pwn 0.5.776 → 0.5.778

data/lib/pwn/version.rb

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

data/spec/lib/pwn/module_skills_spec.rb

@@ -3,8 +3,46 @@
 require 'spec_helper'
 require 'fileutils'
 require 'tmpdir'
+require 'open3'
 
 describe PWN::ModuleSkills do
+  it 'saves legacy generated edits and merges without discarding unrelated edits' do
+    script = File.read(File.expand_path('../../../build_gem.sh', __dir__))
+    recovery = script.split('generated_skills=()', 2).last.split('git checkout master', 2).first
+    Dir.mktmpdir('pwn_upgrade') do |dir|
+      git = lambda do |*args|
+        out, status = Open3.capture2e('git', *args, chdir: dir)
+        expect(status.success?).to be(true), out
+        out
+      end
+      git.call('init', '-b', 'master')
+      git.call('config', 'user.email', 'test@example.invalid')
+      git.call('config', 'user.name', 'Upgrade Test')
+      skill = 'etc/default_skills/pwn/json_text/SKILL.md'
+      path = File.join(dir, skill)
+      FileUtils.mkdir_p(File.dirname(path))
+      original = "---\ngenerated: true\n---\noriginal\n"
+      File.write(path, original)
+      File.write(File.join(dir, 'notes'), 'original')
+      git.call('add', '.')
+      git.call('commit', '-m', 'base')
+      git.call('checkout', '-b', 'incoming')
+      File.write(path, "#{original}upstream\n")
+      git.call('commit', '-am', 'update')
+      git.call('checkout', 'master')
+      File.write(path, "#{original}local regeneration\n")
+      File.write(File.join(dir, 'notes'), 'keep my edit')
+      _, blocked = Open3.capture2e('git', 'merge', '--ff-only', 'incoming', chdir: dir)
+      expect(blocked.success?).to be(false)
+      out, status = Open3.capture2e('bash', '-ec', "generated_skills=()#{recovery}", chdir: dir)
+      expect(status.success?).to be(true), out
+      git.call('merge', '--ff-only', 'incoming')
+      expect(File.read(path)).to eq("#{original}upstream\n")
+      expect(File.read(File.join(dir, 'notes'))).to eq('keep my edit')
+      expect(git.call('show', "stash@{0}:#{skill}")).to include('local regeneration')
+    end
+  end
+
   it 'should display information for authors' do
     expect(described_class).to respond_to :authors
   end
@@ -23,48 +61,50 @@ describe PWN::ModuleSkills do
     expect(described_class.relpath(source: 'pwn.rb')).to eq('pwn/SKILL.md')
   end
 
-  it 'refreshes etc/default_skills/pwn from every lib/pwn module' do
-    report = described_class.refresh!
-    expect(report[:modules]).to be > 50
-    tb = File.join(PWN::ModuleSkills::GEM_SKILLS, 'plugins', 'transparent_browser', 'SKILL.md')
-    expect(File.file?(tb)).to eq(true), tb
-    expect(File).not_to exist(File.join(PWN::ModuleSkills::GEM_SKILLS, 'plugins', 'transparent_browser.md'))
-    body = File.read(tb)
-    expect(body).to include('PWN::Plugins::TransparentBrowser')
-    expect(body).to include('open')
-    expect(body).not_to match(/hermes/i)
+  it 'refreshes a temp skill tree and does not rewrite the checkout' do
+    checkout = File.join(PWN::ModuleSkills::GEM_SKILLS, 'json_text', 'SKILL.md')
+    before = File.read(checkout)
+    Dir.mktmpdir('pwn_mod_refresh') do |dir|
+      report = described_class.refresh!(dest: dir)
+      expect(report[:modules]).to be > 50
+      tb = File.join(dir, 'pwn', 'plugins', 'transparent_browser', 'SKILL.md')
+      expect(File.file?(tb)).to eq(true), tb
+      expect(File).not_to exist(File.join(dir, 'pwn', 'plugins', 'transparent_browser.md'))
+      body = File.read(tb)
+      expect(body).to include('PWN::Plugins::TransparentBrowser')
+      expect(body).to include('open')
+      expect(body).not_to match(/hermes/i)
 
