pwn 0.5.741 → 0.5.743

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3eb74de135994d78ce8af6b31729ef0622495f0cbe6ff72ddb5ecce5662a5aa7
-  data.tar.gz: 3f2d855056ef2cce6424ac399393e38492970850baa36fde37419d5e798ca2f8
+  metadata.gz: 8089c1c616fe3d19f70170b55204b0dd762a14faa40432e6acf421bd6d55197d
+  data.tar.gz: 6633cdc11ab8b811913d6b6e30608a79fa85c06c5bde599d4155c9c63d5a3884
 SHA512:
-  metadata.gz: 995de4dfb6c55750ed90c2f8c282c4d6ca14e876f41ec207b71aecdc1d162ab69359a20d3d479115c4aea9b9eee7d04d9c3bd1678ff73d1e1c06dbefcbef7c46
-  data.tar.gz: 30c2d6602caa5d1fef740508751d4457d69c7f51d861a6260e57f65251c5050d2425c21dad3e946181aa1776345f413e2a035ec3bcf411ae4eedce21441d61d4
+  metadata.gz: 83c1b09ae27724b7e5df7972f018f11b7bee7f77e38d295c45395bf4c828f6c57e9736306687ae243e1fc05dc4dd63e4b33407d4101b916c2e32a8b241f39958
+  data.tar.gz: 19ad087ec133a1194b2fd60d7348edff887b94940647b5a0e34792fa5084742dcb7a04f213ee17b404e4fffda5fc1b8db4821fd1bc6c047c0867c96a2752d8af

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/jobs.rb

@@ -49,10 +49,12 @@ module PWN
                            'PWN::Plugins::Jobs.supervise(root: ARGV[0], id: ARGV[1])', root, id,
                            in: File::NULL, out: File::NULL, err: File::NULL, close_others: true)
             Process.detach(worker)
-            deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 2
+            row[:worker_pid] = worker
+            persist(root: root, row: row)
+            deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 8
             loop do
               row = load_job(id: id)
-              break if row[:worker_pid] || row[:status] != 'RUNNING' || Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+              break if row[:worker_identity] || row[:status] != 'RUNNING' || Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
 
               sleep 0.02
             end
@@ -372,7 +374,11 @@ module PWN
           next unless row[:status] == 'RUNNING'
 
           begin
-            Process.setsid
+            begin
+              Process.setsid
+            rescue Errno::EPERM
+              nil
+            end
             row.merge!(worker_pid: Process.pid, worker_identity: SecureRandom.hex(16), started_at: Time.now.utc.iso8601(6))
             pid = spawn(row[:env].transform_keys(&:to_s), '/bin/sh', '-c', row[:command], chdir: row[:cwd],
                                                                                           in: File::NULL, %i[out err] => [row[:log], 'ab'], pgroup: true, close_others: true)

data/lib/pwn/plugins/redb.rb

@@ -181,7 +181,7 @@ module PWN
         current = nil
         dump.each_line do |line|
           current = Regexp.last_match(1) if line =~ /<([^>]+)>:/
-          next unless current && (line =~ /call\w*\s+.*<([^>@]+)/ || line =~ /call\w*\s+([A-Za-z_]\w*)(?:@plt)?/)
+          next unless current && (line =~ /\b(?:call\w*|blx?r?|jalr?)\b.*<([^>@]+)/ || line =~ /\b(?:call\w*|blx?r?|jalr?)\s+([A-Za-z_]\w*)(?:@plt)?/)
 
           db.execute('INSERT INTO xrefs(src, dst) VALUES(?,?)', [current, Regexp.last_match(1)])
         end

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

@@ -614,31 +614,49 @@ module PWN
           end
 
           def mesh_tx_row_ready?(opts = {})
-            return false unless opts.is_a?(Hash)
+            mesh_tx_outcome(opts) == :ok
+          end
+
+          def mesh_tx_outcome(opts = {})
+            return :idle unless opts.is_a?(Hash)
 
             row = opts[:row]
-            return false unless row.is_a?(Hash)
+            return :idle unless row.is_a?(Hash)
 
             packet = row[:packet] || row['packet']
-            return false unless packet.is_a?(Hash)
+            return :idle unless packet.is_a?(Hash)
 
             decoded = packet[:decoded] || packet['decoded']
