pwn 0.5.740 → 0.5.742

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4abf337af5fb9173890e87ee2d6d8523f93f62c6d9453d1fec9431f650f04a3e
-  data.tar.gz: 2639a24b9b3b1895e392b8168a604270b9f43118c743919c7b8348ec8f4dd929
+  metadata.gz: aae26246e4b23381c5f727d27100f6a10d37d955f2c9a875ad63274d3397219b
+  data.tar.gz: 1a0abc7df30321bd4618a8db3d356fa72e9b6cc13f6055b5f71bf4fb1b4ec90a
 SHA512:
-  metadata.gz: e383699557934dab9374bef09204e3e37c0e4b255a3dd3c13ef1597c265fd46b7b71bb79dd8094d2fb42aea71512e01b5a7bce9eae08a3f74d8dfb7639f8ff00
-  data.tar.gz: 6f1aea7cd79a34738923014fbc13024797c614c33e28058ab8b565402f665ccb464aa440c148291a385f4ad6b2617412d42b3c526df5d2f6cdff349149872c9d
+  metadata.gz: 5b680d2d2d3eb756642d68a6309a36a5d551100131b58323954bd402c73f554515304ecfb005a42e96ab15a385f16d717495cf527c2bf17c87434567401d0dd0
+  data.tar.gz: 7b51570ad19e664e45ca69925619fdbdda6272f985d8627f4c247815b469de19cb11bdfa942433480bbc38792127a8b39e45e56c08c8c73ffe517318ad004396

data/Gemfile

@@ -22,7 +22,7 @@ gem 'brakeman', '8.0.6'
 gem 'bson', '5.2.0'
 gem 'bundler', '>=4.0.21'
 gem 'bundler-audit', '>=0.9.3'
-gem 'bunny', '3.3.0'
+gem 'bunny', '3.4.0'
 gem 'colorize', '1.1.0'
 gem 'credit_card_validations', '9.0.0'
 gem 'curses', '1.7.0'

data/etc/default_skills/pwn/plugins/sandbox/driver/SKILL.md

@@ -28,13 +28,20 @@ Class methods take `(opts = {})` and read `opts`.
 
 ```ruby
 PWNSandboxDriver.help
-PWNSandboxDriver.help(opts)
+PWNSandboxDriver.available?(opts)
 ```
 
 ## Public methods
 
 - `authors`
 - `help`
+- `available?`
+- `bounded`
+- `execute`
+- `fuzz`
+- `inside`
+- `main`
+- `snapshot`
 
 ## Source
 

data/lib/pwn/ai/agent/registry.rb

@@ -144,12 +144,31 @@ module PWN
 
           pool = apply_preference({ items: pool }.merge(pref_fwd))
           pool.map do |entry|
-            schema = entry.schema
+            schema = entry.schema.merge(parameters: explicit_root_types(schema: entry.schema[:parameters]))
             schema = schema.merge(description: "#{schema[:description]} #{mcp[:description]}") if entry.name == 'mcp'
             { type: 'function', function: schema }
           end
         end
 
+        # Providers inspect union branches independently of their object parent.
+        # Inherit only along same-instance combinators, never into properties or
+        # array items (which may legitimately be scalar/object unions).
+        private_class_method def self.explicit_root_types(opts = {})
+          schema = opts[:schema]
+          return schema unless schema.is_a?(Hash)
+
+          result = schema.dup
+          type = schema[:type] || schema['type'] || opts[:inherited_type]
+          result[:type] = type if type && !schema.key?(:type) && !schema.key?('type')
+          %i[anyOf oneOf allOf].each do |combiner|
+            key = schema.key?(combiner) ? combiner : combiner.to_s
+            next unless schema[key].is_a?(Array)
+
+            result[key] = schema[key].map { |branch| explicit_root_types(schema: branch, inherited_type: type) }
+          end
+          result
+        end
+
         # Supported Method Parameters::
         # order = PWN::AI::Agent::Registry.preference_order(
         #   order: 'optional - Array of tool names; explicit nil/[] disables',

data/lib/pwn/ai/grok.rb

@@ -476,7 +476,7 @@ module PWN
                 extra: '429 retries exhausted', error: e
               )
             end
-            return "#{e.message}: #{e.response}"
+            raise
           end
           sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry
@@ -497,8 +497,10 @@ module PWN
           nil
         end
       rescue RestClient::ExceptionWithResponse => e