-    pw = File.join(PWN::ModuleSkills::GEM_SKILLS, 'sast', 'password', 'SKILL.md')
-    expect(File.file?(pw)).to eq(true), pw
-    expect(File.file?(File.join(PWN::ModuleSkills::GEM_SKILLS, 'sast', 'password', 'references', 'security.md'))).to eq(true)
+      pw = File.join(dir, 'pwn', 'sast', 'password', 'SKILL.md')
+      expect(File.file?(pw)).to eq(true), pw
+      expect(File.file?(File.join(dir, 'pwn', 'sast', 'password', 'references', 'security.md'))).to eq(true)
+
+      described_class.enumerate.each do |rec|
+        path = File.join(dir, described_class.relpath(source: rec[:source], const: rec[:const]))
+        expect(File.file?(path)).to eq(true), path
+        expect(File.read(path)).to include(rec[:const])
+        expect(File.read(path)).not_to match(/hermes/i)
+      end
+      drift = described_class.drift(dest: dir)
+      expect(drift[:missing]).to eq([])
+      expect(drift[:stale]).to eq([])
+      expect(drift[:orphans]).to eq([])
+    end
+    expect(File.read(checkout)).to eq(before)
 
     gw = File.join(PWN::ModuleSkills::GEM_SKILLS, 'plugins', 'google_workspace', 'SKILL.md')
     expect(File.read(gw)).to include('preserve: true')
     expect(File.read(gw)).to include('gmail_search')
     expect(File.read(gw)).to include('daily-brief.md')
     expect(File).not_to exist(File.join(PWN::Config.default_skills_dir, 'productivity', 'google-workspace', 'SKILL.md'))
-
-    described_class.enumerate.each do |rec|
-      path = File.join(
-        File.dirname(PWN::ModuleSkills::GEM_SKILLS),
-        described_class.relpath(source: rec[:source], const: rec[:const])
-      )
-      expect(File.file?(path)).to eq(true), path
-      expect(File.read(path)).to include(rec[:const])
-      expect(File.read(path)).not_to match(/hermes/i)
-    end
-    drift = described_class.drift
-    expect(drift[:missing]).to eq([])
-    expect(drift[:stale]).to eq([])
-    expect(drift[:orphans]).to eq([])
   end
 
-  it 'exposes drift so rake/spec can refuse a stale gem skill tree' do
-    expect(described_class).to respond_to(:drift)
+  it 'does not rewrite the checkout before spec' do
     rake = File.read(File.expand_path('../../../Rakefile', __dir__))
-    expect(rake).to match(/module_skills/)
+    expect(rake).to match(/task :module_skills do/)
     expect(rake).to match(/ModuleSkills\.refresh!/)
-    expect(rake).to match(/Task\[:spec\]\.enhance|task spec: :module_skills/)
+    expect(rake).not_to match(/Task\[:spec\]\.enhance\(\[:module_skills\]\)/)
+    expect(rake).not_to match(/module_skills_drift/)
   end
 
   it 'install overwrites existing generated module skills' do
@@ -83,7 +123,6 @@ describe PWN::ModuleSkills do
   end
 
   it 'ships no credential-shaped artifacts under etc/default_skills' do
-    described_class.refresh!
     rx = described_class.const_get(:ARTIFACT_RX)
     leftovers = []
     Dir.glob(File.join(PWN::Config.default_skills_dir, '**', '*')).each do |path|

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

@@ -116,7 +116,8 @@ describe PWN::Plugins::REPL, 'mesh terminal integration' do
       end
       expect(status.exitstatus).to eq(0), transcript
       transcript.force_encoding(Encoding::UTF_8)
-      expect(transcript).to include('╭', '─', 'COMPOSE', 'CONVERSATION')
+      expect(transcript).to include('╭', '─', 'COMPOSE', 'CONVERSATION', 'SENDER', 'RECEIVER')
+      expect(transcript).not_to include('MSG DETAILS', 'SNDR INFO', 'RCVR INFO')
       expect(File.read(File.join(dir, 'topic'))).to eq('msh/US/UT/2/e/LongFast/#')
       path = File.join(dir, 'pwn.yaml')
       expect(PWN::Plugins::Vault.file_encrypted?(file: path)).to be(true)

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

@@ -26,4 +26,122 @@ describe PWN::Plugins::REPL, 'mesh terminal layout' do
     expect(layout[:tx_top]).to be < 10
     expect(layout[:tx_top] + layout[:tx]).to eq(10)
   end