-            return false unless decoded.is_a?(Hash)
+            return :idle unless decoded.is_a?(Hash)
 
             port = decoded[:portnum] || decoded['portnum']
-            %w[5 ROUTING_APP].include?(port.to_s) || port == :ROUTING_APP
+            return :idle unless %w[5 ROUTING_APP].include?(port.to_s) || port == :ROUTING_APP
+
+            want = opts[:request_id]
+            got = decoded[:request_id] || decoded['request_id']
+            return :idle if want && got && want.to_i != got.to_i
+
+            routing = decoded[:payload] || decoded['payload']
+            routing = Meshtastic::Routing.decode(routing).to_h if routing.is_a?(String)
+            reason = routing[:error_reason] if routing.is_a?(Hash)
+            reason = Meshtastic::Routing::Error.lookup(reason) || reason if reason.is_a?(Integer)
+            name = reason.to_s
+            return :ok if reason.nil? || %w[0 NONE].include?(name)
+            return :rate_limited if name == 'RATE_LIMIT_EXCEEDED'
+
+            :error
           end
 
           def mesh_wait_tx_slot(opts = {})
-            return unless opts.is_a?(Hash)
+            return :ok unless opts.is_a?(Hash)
 
             obj = opts[:obj]
-            return unless obj.is_a?(Hash)
+            return :ok unless obj.is_a?(Hash)
 
             timeout = opts[:timeout]
             timeout = 8 if timeout.nil?
             timeout = Float(timeout)
-            return if timeout <= 0
+            return :ok if timeout <= 0
 
             since = opts[:since].to_i
             deadline = Time.now + timeout
@@ -648,11 +666,11 @@ module PWN
                      else
                        Array(obj[:proto_data])
                      end
-              ready = rows.drop(since).any? do |row|
-                mesh_tx_row_ready?(row: row)
+              rows.drop(since).each do |row|
+                outcome = mesh_tx_outcome(row: row, request_id: opts[:request_id])
+                return outcome unless outcome == :idle
               end
-              return if ready
-              return if Time.now >= deadline
+              return :timeout if Time.now >= deadline
 
               sleep 0.05
             end
@@ -682,6 +700,13 @@ module PWN
                 end
                 bodies << piece
                 offset += piece.length
+                next unless offset < text.length && piece.match?(/[^[:space:]]\z/)
+
+                cut = piece.rindex(/[[:space:]]/)
+                next unless cut&.positive?
+
+                bodies[-1] = piece[0, cut + 1]
+                offset = offset - piece.length + bodies[-1].length
               end
               if bodies.size <= n
                 total = bodies.size
@@ -772,69 +797,77 @@ module PWN
               dm_key = mesh_dm_key(obj: obj, kind: kind, to: dest, radio: radio, timeout: opts.fetch(:key_timeout, 15))
             end
             chunks = mesh_text_chunks(text: opts[:text])