-        puts "ERROR: #{e.message}: #{e.response}" unless opts[:quiet]
-        "#{e.message}: #{e.response}" if opts[:quiet]
+        # Keep the HTTP type/response for callers, and surface provider diagnostics
+        # instead of turning failed requests into nil or unparseable JSON text.
+        e.message = "Grok HTTP #{e.http_code} (#{http_method.to_s.upcase} #{rest_call}): #{e.response&.body}"
+        raise
       rescue StandardError => e
         case e.message
         when '400 Bad Request', '404 Resource Not Found'

data/lib/pwn/ai/ollama.rb

@@ -182,7 +182,7 @@ module PWN
                 extra: '429 retries exhausted', error: e
               )
             end
-            return "#{e.message}: #{e.response}"
+            raise
           end
           sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry

data/lib/pwn/ai/open_web_ui.rb

@@ -207,7 +207,7 @@ module PWN
                 extra: '429 retries exhausted', error: e
               )
             end
-            return "#{e.message}: #{e.response}"
+            raise
           end
           sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry

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

@@ -6,6 +6,7 @@ require 'json'
 require 'base64'
 require 'pry'
 require 'reline'
+require 'io/wait'
 
 module PWN
   module Plugins
@@ -134,10 +135,12 @@ module PWN
 
               # Curses owns input and rendering until this command returns to Pry.
               PWN.const_set(:MeshEvents, Queue.new)
-              PWN::Plugins::REPL.send(:mesh_start_rx!, env: meshtastic_env, obj: mesh_obj)
-              PWN::Plugins::REPL.send(:mesh_refresh_ui!, env: meshtastic_env)
-              PWN::Plugins::REPL.send(:mesh_ui_puts, text: 'Ready. /menu opens settings. Incoming channel messages appear here.')
-              PWN::Plugins::REPL.send(:mesh_console_loop, pry: pi)
+              PWN::Plugins::REPL.send(:mesh_capture_output, run: proc {
+                PWN::Plugins::REPL.send(:mesh_start_rx!, env: meshtastic_env, obj: mesh_obj)
+                PWN::Plugins::REPL.send(:mesh_refresh_ui!, env: meshtastic_env)
+                PWN::Plugins::REPL.send(:mesh_ui_puts, text: 'Ready. /menu opens settings. Incoming channel messages appear here.')
+                PWN::Plugins::REPL.send(:mesh_console_loop, pry: pi)
+              })
             rescue StandardError => e
               raise e
             ensure
@@ -146,6 +149,15 @@ module PWN
           end
         end
         PWN_MESH_TRANSPORTS = %i[serial bluetooth tcp mqtt].freeze
+        # meshtastic 0.0.184 loses protobuf defaults in Data#to_h. Empty
+        # decoded data is not an unsupported application payload.
+        EMPTY_DATA_DECODER = Module.new do
+          define_method(:decode_payload) do |opts = {}|
+            return nil if opts[:payload].nil? && opts[:msg_type].nil?
+
+            super(opts)
+          end
+        end
 
         # Meshtastic transport for pwn-mesh: auto (probe order) or a pinned kind.
         class << PWN::Plugins::REPL # rubocop:disable Metrics/ClassLength
@@ -557,6 +569,7 @@ module PWN
 
           # Subscribe for inbound TEXT_MESSAGE_APP frames.
           def mesh_subscribe(opts = {})
+            Meshtastic::MeshInterface.prepend(Mesh::EMPTY_DATA_DECODER) unless Meshtastic::MeshInterface.ancestors.include?(Mesh::EMPTY_DATA_DECODER)
             env = opts[:env] || {}
             obj = opts[:obj]
             psks = opts[:psks]
@@ -1002,7 +1015,13 @@ module PWN
               event = PWN::MeshEvents.pop(true)
               next if event[:obj] && (!PWN.const_defined?(:MeshObj) || !event[:obj].equal?(PWN::MeshObj))
 
-              event[:msg] ? mesh_handle_rx(msg: event[:msg]) : mesh_ui_puts(text: event[:text])
+              if event[:notice]
+                mesh_notice(text: event[:notice])
+              elsif event[:msg]
+                mesh_handle_rx(msg: event[:msg])
+              else
+                mesh_ui_puts(text: event[:text])
+              end
             end
           rescue ThreadError
             nil