+
+  it 'keeps a 32-column MSG DETAILS pane beside conversation when the terminal is wide enough' do
+    layout = described_class.send(:mesh_layout, lines: 24, cols: 110)
+    expect(layout[:details]).to eq(32)
+    expect(layout[:conversation]).to eq(78)
+    expect(layout[:header] + layout[:body] + layout[:tx]).to eq(24)
+  end
+
+  it 'omits MSG DETAILS when the terminal is too narrow for both panes' do
+    layout = described_class.send(:mesh_layout, lines: 24, cols: 40)
+    expect(layout[:details]).to eq(0)
+    expect(layout[:conversation]).to eq(40)
+  end
+
+  it 'resizes from the terminal dup the same way pwn-ai does' do
+    source = double('terminal dup', tty?: true, winsize: [30, 100])
+    stub_const('PWN::MeshTerm', source)
+    allow(Curses).to receive(:lines).and_return(24)
+    allow(Curses).to receive(:cols).and_return(80)
+    allow(Curses).to receive(:resizeterm)
+    allow(described_class).to receive(:mesh_relayout!)
+    _input, pipe = IO.pipe
+    original = $stdout
+    $stdout = pipe
+    described_class.send(:mesh_apply_resize)
+    expect(Curses).to have_received(:resizeterm).with(30, 100)
+    expect(described_class).to have_received(:mesh_relayout!).with(lines: 30, cols: 100)
+  ensure
+    $stdout = original
+    pipe&.close
+  end
+
+  it 'does not read winsize when getch is a test proc' do
+    source = double('terminal dup', tty?: true)
+    allow(source).to receive(:winsize)
+    stub_const('PWN::MeshTerm', source)
+    described_class.send(:mesh_apply_resize, getch: proc {})
+    expect(source).not_to have_received(:winsize)
+  end
+
+  def pane_double
+    win = double('pane')
+    allow(win).to receive(:resize)
+    allow(win).to receive(:move)
+    allow(win).to receive(:erase)
+    allow(win).to receive(:clear)
+    allow(win).to receive(:close)
+    allow(win).to receive(:maxx).and_return(40)
+    allow(win).to receive(:maxy).and_return(10)
+    %i[scrollok nodelay= keypad timeout= setpos addstr attron attroff refresh noutrefresh touch].each do |message|
+      allow(win).to receive(message)
+    end
+    win
+  end
+
+  it 'keeps the same panes on resize and does not clear stdscr' do
+    old = pane_double
+    %i[MeshRxHeaderWin MeshRxFrameWin MeshRxBodyWin MeshSndrWin MeshRcvrWin MeshTxWin].each do |name|
+      stub_const("PWN::#{name}", old)
+    end
+    stub_const('PWN::MeshMutex', Mutex.new)
+    stub_const('PWN::MeshRxState', { rows: [{ header: '2026 · PEER · path · dest · RX via Serial', body: 'hello', color: 21 }], focus: :compose })
+    screen = double('stdscr', erase: nil, noutrefresh: nil)
+    allow(Curses).to receive(:stdscr).and_return(screen)
+    allow(Curses).to receive(:doupdate)
+    allow(Curses).to receive(:clear)
+    allow(Curses).to receive(:refresh)
+    allow(Curses).to receive(:color_pair).and_return(0)
+    described_class.send(:mesh_relayout!, lines: 30, cols: 120)
+    expect(old).to have_received(:resize).with(anything, 120).at_least(:once)
+    expect(old).not_to have_received(:close)
+    expect(PWN::MeshTxWin).to equal(old)
+    expect(Curses).not_to have_received(:clear)
+    expect(Curses).not_to have_received(:refresh)
+    expect(PWN::MeshRxBodyWin).to have_received(:addstr).with(a_string_including('RX via Serial'))
+    expect(PWN::MeshRxBodyWin).to have_received(:addstr).with(a_string_including('hello'))
+    expect(old).to have_received(:touch).at_least(4).times
+    expect(old).to have_received(:noutrefresh).at_least(4).times
+    expect(Curses).to have_received(:doupdate)
+  end
+
+  it 'does not raise when a resize arrives before any message exists' do
+    hide_const('PWN::MeshRxState')
+    old = pane_double
+    %i[MeshRxHeaderWin MeshRxFrameWin MeshRxBodyWin MeshTxWin].each do |name|
+      stub_const("PWN::#{name}", old)
+    end
+    stub_const('PWN::MeshMutex', Mutex.new)
+    allow(Curses).to receive(:color_pair).and_return(0)
+    allow(Curses).to receive(:stdscr).and_return(double('stdscr', erase: nil, noutrefresh: nil))
+    allow(Curses).to receive(:doupdate)
+    expect { described_class.send(:mesh_relayout!, lines: 24, cols: 100) }.not_to raise_error
+    expect(PWN::MeshTxWin).to equal(old)
+    expect(old).not_to have_received(:close)
+  ensure
+    %i[MeshSndrWin MeshRcvrWin].each do |name|
+      PWN.send(:remove_const, name) if PWN.const_defined?(name)
+    end
+  end
+
+  it 'drops side-pane focus when a resize hides SENDER and RECEIVER' do
+    old = pane_double
+    %i[MeshRxHeaderWin MeshRxFrameWin MeshRxBodyWin MeshSndrWin MeshRcvrWin MeshTxWin].each do |name|
+      stub_const("PWN::#{name}", old)
+    end
+    stub_const('PWN::MeshMutex', Mutex.new)
+    stub_const('PWN::MeshRxState', { focus: :sndr, rows: [] })
+    allow(Curses).to receive(:color_pair).and_return(0)
+    allow(Curses).to receive(:stdscr).and_return(double('stdscr', erase: nil, noutrefresh: nil))
+    allow(Curses).to receive(:doupdate)
+    described_class.send(:mesh_relayout!, lines: 24, cols: 40)
+    expect(PWN.const_defined?(:MeshSndrWin)).to be(false)
+    expect(described_class.send(:mesh_focus)).to eq(:conversation)
+    expect(PWN::MeshTxWin).to equal(old)
+  ensure
+    PWN.const_set(:MeshSndrWin, old) unless PWN.const_defined?(:MeshSndrWin)
+    PWN.const_set(:MeshRcvrWin, old) unless PWN.const_defined?(:MeshRcvrWin)
+  end
 end

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

@@ -224,7 +224,9 @@ describe PWN::Plugins::REPL, 'additive MQTT receive ownership' do
     stub_const('PWN::MeshObj', {})
     stub_const('PWN::MeshTransport', :mqtt)
     described_class.send(:mesh_handle_rx, env: env, msg: messages.first)
-    expect(win).to have_received(:addstr).with(a_string_including('FIRST', '/LongFast/', 'RX via Serial'))
+    expect(win).to have_received(:addstr).with(a_string_including('FIRST', '/LongFast/'))
+    expect(win).to have_received(:addstr).with(a_string_including('RX via Serial'))
+    expect(described_class.send(:mesh_details_lines, message: PWN::MeshRxState[:detail_rows].last, width: 28).values.flatten.map { |line| line[:text] }.join("\n")).not_to include('VIA')
     expect(described_class).to have_received(:mesh_maybe_dispatch_to_pwn_ai).with(hash_including(obj: radio, channel_name: 'LongFast'))
   end
 

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

@@ -36,6 +36,39 @@ describe PWN::Plugins::REPL, 'mesh primary display, MQTT sender, and GPS link' d
       end
     end.new
   end
+  let(:details) do
+    Class.new do
+      attr_reader :lines
+      attr_accessor :width
+
+      def initialize
+        @lines = []
+        @width = 32
+      end
+
+      def maxx
+        @width
+      end
+
+      def maxy
+        20
+      end
+
+      def attron(*) end
+      def attroff(*) end
+      def refresh; end
+      def setpos(*); end
+
+      def addstr(text)
+        @lines << text
+      end
+
+      def clear
+        @lines.clear
+      end
+    end.new
+  end
+  let(:rcvr) { details.class.new }
   let(:packet) { { id: 123, from: 0x421f6f22, to: 0xffffffff, decoded: { portnum: :TEXT_MESSAGE_APP, payload: 'hello' } } }
 
   before do
@@ -46,6 +79,8 @@ describe PWN::Plugins::REPL, 'mesh primary display, MQTT sender, and GPS link' d
     stub_const('PWN::MeshLastTx', nil)
     stub_const('PWN::MeshMutex', Mutex.new)
     stub_const('PWN::MeshRxBodyWin', win)
+    stub_const('PWN::MeshSndrWin', details)
+    stub_const('PWN::MeshRcvrWin', rcvr)
     allow(Curses).to receive(:color_pair) { |color| color }
     allow(described_class).to receive(:mesh_env_hash).and_return(env)
     allow(described_class).to receive(:mesh_maybe_dispatch_to_pwn_ai)
@@ -60,17 +95,30 @@ describe PWN::Plugins::REPL, 'mesh primary display, MQTT sender, and GPS link' d
     described_class.send(:mesh_handle_rx, env: env, obj: broker, msg: { packet: packet, mesh_transport: :mqtt, topic: 'msh/US/2/e/LongFast/!421f6f22' })
     described_class.send(:mesh_handle_rx, env: env, obj: radio, msg: { packet: packet, mesh_transport: :serial })
 
-    expect(headers).to eq(headers.grep(/RX via Serial/))
-    expect(headers.join).to include('RX via Serial')
-    expect(headers.join).not_to include('RX via MQTT')
+    painted = win.lines.join
+    expect(painted).to include('RX via Serial')
+    expect(painted).not_to include('RX via MQTT')
+    expect(rcvr.lines.join).not_to include('VIA')
+    expect(details.lines.join).not_to include('VIA')
     expect(described_class).to have_received(:mesh_maybe_dispatch_to_pwn_ai).once.with(hash_including(transport: :mqtt))
   end
 
+  it 'does not index an MQTT client while painting node details' do
+    require 'mqtt'
+    client = MQTT::Client.new(host: 'offline.invalid')
+    stub_const('PWN::MeshReceivers', [{ obj: client, transport: :mqtt, secondary: true, active: true }])
+    described_class.send(:mesh_handle_rx, env: env, obj: radio, msg: { packet: packet, mesh_transport: :serial })
+    described_class.send(:mesh_handle_rx, env: env, obj: client, msg: { packet: packet.merge(id: 124), mesh_transport: :mqtt, topic: 'msh/US/2/e/LongFast/!421f6f22' })
+    expect(described_class).not_to have_received(:mesh_ui_puts).with(hash_including(text: a_string_including('RX display failed')))
+    expect(details.lines.join).to include('Node ID: !421f6f22')
+  end
+
   it 'keeps RX via MQTT when that is the only observation' do
     described_class.send(:mesh_handle_rx, env: env, obj: broker, msg: { packet: packet, mesh_transport: :mqtt, topic: 'msh/US/2/e/LongFast/!421f6f22' })
 
-    expect(headers.join).to include('RX via MQTT')
-    expect(headers.join).not_to include('RX via Serial')
+    expect(win.lines.join).to include('RX via MQTT')
+    expect(win.lines.join).not_to include('RX via Serial')
+    expect(rcvr.lines.join).not_to include('VIA')
   end
 
   it 'publishes the configured channel sender instead of the MQTT library default' do
@@ -88,7 +136,7 @@ describe PWN::Plugins::REPL, 'mesh primary display, MQTT sender, and GPS link' d
     described_class.send(:mesh_send_text, env: radio_env, obj: broker, transport: :mqtt, from: '!00000b0b', text: 'sent', channel_name: 'LongFast')
   end
 
-  it 'links a known sender position and leaves unknown positions unlabeled' do
+  it 'links a known sender position in MSG DETAILS and leaves unknown positions unlabeled' do
     lat_i = 10_000_000
     lon_i = -20_000_000
     coord = format('%<lat>.7f,%<lon>.7f', lat: lat_i / 10_000_000.0, lon: lon_i / 10_000_000.0)
@@ -96,20 +144,114 @@ describe PWN::Plugins::REPL, 'mesh primary display, MQTT sender, and GPS link' d
                            packet: { id: 1, from: 0x421f6f22, decoded: { portnum: :POSITION_APP, payload: { latitude_i: lat_i, longitude_i: lon_i, location_source: :LOC_INTERNAL } } }
                          })
     described_class.send(:mesh_handle_rx, env: env, obj: radio, msg: { packet: packet, mesh_transport: :serial })
-    linked = headers.join
-    expect(linked).to include("#{coord} >> https://maps.google.com/?q=#{coord}")
+    linked = details.lines.join
+    expect(details.lines.join).to include('SENDER', 'Node ID: !421f6f22', coord)
+    expect(rcvr.lines.join).to include('RECEIVER', 'Node ID: LongFast', 'GPS: N/A')
+    expect(rcvr.lines.join).not_to include('broadcast')
+    expect(linked).not_to include('maps.google.com')
     expect(linked).not_to include("\e")
-    expect(win.lines.join).not_to include("\n https://")
-    win.lines.clear
-    allow(win).to receive(:maxx).and_return(120)
-    described_class.send(:mesh_handle_rx, env: env, obj: radio, msg: { packet: packet.merge(id: 9), mesh_transport: :serial })
-    expect(win.lines.map(&:strip).grep(Regexp.new(Regexp.escape(coord.split(',').first)))).to all(include(coord))
+    hit = PWN::MeshRxState[:gps_hits].find { |row| row[:url].include?(coord) }
+    expect(hit[:url]).to eq("https://maps.google.com/?q=#{coord}")
+    allow(described_class).to receive(:mesh_maps_opener).and_return(['/usr/bin/xdg-open'])
+    expect(Process).to receive(:spawn).with('/usr/bin/xdg-open', hit[:url], hash_including(out: File::NULL, err: File::NULL)).and_return(0)
+    expect(Process).to receive(:detach).with(0)
+    described_class.send(:mesh_open_gps_at, x: hit[:x], y: hit[:y])
+    expect(details.lines.join).not_to include('maps.google.com')
+    expect(headers.join).not_to include('GPS N/A')
+    expect(headers.join).not_to include('maps.google.com')
+    details.lines.clear
+    allow(details).to receive(:maxx).and_return(20)
+    described_class.send(:mesh_paint_details, obj: radio)
+    expect(details.lines.grep(Regexp.new(Regexp.escape(coord.split(',').first)))).to all(include(coord))
 
     described_class.send(:mesh_handle_rx, env: env, obj: radio, msg: {
                            packet: { id: 2, from: 0x99aabbcc, to: 0xffffffff, decoded: { portnum: 1, payload: 'no fix' } }, mesh_transport: :serial
                          })
-    expect(headers.last).to include('!99aabbcc')
-    expect(headers.last).to end_with(" · GPS N/A\n")
+    expect(details.lines.join).to include('!99aabbcc', 'GPS: N/A')
+    expect(details.lines.join).not_to include('maps.google.com')
+  end
+
+  it 'shows the highlighted conversation message, and the last received message while composing' do
+    first = '1.0000000,2.0000000'
+    second = '3.0000000,4.0000000'
+    described_class.send(:mesh_store_position, id: '!421f6f22', position: { latitude_i: 10_000_000, longitude_i: 20_000_000, location_source: :LOC_INTERNAL })
+    described_class.send(:mesh_store_position, id: '!99aabbcc', position: { latitude_i: 30_000_000, longitude_i: 40_000_000, location_source: :LOC_INTERNAL })
+    described_class.send(:mesh_handle_rx, env: env, obj: radio, msg: { packet: packet, mesh_transport: :serial })
+    described_class.send(:mesh_handle_rx, env: env, obj: radio, msg: {
+                           packet: packet.merge(id: 9, from: 0x99aabbcc), mesh_transport: :serial
+                         })
+    expect(details.lines.join).to include(second)
+    expect(details.lines.join).not_to include(first)
+    allow(win).to receive(:maxy).and_return(1)
+    described_class.send(:mesh_set_focus, focus: :conversation)
+    described_class.send(:mesh_scroll_conversation, key: :home)
+    expect(details.lines.join).to include(first)
+    expect(details.lines.join).not_to include(second)
+    described_class.send(:mesh_set_focus, focus: :compose)
+    expect(details.lines.join).to include(second)
+    expect(details.lines.join).not_to include(first)
+    described_class.send(:mesh_handle_rx, env: env, obj: radio, local: true, transport: :serial, msg: {
+                           packet: packet.merge(id: 11, from: 0x1337, to: 0x99aabbcc), decoded: { portnum: 1, payload: 'sent' }
+                         })
+    expect(details.lines.join).to include(second)
+    expect(details.lines.join).not_to include('!00001337')
+  end
+
+  it 'includes the receiver fix for a direct message and not for broadcast' do
+    described_class.send(:mesh_store_position, id: '!421f6f22', position: { latitude_i: 10_000_000, longitude_i: -20_000_000, location_source: :LOC_INTERNAL })
+    described_class.send(:mesh_store_position, id: '!00001337', position: { latitude_i: 11_000_000, longitude_i: -21_000_000, location_source: :LOC_MANUAL })
+    described_class.send(:mesh_handle_rx, env: env, obj: radio, msg: {
+                           packet: packet.merge(to: 0x1337), mesh_transport: :serial
+                         })
+    sender = '1.0000000,-2.0000000'
+    receiver = '1.1000000,-2.1000000'
+    painted = details.lines.join
+    expect(details.lines.join).to include('SENDER', 'Node ID: !421f6f22', sender)
+    expect(rcvr.lines.join).to include('RECEIVER', 'Node ID: !00001337', receiver)
+    expect(rcvr.lines.join).not_to include('broadcast')
+  end
+
+  it 'shows node inventory fields under cyan SENDER and RECEIVER titles' do
+    heard = Time.at(1_700_000_000).getlocal.strftime('%Y-%m-%d %H:%M:%S%z')
+    key = 'k' * 32
+    radio[:proto_data] << {
+      node_info: {
+        num: 0x421f6f22, last_heard: 1_700_000_000, hops_away: 3, is_key_manually_verified: true,
+        device_metrics: { uptime_seconds: 3661 },
+        user: { short_name: 'PEER', role: :ROUTER, public_key: key }
+      }
+    }
+    colors = []
+    allow(details).to receive(:attron) { |attr| colors << attr }
+    described_class.send(:mesh_handle_rx, env: env, obj: radio, msg: { packet: packet, mesh_transport: :serial })
+    painted = details.lines.join("\n")
+    expect(painted).to include('SENDER', 'Node ID: !421f6f22', 'GPS:')
+    expect(painted).not_to include('VIA')
+    node_num = 0x421f6f22
+    expect(painted).to include('Short Name: PEER', 'Device Role: ROUTER', "Node #: #{node_num}")
+    expect(painted).to include('Last Heard:', heard, 'Hops Away: 3', 'Uptime: 1h 1m 1s')
+    expect(painted).to include('Security: PKI verified', 'Public Key:')
+    expect(painted.gsub(/\s+/, '')).to include(key.unpack1('H*'))
+    expect(colors).to include(Curses.color_pair(20) | Curses::A_BOLD)
+    expect(rcvr.lines.join).to include('RECEIVER', 'Node ID: LongFast', 'Short Name: —', 'Device Role: —')
+    expect(rcvr.lines.join).not_to include('VIA', 'PEER', 'broadcast')
+  end
+
+  it 'does not refresh MSG DETAILS from the radio position cache' do
+    refreshes = 0
+    allow(details).to receive(:refresh) { refreshes += 1 }
+    20.times do |index|
+      described_class.send(:mesh_store_position, id: format('!%08x', index), position: { latitude_i: 10_000_000, longitude_i: -20_000_000, location_source: :LOC_INTERNAL })
+    end
+    expect(refreshes).to eq(0)
+  end
+
+  it 'does not warn when reading a curses mouse event' do
+    allow(Curses).to receive(:getmouse) do
+      warn 'undefining the allocator of T_DATA class Curses::MouseEvent'
+      nil
+    end
+    expect { described_class.send(:mesh_open_gps_click) }.not_to output(/MouseEvent/).to_stderr
   end
 
   it 'treats unset 0,0 as unknown and an explicit source at 0,0 as a real fix' do

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

@@ -46,4 +46,47 @@ describe PWN::Plugins::REPL, 'mesh conversation scroll' do
     described_class.send(:mesh_scroll_conversation, key: :down)
     expect(PWN::MeshRxState[:scroll]).to be_nil
   end
+
+  it 'moves between messages that already fit in the pane' do
+    stub_const('PWN::MeshRxState', {
+                 lines: [
+                   { text: 'one', color: 21, bold: true, message: 0 },
+                   { text: 'two', color: 21, bold: true, message: 1 }
+                 ],
+                 detail_rows: [
+                   { index: 0, from_id: '!00000001', to_id: '!ffffffff', received: true },
+                   { index: 1, from_id: '!00000002', to_id: '!ffffffff', received: true }
+                 ],
+                 focus: :conversation
+               })
+    allow(PWN::MeshRxBodyWin).to receive(:maxy).and_return(20)
+    described_class.send(:mesh_scroll_conversation, key: :up)
+    expect(PWN::MeshRxState[:selected]).to eq(0)
+    expect(described_class.send(:mesh_highlighted_message)[:from_id]).to eq('!00000001')
+    described_class.send(:mesh_scroll_conversation, key: :down)
+    expect(PWN::MeshRxState[:selected]).to be_nil
+    expect(described_class.send(:mesh_highlighted_message)[:from_id]).to eq('!00000002')
+    described_class.send(:mesh_scroll_conversation, key: :home)
+    expect(PWN::MeshRxState[:selected]).to eq(0)
+    described_class.send(:mesh_scroll_conversation, key: :page_down)
+    expect(PWN::MeshRxState[:selected]).to be_nil
+    described_class.send(:mesh_scroll_conversation, key: :page_up)
+    expect(PWN::MeshRxState[:selected]).to eq(0)
+    described_class.send(:mesh_scroll_conversation, key: :end)
+    expect(PWN::MeshRxState[:selected]).to be_nil
+  end
+
+  it 'cycles Ctrl+T through compose, conversation, sndr, and rcvr' do
+    stub_const('PWN::MeshSndrWin', double('sndr', setpos: nil, addstr: nil, attron: nil, attroff: nil, refresh: nil, maxx: 32, erase: nil, maxy: 6))
+    stub_const('PWN::MeshRcvrWin', double('rcvr', setpos: nil, addstr: nil, attron: nil, attroff: nil, refresh: nil, maxx: 32, erase: nil, maxy: 6))
+    allow(described_class).to receive(:mesh_paint_details)
+    described_class.send(:mesh_toggle_focus)
+    expect(described_class.send(:mesh_focus)).to eq(:conversation)
+    described_class.send(:mesh_toggle_focus)
+    expect(described_class.send(:mesh_focus)).to eq(:sndr)
+    described_class.send(:mesh_toggle_focus)
+    expect(described_class.send(:mesh_focus)).to eq(:rcvr)
+    described_class.send(:mesh_toggle_focus)
+    expect(described_class.send(:mesh_focus)).to eq(:compose)
+  end
 end

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

@@ -52,7 +52,8 @@ describe PWN::Plugins::REPL, 'mesh per-message transport labels' do
       obj[:proto_data].last[:node_info][:user][:short_name] = 'LATE'
       described_class.send(:mesh_drain_events)
 
-      expect(win).to have_received(:addstr).with(" 2026-01-02 03:04:05+0000 🔍 · PEER · US/CA/2/e/LongFast/!bbccddee · US/CA/2/e/LongFast/# · RX via #{label} · GPS N/A\n")
+      expect(win).to have_received(:addstr).with(" 2026-01-02 03:04:05+0000 🔍 · PEER · US/CA/2/e/LongFast/!bbccddee · US/CA/2/e/LongFast/# · RX via #{label}\n")
+      expect(described_class.send(:mesh_details_lines, message: PWN::MeshRxState[:detail_rows].last, width: 28).values.flatten.map { |line| line[:text] }.join("\n")).not_to include('VIA')
       expect(win).to have_received(:attron).with(21 | Curses::A_BOLD)
       expect(win).to have_received(:addstr).with(" hello\n")
       expect(message).not_to have_key(:mesh_transport)
@@ -75,7 +76,8 @@ describe PWN::Plugins::REPL, 'mesh per-message transport labels' do
       end
       described_class.send(:mesh_send_text, env: env, obj: obj, text: 'sent', channel_name: 'LongFast', channel: 0)
 
-      expect(win).to have_received(:addstr).with(" 2026-01-02 03:04:05+0000 🔍 · SELF · US/CA/2/e/LongFast/!aabbccdd (ME) · US/CA/2/e/LongFast/# · TX via #{label} · GPS N/A\n")
+      expect(win).to have_received(:addstr).with(" 2026-01-02 03:04:05+0000 🔍 · SELF · US/CA/2/e/LongFast/!aabbccdd (ME) · US/CA/2/e/LongFast/# · TX via #{label}\n")
+      expect(described_class.send(:mesh_details_lines, message: PWN::MeshRxState[:detail_rows].last, width: 28).values.flatten.map { |line| line[:text] }.join("\n")).not_to include('VIA')
       expect(win).to have_received(:attron).with(23 | Curses::A_BOLD)
       expect(described_class).not_to have_received(:mesh_maybe_dispatch_to_pwn_ai)
     end
@@ -101,7 +103,7 @@ describe PWN::Plugins::REPL, 'mesh per-message transport labels' do
     described_class.send(:mesh_handle_rx, msg: message.merge(mesh_transport: :tcp))
     reply = message[:packet].merge(id: 124, decoded: { portnum: 1, reply_id: 123, payload: '@ai reply' })
     described_class.send(:mesh_handle_rx, msg: { packet: reply, mesh_transport: :tcp })
-    expect(win).to have_received(:addstr).with(a_string_matching(%r{🔒 · PEER · .*!bbccddee.*!aabbccdd \(ME\) · RX via TCP · GPS N/A\n})).twice
+    expect(win).to have_received(:addstr).with(a_string_matching(/🔒 · PEER · .*!bbccddee.*!aabbccdd \(ME\) · RX via TCP\n/)).twice
     expect(win).to have_received(:addstr).with(" Replied to: \"!bbccddee >> hello\" with: @ai reply\n")
     expect(described_class).to have_received(:mesh_maybe_dispatch_to_pwn_ai).with(hash_including(text: '@ai reply', radio: 0))
   end
@@ -109,7 +111,8 @@ describe PWN::Plugins::REPL, 'mesh per-message transport labels' do
   it 'does not invent a known transport for an untagged event' do
     stub_const('PWN::MeshTransport', :mqtt)
     described_class.send(:mesh_handle_rx, msg: message)
-    expect(win).to have_received(:addstr).with(a_string_ending_with(" · RX via Unknown · GPS N/A\n"))
+    expect(win).to have_received(:addstr).with(a_string_including('RX via Unknown'))
+    expect(described_class.send(:mesh_details_lines, message: PWN::MeshRxState[:detail_rows].last, width: 28).values.flatten.map { |line| line[:text] }.join("\n")).not_to include('VIA')
   end
 
   it 'learns MQTT sender names from real NODEINFO envelopes, not gateway or destination names' do
@@ -140,7 +143,7 @@ describe PWN::Plugins::REPL, 'mesh per-message transport labels' do
     it "omits absent/blank short names without substituting the long name: #{name.inspect}" do
       obj[:proto_data].each { |row| row[:node_info][:user][:short_name] = name }
       described_class.send(:mesh_handle_rx, msg: message.merge(mesh_transport: :serial))
-      expect(win).to have_received(:addstr).with(" 2026-01-02 03:04:05+0000 🔍 · US/CA/2/e/LongFast/!bbccddee · US/CA/2/e/LongFast/# · RX via Serial · GPS N/A\n")
+      expect(win).to have_received(:addstr).with(" 2026-01-02 03:04:05+0000 🔍 · US/CA/2/e/LongFast/!bbccddee · US/CA/2/e/LongFast/# · RX via Serial\n")
     end
   end
 
@@ -188,9 +191,10 @@ describe PWN::Plugins::REPL, 'mesh per-message transport labels' do
       allow(win).to receive(:addstr) { |text| lines << text }
       described_class.send(:mesh_handle_rx, msg: message.merge(mesh_transport: :serial))
       header_lines = lines.take_while { |text| !text.include?('hello') }.map(&:strip).reject(&:empty?)
-      expect(header_lines.join(' · ').split(' · ').size).to eq(6)
+      expect(header_lines.join(' · ').split(' · ').size).to eq(5)
       expect(header_lines.join("\n")).not_to match(/  ·|·  /)
-      expect(header_lines.join("\n")).to include('US/CA/2/e/LongFast/!bbccddee', 'US/CA/2/e/LongFast/#', 'RX via Serial', 'GPS N/A')
+      expect(header_lines.join("\n")).to include('US/CA/2/e/LongFast/!bbccddee', 'US/CA/2/e/LongFast/#', 'RX via Serial')
+      expect(described_class.send(:mesh_details_lines, message: PWN::MeshRxState[:detail_rows].last, width: 28).values.flatten.map { |line| line[:text] }.join("\n")).not_to include('VIA')
     end
   end