-            chunks.each_with_index do |piece, idx|
-              packet_id = Random.rand(2...0xffffffff)
-              since = obj.is_a?(Hash) ? Array(obj[:proto_data]).size : 0
-              if dm_key
-                bytes = Meshtastic::MeshInterface.new.send_text(from: obj[:my_node_num] || 0, to: dest, channel: radio || 0, text: piece, want_ack: true, psks: nil, last_packet_id: packet_id - 1)
-                packet = Meshtastic::ToRadio.decode(bytes)
-                packet.packet.pki_encrypted = true
-                packet.packet.public_key = dm_key
-                transport = { serial: Meshtastic::Serial, bluetooth: Meshtastic::Bluetooth, tcp: Meshtastic::TCP }.fetch(kind)
-                transport.send_to_radio({ "#{kind}_obj": obj, to_radio: packet.to_proto })
-              else
-                case kind
-                when :serial
-                  tx = { serial_obj: obj, to: dest, text: piece, want_ack: true, last_packet_id: packet_id - 1 }
-                  tx[:channel] = radio unless radio.nil?
-                  Meshtastic::Serial.send_text(tx)
-                when :bluetooth
-                  tx = { bluetooth_obj: obj, to: dest, text: piece, want_ack: true, last_packet_id: packet_id - 1 }
-                  tx[:channel] = radio unless radio.nil?
-                  Meshtastic::Bluetooth.send_text(tx)
-                when :tcp
-                  tx = { tcp_obj: obj, to: dest, text: piece, last_packet_id: packet_id - 1 }
-                  tx[:channel] = radio unless radio.nil?
-                  Meshtastic::TCP.send_text(tx)
+            chunks.each_with_index do |piece, _idx|
+              echoed = false
+              attempts = 0
+              loop do
+                attempts += 1
+                packet_id = Random.rand(2...0xffffffff)
+                since = obj.is_a?(Hash) ? Array(obj[:proto_data]).size : 0
+                if dm_key
+                  bytes = Meshtastic::MeshInterface.new.send_text(from: obj[:my_node_num] || 0, to: dest, channel: radio || 0, text: piece, want_ack: true, psks: nil, last_packet_id: packet_id - 1)
+                  packet = Meshtastic::ToRadio.decode(bytes)
+                  packet.packet.pki_encrypted = true
+                  packet.packet.public_key = dm_key
+                  transport = { serial: Meshtastic::Serial, bluetooth: Meshtastic::Bluetooth, tcp: Meshtastic::TCP }.fetch(kind)
+                  transport.send_to_radio({ "#{kind}_obj": obj, to_radio: packet.to_proto })
                 else
-                  send_psks = psks
-                  send_psks = mesh_channel_psks(env: env) if send_psks.nil? || send_psks.empty?
-                  Meshtastic::MQTT.send_text(
-                    mqtt_obj: obj,
-                    last_packet_id: packet_id - 1,
-                    from: from,
-                    to: dest,
-                    region: mesh_mqtt_region(region: opts[:region], env: env),
-                    topic: mesh_mqtt_topic(env: env, topic: opts[:topic]),
-                    channel: channel,
-                    text: piece,
-                    psks: send_psks
+                  case kind
+                  when :serial
+                    tx = { serial_obj: obj, to: dest, text: piece, want_ack: true, last_packet_id: packet_id - 1 }
+                    tx[:channel] = radio unless radio.nil?
+                    Meshtastic::Serial.send_text(tx)
+                  when :bluetooth
+                    tx = { bluetooth_obj: obj, to: dest, text: piece, want_ack: true, last_packet_id: packet_id - 1 }
+                    tx[:channel] = radio unless radio.nil?
+                    Meshtastic::Bluetooth.send_text(tx)
+                  when :tcp
+                    tx = { tcp_obj: obj, to: dest, text: piece, want_ack: true, last_packet_id: packet_id - 1 }
+                    tx[:channel] = radio unless radio.nil?
+                    Meshtastic::TCP.send_text(tx)
+                  else
+                    send_psks = psks
+                    send_psks = mesh_channel_psks(env: env) if send_psks.nil? || send_psks.empty?
+                    Meshtastic::MQTT.send_text(
+                      mqtt_obj: obj,
+                      last_packet_id: packet_id - 1,
+                      from: from,
+                      to: dest,
+                      region: mesh_mqtt_region(region: opts[:region], env: env),
+                      topic: mesh_mqtt_topic(env: env, topic: opts[:topic]),
+                      channel: channel,
+                      text: piece,
+                      psks: send_psks
+                    )
+                  end
+                end
+                unless echoed
+                  from_id = from.to_s
+                  from_id = mesh_self_node_id(env: env, obj: obj) if from_id.empty?
+                  from_id = mesh_format_node_id(id: from_id)
+                  PWN.send(:remove_const, :MeshLastTx) if PWN.const_defined?(:MeshLastTx)
+                  PWN.const_set(:MeshLastTx, { from: from_id, to: dest, text: piece.to_s, at: Time.now })
+                  mesh_handle_rx(
+                    local: true,
+                    channel_name: channel_name,
+                    msg: {
+                      packet: {
+                        id: packet_id,
+                        channel: radio,
+                        pki_encrypted: !dm_key.nil?,
+                        node_id_from: from_id,
+                        node_id_to: dest,
+                        decoded: { portnum: :TEXT_MESSAGE_APP, payload: piece.to_s }
+                      }
+                    }
                   )
+                  echoed = true
                 end
-              end
-              from_id = from.to_s
-              from_id = mesh_self_node_id(env: env, obj: obj) if from_id.empty?
-              from_id = mesh_format_node_id(id: from_id)
-              PWN.send(:remove_const, :MeshLastTx) if PWN.const_defined?(:MeshLastTx)
-              PWN.const_set(:MeshLastTx, { from: from_id, to: dest, text: piece.to_s, at: Time.now })
-              mesh_handle_rx(
-                local: true,
-                channel_name: channel_name,
-                msg: {
-                  packet: {
-                    id: packet_id,
-                    channel: radio,
-                    pki_encrypted: !dm_key.nil?,
-                    node_id_from: from_id,
-                    node_id_to: dest,
-                    decoded: { portnum: :TEXT_MESSAGE_APP, payload: piece.to_s }
-                  }
-                }
-              )
-              next unless idx + 1 < chunks.size
-              next unless %i[serial bluetooth tcp].include?(kind)
+                break unless %i[serial bluetooth tcp].include?(kind)
 
-              mesh_wait_tx_slot(obj: obj, since: since)
+                slot = mesh_wait_tx_slot(obj: obj, since: since, request_id: packet_id)
+                break if slot == :ok || slot == :timeout || slot == :error || attempts >= 8
+              end
             end
             return unless dm_key && PWN.const_defined?(:MeshPendingDm)
 
@@ -1016,7 +1049,8 @@ module PWN
               next if event[:obj] && (!PWN.const_defined?(:MeshObj) || !event[:obj].equal?(PWN::MeshObj))
 
               if event[:notice]
-                mesh_notice(text: event[:notice])
+                notice = mesh_notice_text(text: event[:notice])
+                mesh_notice(text: notice) if notice
               elsif event[:msg]
                 mesh_handle_rx(msg: event[:msg])
               else
@@ -1102,6 +1136,14 @@ module PWN
             text
           end
 
+          def mesh_notice_text(opts = {})
+            text = opts[:text].to_s.dup.force_encoding(Encoding::UTF_8).scrub
+            text.gsub!(/\e\[[0-9;?]*[A-Za-z]/, '')
+            text.gsub!(/[\x00-\x08\x0b\x0c\x0e-\x1f]/, '')
+            text.strip!
+            text.empty? ? nil : text
+          end
+
           def mesh_capture_output(opts = {})
             original_out = $stdout
             original_err = $stderr
@@ -1116,7 +1158,8 @@ module PWN
                 rescue EOFError
                   # Flush the last diagnostic even when the TUI is closing.
                 end
-                events << { notice: text.force_encoding(Encoding::UTF_8).scrub }
+                notice = mesh_notice_text(text: text)
+                events << { notice: notice } if notice
               end
             rescue IOError
               nil
@@ -1173,7 +1216,7 @@ module PWN
             end
           end
 
-          private :mesh_capture_output, :mesh_notice
+          private :mesh_capture_output, :mesh_notice, :mesh_notice_text
 
           # Drop the submitted TX buffer so the next prompt is empty (Reline keeps the old line).
           def mesh_reset_input!(opts = {})
@@ -1551,7 +1594,7 @@ module PWN
               routing = Meshtastic::Routing.decode(routing).to_h if routing.is_a?(String)
               reason = routing[:error_reason] if routing.is_a?(Hash)
               reason = Meshtastic::Routing::Error.lookup(reason) || reason if reason.is_a?(Integer)
-              mesh_ui_puts(text: "TX failed: packet #{decoded[:request_id]}: #{reason}") if reason && !%w[0 NONE].include?(reason.to_s)
+              mesh_ui_puts(text: "TX failed: packet #{decoded[:request_id]}: #{reason}") if reason && !%w[0 NONE RATE_LIMIT_EXCEEDED].include?(reason.to_s)
               return
             end
             return unless mesh_text_app?(portnum: decoded[:portnum])
@@ -2185,7 +2228,7 @@ module PWN
 
           private :mesh_transport, :mesh_bound_transport, :mesh_layout, :mesh_box!, :mesh_mqtt_region, :mesh_mqtt_topic, :mesh_active_psks, :mesh_device_channel_meta, :mesh_device_channels
           private :mesh_radio_channel, :mesh_radio_index_for_name, :mesh_channel_name_for_index, :mesh_unassigned_slot_map, :mesh_psk_b64, :mesh_psk_same?, :mesh_env_channel_name_for_psk, :mesh_whitelist_name_for_index, :mesh_channel_name_from_topic, :mesh_link_label
-          private :mesh_connect_one, :mesh_connect, :mesh_mqtt_tls?, :mesh_subscribe, :mesh_text_payload_max, :mesh_payload_fits?, :mesh_text_chunks, :mesh_tx_row_ready?, :mesh_wait_tx_slot, :mesh_send_text, :mesh_disconnect, :mesh_compose_send, :mesh_channel_names, :mesh_env_hash
+          private :mesh_connect_one, :mesh_connect, :mesh_mqtt_tls?, :mesh_subscribe, :mesh_text_payload_max, :mesh_payload_fits?, :mesh_text_chunks, :mesh_tx_row_ready?, :mesh_tx_outcome, :mesh_wait_tx_slot, :mesh_send_text, :mesh_disconnect, :mesh_compose_send, :mesh_channel_names, :mesh_env_hash
           private :mesh_submit, :mesh_console_loop, :mesh_drain_events, :mesh_draw_input, :mesh_wrap_text, :mesh_ui_puts, :mesh_menu_root, :mesh_list_devices
           private :mesh_start_rx!, :mesh_channel_psks, :mesh_text_app?, :mesh_rx_text, :mesh_self_node_id, :mesh_decorate_local_id, :mesh_public_psk?, :mesh_channel_securely_encrypted?
           private :mesh_ai_whitelisted?, :mesh_ai_prompt, :mesh_broadcast?, :mesh_reply_target_label, :mesh_handle_rx, :mesh_maybe_dispatch_to_pwn_ai, :mesh_refresh_ui!, :mesh_reconnect!

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.741'
+  VERSION = '0.5.743'
 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/agent/tools/exploitdev_spec.rb

@@ -15,7 +15,7 @@ describe 'PWN::AI::Agent::Tools exploitdev' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'exploitdev')).not_to be_nil
   end
 
-  it 'builds a ret2libc chain end-to-end through Dispatch' do
+  it 'builds a ret2libc chain end-to-end through Dispatch', :x86_64_binary do
     Dir.mktmpdir('pwn-ret2libc-tool-') do |dir|
       src = File.join(dir, 'vuln.c')
       bin = File.join(dir, 'vuln')

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/exploit_dev_spec.rb

@@ -60,7 +60,7 @@ describe PWN::Plugins::ExploitDev do
     expect(row[:gadgets].map { |g| g[:gadget] }).to include(a_string_matching(/pop rdi/i))
   end
 
-  it 'ret2libc builds a packed chain from ELF resolve + pop rdi' do
+  it 'ret2libc builds a packed chain from ELF resolve + pop rdi', :x86_64_binary do
     Dir.mktmpdir('pwn-ret2libc-') do |dir|
       src = File.join(dir, 'vuln.c')
       bin = File.join(dir, 'vuln')

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

@@ -64,7 +64,16 @@ describe PWN::Plugins::Jobs do
 
   it 'pages binary logs with byte offsets and distinguishes EOF from completion' do
     row = described_class.start(command: "printf 'abc\\377def'; sleep 1", max_runtime: 5)
-    first = described_class.job_tail(handle: row[:id], offset: 0, length: 4)
+    first = Timeout.timeout(8) do
+      loop do
+        page = described_class.job_tail(handle: row[:id], offset: 0, length: 4)
+        break page if page[:bytes].to_i.positive?
+
+        raise 'job ended before log bytes' unless page[:status] == 'RUNNING'
+
+        sleep 0.05
+      end
+    end
     expect(first).to include(bytes: 4, next_offset: 4, encoding: 'base64', eof: false, status: 'RUNNING')
     expect(Base64.strict_decode64(first[:data])).to eq("abc\xFF".b)
     last = described_class.tail(id: row[:id], offset: 4, length: 100)

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

@@ -13,13 +13,31 @@ describe PWN::Plugins::REDB do
     expect(described_class).to respond_to :help
   end
 
+  it 'records ARM bl strcpy xrefs from objdump' do
+    Dir.mktmpdir('redb-arm') do |dir|
+      stub_const('PWN::Plugins::REDB::ROOT', File.join(dir, 'redb'))
+      bin = File.join(dir, 'x')
+      File.write(bin, 'fake')
+      dump = <<~ASM
+        0000000000000000 <caller>:
+           0:	d10043ff 	sub	sp, sp, #0x10
+           4:	94000000 	bl	8 <strcpy@plt>
+      ASM
+      allow(Open3).to receive(:capture2).with('nm', '-C', bin).and_return(['', 1])
+      allow(Open3).to receive(:capture2).with('objdump', '-d', bin).and_return([dump, 1])
+      allow(Open3).to receive(:capture2).with('strings', '-a', bin).and_return(['', 1])
+      described_class.open(bin: bin)
+      expect(described_class.xrefs_to(bin: bin, sym: 'strcpy').map { |row| row['dst'] || row[:dst] }).to include('strcpy')
+    end
+  end
+
   it 'answers who calls strcpy from cache on a second open' do
     Dir.mktmpdir('redb') do |dir|
       stub_const('PWN::Plugins::REDB::ROOT', File.join(dir, 'redb'))
       src = File.join(dir, 'x.c')
       bin = File.join(dir, 'x')
       File.write(src, "#include <string.h>\nvoid caller(void){ char b[8]; strcpy(b, \"x\"); }\nint main(void){ caller(); return 0; }\n")
-      system('cc', '-O0', '-g', '-fno-builtin', '-fno-inline', '-o', bin, src)
+      expect(system('cc', '-O0', '-g', '-fno-builtin', '-fno-inline', '-o', bin, src)).to be(true)
       described_class.open(bin: bin)
       t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       described_class.open(bin: bin)

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

@@ -113,6 +113,7 @@ describe PWN::Plugins::REPL, 'mesh packet channel routing' do
       sent = Meshtastic::ToRadio.decode(args[:to_radio]).packet
     end
     allow(described_class).to receive(:mesh_maybe_dispatch_to_pwn_ai)
+    allow(described_class).to receive(:mesh_wait_tx_slot).and_return(:ok)
     described_class.send(:mesh_send_text, env: mesh_env, obj: radio, text: 'Local message', channel_name: 'LongFast')
     expect(sent.decoded.payload).to eq('Local message')
     packet = { decoded: { emoji: 1, reply_id: sent.id } }

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

@@ -40,6 +40,47 @@ describe PWN::Plugins::REPL, 'mesh payload chunking' do
     expect(reconstructed).to eq(body)
   end
 
+  it 'does not split a word across chunk boundaries' do
+    words = (1..80).map { |i| "token#{i}" }
+    body = words.join(' ')
+    chunks = described_class.send(:mesh_text_chunks, text: body)
+    bodies = chunks.map { |piece| piece.sub(%r{\A\(\d+/\d+\) }, '') }
+    expect(bodies.join).to eq(body)
+    expect(chunks.size).to be > 1
+    bodies[0..-2].each do |piece|
+      expect(piece).to match(/[[:space:]]\z/)
+    end
+    expect(bodies.join.split).to eq(words)
+  end
+
+  it 'still splits a single word that cannot fit in one payload' do
+    body = 'A' * (max + 10)
+    chunks = described_class.send(:mesh_text_chunks, text: body)
+    expect(chunks.size).to be > 1
+    expect(chunks.map { |piece| piece.sub(%r{\A\(\d+/\d+\) }, '') }.join).to eq(body)
+  end
+
+  it 'does not treat RATE_LIMIT_EXCEEDED as a free TX slot' do
+    obj = {
+      proto_data: [{ packet: { decoded: { portnum: :ROUTING_APP, request_id: 7, payload: { error_reason: :RATE_LIMIT_EXCEEDED } } } }],
+      rx_mutex: Mutex.new
+    }
+    t = Time.now
+    expect(described_class.send(:mesh_wait_tx_slot, obj: obj, since: 0, timeout: 0.25, request_id: 7)).to eq(:rate_limited)
+    expect(Time.now - t).to be < 0.2
+  end
+
+  it 'retries a rate-limited chunk instead of sending the next one' do
+    body = 'A' * (max + 10)
+    sent = []
+    allow(Meshtastic::Serial).to receive(:send_text) { |h| sent << h[:text] }
+    allow(described_class).to receive(:mesh_wait_tx_slot).and_return(:rate_limited, :ok, :ok)
+    described_class.send(:mesh_send_text, env: env, obj: { proto_data: [] }, text: body, to: '!ffffffff')
+    expect(sent.size).to be > 2
+    expect(sent[0]).to eq(sent[1])
+    expect(sent[2]).not_to eq(sent[0])
+  end
+
   it 'keeps each chunk small enough that the encoded ToRadio fits a 256-byte LoRa frame' do
     body = 'A' * max
     chunks = described_class.send(:mesh_text_chunks, text: body)