@@ -1059,6 +1078,10 @@ module PWN
 
           def mesh_ui_puts(opts = {})
             text = opts[:text].to_s
+            if PWN.const_defined?(:MeshEvents) && text.match?(/warning|error|failed|disconnect|persist skipped|unknown command/i)
+              PWN::MeshEvents << { notice: text }
+              return text
+            end
             if PWN.const_defined?(:MeshRxBodyWin) && PWN.const_defined?(:MeshMutex)
               win = PWN.const_get(:MeshRxBodyWin)
               mutex = PWN.const_get(:MeshMutex)
@@ -1079,6 +1102,79 @@ module PWN
             text
           end
 
+          def mesh_capture_output(opts = {})
+            original_out = $stdout
+            original_err = $stderr
+            input, output = IO.pipe
+            output.sync = true
+            events = PWN::MeshEvents
+            collector = Thread.new do
+              loop do
+                text = input.readpartial(4096)
+                begin
+                  text << input.readpartial(4096) while text.bytesize < 16_384 && input.wait_readable(0.02)
+                rescue EOFError
+                  # Flush the last diagnostic even when the TUI is closing.
+                end
+                events << { notice: text.force_encoding(Encoding::UTF_8).scrub }
+              end
+            rescue IOError
+              nil
+            end
+            $stdout = output
+            $stderr = output
+            opts[:run].call
+          ensure
+            $stdout = original_out
+            $stderr = original_err
+            output&.close
+            collector&.join(1)
+            collector&.kill
+            input&.close
+          end
+
+          def mesh_notice(opts = {})
+            width = [Curses.cols - 2, 80].min
+            lines = mesh_wrap_text(text: opts[:text].to_s, width: [width - 4, 1].max)
+            height = [lines.size + 5, Curses.lines - 2].min
+            win = Curses::Window.new(height, width, (Curses.lines - height) / 2, (Curses.cols - width) / 2)
+            win.keypad(true)
+            offset = 0
+            loop do
+              win.erase
+              mesh_box!(win: win)
+              win.setpos(0, 2)
+              win.attron(Curses.color_pair(20) | Curses::A_BOLD)
+              win.addstr(' NOTICE ')
+              win.attroff(Curses.color_pair(20) | Curses::A_BOLD)
+              lines.drop(offset).first([height - 4, 1].max).each_with_index do |line, index|
+                win.setpos(index + 1, 2)
+                win.addstr(line)
+              end
+              win.setpos(height - 2, (width - 2) / 2)
+              win.attron(Curses.color_pair(20) | Curses::A_BOLD | Curses::A_REVERSE)
+              win.addstr('Ok')
+              win.attroff(Curses.color_pair(20) | Curses::A_BOLD | Curses::A_REVERSE)
+              win.refresh
+              key = opts[:getch] ? opts[:getch].call : win.getch
+              break if [10, 13, "\n", "\r", Curses::KEY_ENTER].include?(key)
+
+              offset = [offset - 1, 0].max if key == Curses::KEY_UP
+              offset += 1 if key == Curses::KEY_DOWN && offset < lines.size - (height - 4)
+            end
+          ensure
+            win&.close
+            %i[MeshRxHeaderWin MeshRxFrameWin MeshRxBodyWin MeshTxWin].each do |name|
+              next unless PWN.const_defined?(name)
+
+              pane = PWN.const_get(name)
+              pane.touch
+              pane.refresh
+            end
+          end
+
+          private :mesh_capture_output, :mesh_notice
+
           # Drop the submitted TX buffer so the next prompt is empty (Reline keeps the old line).
           def mesh_reset_input!(opts = {})
             return opts if PWN.const_defined?(:MeshEvents)
@@ -1264,7 +1360,25 @@ module PWN
             psks = mesh_active_psks(env: env) if psks.empty?
             PWN.const_set(:MeshRxState, { last_from: nil, last_line: nil }) unless PWN.const_defined?(:MeshRxState)
             events = PWN.const_defined?(:MeshEvents) ? PWN::MeshEvents : Queue.new
+            kind = mesh_bound_transport(env: env)
+            interval = Float(opts.fetch(:heartbeat_interval, 30))
+            raise ArgumentError, 'heartbeat interval must be positive and finite' unless interval.positive? && interval.finite?
+
             thread = Thread.new do