@@ -76,17 +117,17 @@ describe PWN::Plugins::REPL, 'mesh payload chunking' do
     body = 'A' * (max + 10)
     obj = { proto_data: [], rx_mutex: Mutex.new }
     allow(Meshtastic::Serial).to receive(:send_text)
-    allow(described_class).to receive(:mesh_wait_tx_slot)
+    allow(described_class).to receive(:mesh_wait_tx_slot).and_return(:ok)
     described_class.send(:mesh_send_text, env: env, obj: obj, text: body, to: '!ffffffff')
     n = described_class.send(:mesh_text_chunks, text: body).size
-    expect(described_class).to have_received(:mesh_wait_tx_slot).exactly(n - 1).times
+    expect(described_class).to have_received(:mesh_wait_tx_slot).exactly(n).times
   end
 
-  it 'does not wait for a TX slot after a single payload' do
+  it 'waits for a TX slot after a single radio payload' do
     allow(Meshtastic::Serial).to receive(:send_text)
-    allow(described_class).to receive(:mesh_wait_tx_slot)
+    allow(described_class).to receive(:mesh_wait_tx_slot).and_return(:ok)
     described_class.send(:mesh_send_text, env: env, obj: { proto_data: [] }, text: 'hi', to: '!ffffffff')
-    expect(described_class).not_to have_received(:mesh_wait_tx_slot)
+    expect(described_class).to have_received(:mesh_wait_tx_slot).once
   end
 
   it 'does not treat QueueStatus free as the chunk being on the air' do

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

@@ -40,6 +40,35 @@ describe PWN::Plugins::REPL, 'mesh compose history' do
     described_class.send(:mesh_drain_events)
   end
 
+  it 'does not turn spinner cursor restores into a notice overlay' do
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    described_class.send(:mesh_capture_output, run: proc {
+      3.times { $stdout.write("\e[?25h") }
+      $stderr.write("\e[?25h")
+    })
+    expect(events).to be_empty
+  end
+
+  it 'does not notice TTYSpinner cursor restore during capture' do
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    described_class.send(:mesh_capture_output, run: proc {
+      PWN::Plugins::TTYSpinner.send(:show_cursor, spin: nil)
+    })
+    expect(events).to be_empty
+  end
+
+  it 'keeps real warnings after stripping cursor sequences' do
+    events = Queue.new
+    stub_const('PWN::MeshEvents', events)
+    described_class.send(:mesh_capture_output, run: proc {
+      $stderr.write("\e[?25hWARNING: decoder fixture\e[?25h\n")
+    })
+    expect(events.pop(true)[:notice]).to eq('WARNING: decoder fixture')
+    expect(events).to be_empty
+  end
+
   it 'captures dependency stdout and stderr and restores both streams on failure' do
     events = Queue.new
     stub_const('PWN::MeshEvents', events)

data/spec/spec_helper.rb

@@ -31,6 +31,7 @@ RSpec.configure do |config|
   end
   config.filter_run_excluding :rtl_sdr_hardware unless ENV['PWN_TEST_RTL_SDR_HARDWARE'] == '1'
   config.filter_run_excluding :combo_nation_mcp unless ENV['PWN_TEST_COMBO_NATION_MCP'] == '1'
+  config.filter_run_excluding :x86_64_binary unless RbConfig::CONFIG['host_cpu'].to_s.match?(/amd64|x86_64/)
 
   next if ENV['PWN_SPEC_VERBOSE']
 

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.741
+  version: 0.5.743
 platform: ruby
 authors:
 - 0day Inc.