+              heartbeat = if obj.is_a?(Hash) && %i[serial bluetooth tcp].include?(kind)
+                            Thread.new do
+                              transport = { serial: Meshtastic::Serial, bluetooth: Meshtastic::Bluetooth, tcp: Meshtastic::TCP }.fetch(kind)
+                              bytes = Meshtastic::ToRadio.new(heartbeat: Meshtastic::Heartbeat.new(nonce: 0)).to_proto
+                              loop do
+                                break if obj[:closing]
+
+                                transport.send_to_radio({ "#{kind}_obj": obj, to_radio: bytes })
+                                sleep interval
+                              end
+                            rescue StandardError => e
+                              events << { text: "RX keepalive failed: #{e.class}: #{e.message}", obj: obj }
+                            end
+                          end
               mesh_subscribe(
                 env: env,
                 obj: obj,
@@ -1276,6 +1390,9 @@ module PWN
               events << { text: 'RX stopped: transport stream closed. Use /transport to reconnect.', obj: obj }
             rescue StandardError => e
               events << { text: "RX failed: #{e.class}: #{e.message}", obj: obj }
+            ensure
+              heartbeat&.kill
+              heartbeat&.join
             end
             PWN.send(:remove_const, :MeshSubThread) if PWN.const_defined?(:MeshSubThread)
             PWN.const_set(:MeshSubThread, thread)
@@ -1546,13 +1663,17 @@ module PWN
             if decoded[:emoji].to_i.zero?
               messages[[scope, id]] = { from: opts[:from], text: text } if id.positive?
               messages.shift while messages.size > 1000
-              return text
+              return text unless decoded[:reply_id].to_i.positive?
             end
 
             original = messages[[scope, decoded[:reply_id].to_i]]
             original ||= mesh_reaction_original(reply_id: decoded[:reply_id], index: opts[:index])
             target = original ? "#{original[:from]} >> #{original[:text]}" : "original message unavailable (packet #{decoded[:reply_id].to_i})"
-            "Reacted to: \"#{target}\" with: #{text}."
+            if decoded[:emoji].to_i.positive?
+              "Reacted to: \"#{target}\" with: #{text}."
+            else
+              "Replied to: \"#{target}\" with: #{text}"
+            end
           end
 
           def mesh_reaction_original(opts = {})
@@ -2058,7 +2179,7 @@ module PWN
             end
             true
           rescue StandardError => e
-            warn "[pwn-mesh] persist skipped: #{e.class}: #{e.message}"
+            mesh_ui_puts(text: "[pwn-mesh] persist skipped: #{e.class}: #{e.message}")
             false
           end
 

data/lib/pwn/version.rb

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

data/spec/lib/pwn/ai/agent/registry_spec.rb

@@ -47,6 +47,33 @@ describe PWN::AI::Agent::Registry do
     expect(names.length).to eq(described_class::CORE_TOOLS.length)
   end
 
+  it 'exports explicitly object-typed root alternatives without changing registered schemas' do
+    described_class.discover
+    original = Marshal.dump(described_class.lookup(name: 'artifact_read').schema)
+    definitions = described_class.definitions(core_only: false, top_k: 0)
+    check = lambda do |schema|
+      %i[anyOf oneOf allOf].each do |key|
+        Array(schema[key]).each do |branch|
+          expect(branch[:type]).to eq('object')
+          check.call(branch)
+        end
+      end
+    end
+    definitions.each { |tool| check.call(tool[:function][:parameters]) }
+    tool = definitions.find { |entry| entry[:function][:name] == 'artifact_read' }
+    expect(tool[:function][:parameters][:anyOf].map { |branch| branch[:required] }).to eq([%w[handle], %w[path], %w[ref]])
+    expect(Marshal.dump(described_class.lookup(name: 'artifact_read').schema)).to eq(original)
+  end
+
+  it 'preserves property-level scalar unions and explicit branch types' do
+    schema = { 'type' => 'object', 'oneOf' => [{ 'required' => ['value'] }],
+               'properties' => { 'value' => { 'anyOf' => [{ 'type' => 'string' }, { 'type' => 'object' }] } } }
+    normalized = described_class.send(:explicit_root_types, schema: schema)
+    expect(normalized['oneOf'].first[:type]).to eq('object')
+    expect(normalized['properties']).to eq(schema['properties'])
+    expect(schema['oneOf'].first).to eq('required' => ['value'])
+  end
+
   it 'advertises the MCP broker for a named backend in the normal core-only prompt path' do
     described_class.discover
     request = 'Use combo.nation to inspect the menu catalog'

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

@@ -18,6 +18,111 @@ describe PWN::AI::Grok do
     expect(src).to match(/openai_wire_messages/)
   end
 
+  describe '.chat_with_tools HTTP failures' do
+    let(:messages) { [{ role: 'user', content: 'hello' }] }
+    let(:body) { '{"error":"Invalid schema: tools[0].function.parameters requires properties"}' }
+    let(:response) { instance_double(RestClient::Response, code: 400, body: body, to_s: body) }
+    let(:error) { RestClient::BadRequest.new(response) }
+
+    before do
+      stub_const('PWN::Env', { ai: { grok: { key: 'test-key', model: 'test-model' } } })
+      allow(PWN::Plugins::TransparentBrowser).to receive(:open).with(browser_type: :rest).and_return(browser: RestClient)
+      allow(PWN::AI::Agent::ToolGuard).to receive(:protect_http!)
+      allow(PWN::AI::Agent::PromptCache).to receive(:enabled?).and_return(false)
+      allow(PWN::Plugins::TTYSpinner).to receive(:stop)
+      allow(RestClient::Request).to receive(:execute).and_raise(error)
+    end
+
+    it 'serializes explicit artifact_read branch types from the real registry' do
+      tools = PWN::AI::Agent::Registry.definitions(core_only: true)
+      allow(RestClient::Request).to receive(:execute).and_return(
+        '{"choices":[{"message":{"role":"assistant","content":"hello"}}]}'
+      )
+
+      described_class.chat_with_tools(messages: messages, tools: tools)
+
+      expect(RestClient::Request).to have_received(:execute) do |request|
+        payload = JSON.parse(request[:payload])
+        artifact_read = payload.fetch('tools').find { |tool| tool.dig('function', 'name') == 'artifact_read' }
+        expect(artifact_read).not_to be_nil
+        branches = artifact_read.fetch('function').fetch('parameters').fetch('anyOf')
+        expect(branches).not_to be_empty
+        expect(branches).to all(include('type' => 'object'))
+      end
+    end
+
+    context 'when rate limits exhaust the retry budget' do
+      let(:body) { '{"error":"rate limit exceeded"}' }
+      let(:response) { instance_double(RestClient::Response, code: 429, body: body, to_s: body, headers: { retry_after: '2' }) }
+      let(:error) { RestClient::TooManyRequests.new(response) }
+
+      it 'raises the HTTP error after five attempts and four Retry-After waits' do
+        allow(described_class).to receive(:rand).with(0.3..5.0).and_return(0.5)
+        allow(described_class).to receive(:sleep)
+        allow(PWN::AI::HttpRetry).to receive(:report_event)
+
+        expect do
+          described_class.chat_with_tools(messages: messages)
+        end.to raise_error(RestClient::TooManyRequests) { |raised|
+          expect(raised.message).to include('HTTP 429', body)
+        }
+        expect(RestClient::Request).to have_received(:execute).exactly(5).times
+        expect(described_class).to have_received(:sleep).with(2.5).exactly(4).times
+      end
+    end
+
+    context 'when the request times out' do
+      let(:error) { RestClient::Exceptions::ReadTimeout.new }
+
+      it 'preserves the default five attempts and nil on exhaustion' do
+        allow(PWN::AI::HttpRetry).to receive(:report_event)
+        expect(described_class.chat_with_tools(messages: messages)).to be_nil
+        expect(RestClient::Request).to have_received(:execute).with(hash_including(timeout: 180)).exactly(5).times
+      end
+
+      it 'keeps quiet sidecars single-shot and silent' do
+        expect(PWN::AI::HttpRetry).not_to receive(:report_event)
+        expect(described_class.chat_with_tools(messages: messages, quiet: true)).to be_nil
+        expect(RestClient::Request).to have_received(:execute).once
+      end
+
+      it 'keeps short timeouts single-shot' do
+        allow(PWN::AI::HttpRetry).to receive(:report_event)
+        expect(described_class.chat_with_tools(messages: messages, timeout: 10)).to be_nil
+        expect(RestClient::Request).to have_received(:execute).with(hash_including(timeout: 10)).once
+      end
+
+      it 'returns the successful response after a transient timeout' do
+        calls = 0
+        allow(RestClient::Request).to receive(:execute) do
+          calls += 1
+          raise error if calls == 1
+
+          '{"choices":[{"message":{"role":"assistant","content":"hello"}}]}'
+        end
+        allow(PWN::AI::HttpRetry).to receive(:report_event)
+        result = described_class.chat_with_tools(messages: messages)
+        expect(result.dig(:assistant_message, :content)).to eq('hello')
+        expect(RestClient::Request).to have_received(:execute).twice
+      end
+    end
+
+    [false, true].each do |quiet|
+      it "propagates actionable schema errors without printing (quiet=#{quiet})" do
+        expect do
+          expect do
+            described_class.chat_with_tools(messages: messages, quiet: quiet)
+          end.to raise_error(RestClient::BadRequest) { |raised|
+            expect(raised.response).to equal(response)
+            expect(raised.message).to include('Grok', 'HTTP 400', 'chat/completions', body)
+          }
+        end.not_to output.to_stdout
+        expect(RestClient::Request).to have_received(:execute).once
+        expect(PWN::Plugins::TTYSpinner).to have_received(:stop)
+      end
+    end
+  end
+
   it 'does not expose get_plan_usage' do
     expect(described_class).not_to respond_to(:get_plan_usage)
   end

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

@@ -3,6 +3,23 @@
 require 'spec_helper'
 
 describe PWN::AI::Ollama do
+  [false, true].each do |quiet|
+    it "raises an actionable exhausted 429 instead of parsing error text (quiet=#{quiet})" do
+      stub_const('PWN::Env', { ai: { ollama: { model: 'fixture', base_uri: 'http://example.test' } } })
+      allow(PWN::Plugins::TransparentBrowser).to receive(:open).and_return(browser: RestClient)
+      response = instance_double(RestClient::Response, code: 429, body: 'rate limit exceeded', to_s: 'rate limit exceeded', headers: { retry_after: '2' })
+      allow(RestClient::Request).to receive(:execute).and_raise(RestClient::TooManyRequests.new(response))
+      allow(described_class).to receive(:sleep)
+      allow(described_class).to receive(:rand).and_return(0.5)
+      allow(PWN::AI::HttpRetry).to receive(:report_event)
+      expect do
+        described_class.chat_with_tools(messages: [{ role: 'user', content: 'hello' }], quiet: quiet)
+      end.to raise_error(RuntimeError, /Ollama.*429.*rate limit exceeded/)
+      expect(RestClient::Request).to have_received(:execute).exactly(5).times
+      expect(described_class).to have_received(:sleep).with(2.5).exactly(4).times
+    end
+  end
+
   it 'should display information for authors' do
     authors_response = PWN::AI::Ollama
     expect(authors_response).to respond_to :authors

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

@@ -3,6 +3,23 @@
 require 'spec_helper'
 
 describe PWN::AI::OpenWebUI do
+  [false, true].each do |quiet|
+    it "raises an actionable exhausted 429 instead of parsing error text (quiet=#{quiet})" do
+      stub_const('PWN::Env', { ai: { openwebui: { model: 'fixture', base_uri: 'http://example.test', key: 'fixture-key' } } })
+      allow(PWN::Plugins::TransparentBrowser).to receive(:open).and_return(browser: RestClient)
+      response = instance_double(RestClient::Response, code: 429, body: 'rate limit exceeded', to_s: 'rate limit exceeded', headers: { retry_after: '2' })
+      allow(RestClient::Request).to receive(:execute).and_raise(RestClient::TooManyRequests.new(response))
+      allow(described_class).to receive(:sleep)
+      allow(described_class).to receive(:rand).and_return(0.5)
+      allow(PWN::AI::HttpRetry).to receive(:report_event)
+      expect do
+        described_class.chat_with_tools(messages: [{ role: 'user', content: 'hello' }], quiet: quiet)
+      end.to raise_error(RuntimeError, /Open WebUI.*429.*rate limit exceeded/)
+      expect(RestClient::Request).to have_received(:execute).exactly(5).times
+      expect(described_class).to have_received(:sleep).with(2.5).exactly(4).times
+    end
+  end
+
   it 'should display information for authors' do
     authors_response = PWN::AI::OpenWebUI
     expect(authors_response).to respond_to :authors

data/spec/lib/pwn/plugins/repl_mesh_channel_route_spec.rb

@@ -80,6 +80,10 @@ describe PWN::Plugins::REPL, 'mesh packet channel routing' do
       expect(win).to have_received(:addstr).with(" Reacted to: \"!aabbccdd >> Meet at noon\" with: 👍.\n")
       expect(win).to have_received(:attron).with((local ? 23 : 21) | Curses::A_BOLD).at_least(:once)
       expect(described_class).to have_received(:mesh_maybe_dispatch_to_pwn_ai).once
+      reply = Meshtastic::MeshPacket.new(id: 125, from: 0xb0b, to: 0xffffffff, channel: 1,
+                                         decoded: { portnum: :TEXT_MESSAGE_APP, payload: 'See you there!', reply_id: 123 }).to_h
+      described_class.send(:mesh_handle_rx, local: local, msg: { packet: reply })
+      expect(win).to have_received(:addstr).with(" Replied to: \"!aabbccdd >> Meet at noon\" with: See you there!\n")
     end
   end
 
@@ -140,6 +144,8 @@ describe PWN::Plugins::REPL, 'mesh packet channel routing' do
     text = described_class.send(:mesh_reaction_text, packet: packet, text: '👍', channel: 'LongFast', index: 1)
     expect(text).to eq('Reacted to: "original message unavailable (packet 999)" with: 👍.')
     packet[:decoded][:emoji] = 0
+    expect(described_class.send(:mesh_reaction_text, packet: packet, text: 'Reply')).to eq('Replied to: "original message unavailable (packet 999)" with: Reply')
+    packet[:decoded].delete(:reply_id)
     expect(described_class.send(:mesh_reaction_text, packet: packet, text: '👍')).to eq('👍')
   end
 

data/spec/lib/pwn/plugins/repl_mesh_history_spec.rb

@@ -1,8 +1,130 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'meshtastic'
 
 describe PWN::Plugins::REPL, 'mesh compose history' do
+  it 'does not warn when the real subscriber sees an empty protobuf Data message' do
+    stub_const('PWN::MeshTransport', :serial)
+    queue = Queue.new
+    encoded = Meshtastic::FromRadio.new(packet: { decoded: Meshtastic::Data.new }).to_proto
+    queue << Meshtastic::FromRadio.decode(encoded)
+    queue << Meshtastic::FromRadio.new(queueStatus: { free: 1 })
+    queue.close
+    received = []
+    output = StringIO.new
+    old = $stdout
+    $stdout = output
+    described_class.send(:mesh_subscribe, obj: { from_radio_queue: queue }, psks: {}, on_message: proc { |message| received << message })
+    expect(received.size).to eq(2)
+    expect(output.string).not_to include("Can't decode")
+    Meshtastic::MeshInterface.new.decode_payload(payload: 'unsupported', msg_type: :PRIVATE_APP)
+    expect(output.string).to include("Can't decode", 'unsupported')
+  ensure
+    $stdout = old
+  end
+
+  it 'queues warnings for acknowledgement instead of writing through the TUI' do
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    expect(described_class).not_to receive(:puts)
+    described_class.send(:mesh_ui_puts, text: 'WARNING: fixture warning')
+    expect(events.pop(true)).to eq(notice: 'WARNING: fixture warning')
+  end
+
+  it 'displays queued diagnostics on the UI thread' do
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    events << { notice: 'RX failed: fixture' }
+    expect(described_class).to receive(:mesh_notice).with(text: 'RX failed: fixture')
+    described_class.send(:mesh_drain_events)
+  end
+
+  it 'captures dependency stdout and stderr and restores both streams on failure' do
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    original = [$stdout, $stderr]
+    expect do
+      described_class.send(:mesh_capture_output, run: proc {
+        puts 'WARNING: decoder fixture'
+        warn 'ERROR: transport fixture'
+        raise IOError, 'fixture'
+      })
+    end.to raise_error(IOError, 'fixture')
+    expect([$stdout, $stderr]).to eq(original)
+    output = []
+    output << events.pop(true)[:notice] until events.empty?
+    expect(output.join).to include('WARNING: decoder fixture', 'ERROR: transport fixture')
+  end
+
+  it 'centers a reverse-colored Ok button and repaints the underlying panes' do
+    win = double('notice', maxx: 78, maxy: 6)
+    %i[keypad erase setpos addstr refresh close attron attroff].each { |method| allow(win).to receive(method) }
+    allow(Curses).to receive(:color_pair).with(20).and_return(5120)
+    allow(Curses).to receive(:cols).and_return(80)
+    allow(Curses).to receive(:lines).and_return(24)
+    allow(Curses::Window).to receive(:new).and_return(win)
+    pane = double('pane', touch: nil, refresh: nil)
+    stub_const('PWN::MeshTxWin', pane)
+    keys = ["\e", 'q', "\n"]
+    described_class.send(:mesh_notice, text: 'Decoder warning', getch: proc { keys.shift })
+    expect(keys).to be_empty
+    expect(win).to have_received(:addstr).with('Ok').exactly(3).times
+    expect(win).not_to have_received(:addstr).with(a_string_matching(/Acknowledged|Enter/))
+    expect(win).to have_received(:setpos).with(4, 38).exactly(3).times
+    expect(win).to have_received(:attron).with(5120 | Curses::A_BOLD | Curses::A_REVERSE).exactly(3).times
+    expect(win).to have_received(:attroff).with(5120 | Curses::A_BOLD | Curses::A_REVERSE).exactly(3).times
+    expect(win).to have_received(:close)
+    expect(pane).to have_received(:touch)
+  end
+
+  it 'keeps an idle PhoneAPI session alive and stops its heartbeat with the subscriber' do
+    events = Queue.new
+    beats = Queue.new
+    release = Queue.new
+    obj = {}
+    stub_const('PWN::MeshEvents', events)
+    stub_const('PWN::MeshObj', obj)
+    stub_const('PWN::MeshTransport', :serial)
+    allow(Meshtastic::Serial).to receive(:send_to_radio) do |args|
+      beats << [Thread.current, Meshtastic::ToRadio.decode(args[:to_radio])]
+    end
+    allow(described_class).to receive(:mesh_subscribe) do |args|
+      release.pop
+      args[:on_message].call(packet: { decoded: { portnum: 1, payload: 'after idle' } })
+    end
+    thread = described_class.send(:mesh_start_rx!, env: { channel: {} }, obj: obj, heartbeat_interval: 0.01)
+    first = beats.pop(timeout: 1)
+    second = beats.pop(timeout: 1)
+    expect(first).not_to be_nil
+    expect(second).not_to be_nil
+    expect(second.last.payload_variant).to eq(:heartbeat)
+    expect(second.last.heartbeat.nonce).to eq(0)
+    release << true
+    expect(thread.join(1)).to eq(thread)
+    expect(first.first).not_to be_alive
+    expect(events.pop[:msg].dig(:packet, :decoded, :payload)).to eq('after idle')
+  ensure
+    thread&.kill
+    thread&.join(1)
+  end
+
+  it 'drains incoming messages during idle input polls without a keypress' do
+    pi = double('pry', config: double('config', pwn_mesh: true))
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    message = { packet: { decoded: { portnum: 1, payload: 'idle RX' } } }
+    polls = 0
+    allow(described_class).to receive(:mesh_draw_input)
+    expect(described_class).to receive(:mesh_handle_rx).with(msg: message)
+    reader = proc do
+      polls += 1
+      events << { msg: message } if polls == 20
+      polls > 20 ? "\u0004" : nil
+    end
+    described_class.send(:mesh_console_loop, pry: pi, getch: reader)
+  end
+
   it 'recalls submissions with Up/Down and restores the unfinished draft and cursor' do
     config = double('config', pwn_mesh: true)
     pry = double('pry', config: config)

data/third_party/pwn_rdoc.jsonl

@@ -685,6 +685,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.discover Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.discover`: Supported Method Parameters\n\nnames = PWN::AI::Agent::Registry.discover(\n\nforce: 'optional - re-require tool files even if already discovered (default false)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.domain_pin_names Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.domain_pin_names`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.eager_load! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.eager_load!`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.explicit_root_types Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.explicit_root_types`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.lookup Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.lookup`: Supported Method Parameters\n\nentry = PWN::AI::Agent::Registry.lookup(\n\nname: 'required - registered tool name'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Registry.mcp_routing Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Registry.mcp_routing`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.740
+  version: 0.5.742
 platform: ruby
 authors:
 - 0day Inc.
@@ -169,14 +169,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: 3.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: 3.4.0
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement