pwn 0.5.621 → 0.5.626

data/lib/pwn/version.rb

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

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

@@ -12,4 +12,100 @@ describe PWN::AI::Agent::Extrospection do
     help_response = PWN::AI::Agent::Extrospection
     expect(help_response).to respond_to :help
   end
+
+  it 'should expose rf_tune as a public RF sense organ' do
+    expect(PWN::AI::Agent::Extrospection).to respond_to :rf_tune
+  end
+
+  it 'should expose osint / serial / telecomm / packet / vision / voice sense organs' do
+    %i[osint serial_sense telecomm packet_sense vision voice_sense].each do |m|
+      expect(PWN::AI::Agent::Extrospection).to respond_to m
+    end
+  end
+
+  it 'should auto-detect OSINT kind for common query shapes' do
+    det = ->(q) { PWN::AI::Agent::Extrospection.send(:detect_osint_kind, query: q) }
+    expect(det.call('8.8.8.8')).to eq :ip
+    expect(det.call('example.com')).to eq :domain
+    expect(det.call('+13125551212')).to eq :phone
+    expect(det.call('Jane Doe')).to eq :person
+    expect(det.call('US10123456')).to eq :patent
+    expect(det.call('2ABIP-ESP32')).to eq :fcc_id
+    expect(det.call('someone@example.com')).to eq :email
+    expect(det.call('https://evil.example/path')).to eq :url
+    expect(det.call('Acme Robotics LLC')).to eq :company
+    expect(det.call('0000320193')).to eq :cik
+    expect(det.call('123 Main Street Springfield')).to eq :geo
+    expect(det.call('birth record Jane Doe')).to eq :vital_records
+    expect(det.call('1HGCM82633A004352')).to eq :vin
+    expect(det.call('00:11:22:33:44:55')).to eq :mac
+    expect(det.call('W1AW')).to eq :callsign
+    expect(det.call('CVE-2021-44228')).to eq :cve
+    expect(det.call('NPI 1679576722')).to eq :npi
+  end
+
+  it 'should route new public feeds through osint_dispatch' do
+    feeds = %i[
+      otx urlhaus threatfox urlscan hackertarget openfda nominatim
+      opencorporates courtlistener sec_edgar vital_records
+      ipapi_is iplocate ipwhois abuseipdb virustotal greynoise
+      certspotter epss cisa_kev nhtsa nppes federal_register
+      uk_police callook mac_vendor universities microlink
+      agify genderize nationalize haveibeenpwned securitytrails
+    ]
+    feeds.each do |f|
+      # Dispatch should not raise — network failures become error hashes.
+      query = case f
+              when :epss, :cisa_kev then 'CVE-2021-44228'
+              when :nhtsa then '1HGCM82633A004352'
+              when :mac_vendor then '00:11:22:33:44:55'
+              when :callook then 'W1AW'
+              when :nppes then 'John Smith'
+              when :agify, :genderize, :nationalize then 'Michael'
+              when :uk_police then 'metropolitan'
+              else 'example.com'
+              end
+      res = PWN::AI::Agent::Extrospection.send(
+        :osint_dispatch,
+        feed: f,
+        query: query,
+        limit: 1,
+        keys: {}
+      )
+      expect(res).to be_a(Hash)
+    end
+  end
+
+  it 'should include expanded DEFAULT_OSINT_FEEDS' do
+    feeds = PWN::AI::Agent::Extrospection.const_get(:DEFAULT_OSINT_FEEDS)
+    %i[
+      otx urlhaus threatfox urlscan openfda nominatim opencorporates
+      courtlistener sec_edgar vital_records
+      ipapi_is iplocate ipwhois abuseipdb virustotal greynoise
+      certspotter epss cisa_kev nhtsa nppes federal_register
+      uk_police callook mac_vendor universities microlink
+      agify genderize nationalize haveibeenpwned securitytrails
+    ].each do |f|
+      expect(feeds).to include(f)
+    end
+  end
+
+  it 'should skip keyed public-api-lists feeds when no API key is present' do
+    %i[abuseipdb virustotal haveibeenpwned securitytrails].each do |f|
+      res = PWN::AI::Agent::Extrospection.send(
+        :osint_dispatch, feed: f, query: '8.8.8.8', limit: 1, keys: {}
+      )
+      expect(res).to be_a(Hash)
+      expect(res[:skipped]).to eq(true)
+    end
+  end
+
+  it 'should select public-api-lists-aware feeds per kind' do
+    ip_feeds = PWN::AI::Agent::Extrospection.send(:osint_feeds_for, kind: :ip)
+    expect(ip_feeds).to include(:ipapi_is, :iplocate, :abuseipdb, :greynoise)
+    cve_feeds = PWN::AI::Agent::Extrospection.send(:osint_feeds_for, kind: :cve)
+    expect(cve_feeds).to include(:epss, :cisa_kev)
+    vin_feeds = PWN::AI::Agent::Extrospection.send(:osint_feeds_for, kind: :vin)
+    expect(vin_feeds).to eq(%i[nhtsa])
+  end
 end

data/spec/lib/pwn/ai/agent/{introspection_spec.rb → reflect_spec.rb}

@@ -2,14 +2,14 @@
 
 require 'spec_helper'
 
-describe PWN::AI::Agent::Introspection do
+describe PWN::AI::Agent::Reflect do
   it 'should display information for authors' do
-    authors_response = PWN::AI::Agent::Introspection
+    authors_response = PWN::AI::Agent::Reflect
     expect(authors_response).to respond_to :authors
   end
 
   it 'should display information for existing help method' do
-    help_response = PWN::AI::Agent::Introspection
+    help_response = PWN::AI::Agent::Reflect
     expect(help_response).to respond_to :help
   end
 end

data/spec/lib/pwn/ai/agent/tools/extrospection_spec.rb

@@ -1,40 +1,24 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'pwn/ai/agent/tools/extrospection'
 
-describe 'PWN::AI::Agent::Tools extrospection' do
+describe 'PWN::AI::Agent::Tools::Extrospection' do
   it 'registers the extro_snapshot tool' do
-    PWN::AI::Agent::Registry.discover(force: true)
     expect(PWN::AI::Agent::Registry.lookup(name: 'extro_snapshot')).not_to be_nil
   end
 
-  it 'registers the extro_drift tool' do
-    PWN::AI::Agent::Registry.discover(force: true)
-    expect(PWN::AI::Agent::Registry.lookup(name: 'extro_drift')).not_to be_nil
-  end
-
   it 'registers the extro_observe tool' do
-    PWN::AI::Agent::Registry.discover(force: true)
     expect(PWN::AI::Agent::Registry.lookup(name: 'extro_observe')).not_to be_nil
   end
 
-  it 'registers the extro_observations tool' do
-    PWN::AI::Agent::Registry.discover(force: true)
-    expect(PWN::AI::Agent::Registry.lookup(name: 'extro_observations')).not_to be_nil
-  end
-
-  it 'registers the extro_intel tool' do
-    PWN::AI::Agent::Registry.discover(force: true)
-    expect(PWN::AI::Agent::Registry.lookup(name: 'extro_intel')).not_to be_nil
-  end
-
-  it 'registers the extro_correlate tool' do
-    PWN::AI::Agent::Registry.discover(force: true)
-    expect(PWN::AI::Agent::Registry.lookup(name: 'extro_correlate')).not_to be_nil
+  it 'registers the extro_rf_tune tool' do
+    expect(PWN::AI::Agent::Registry.lookup(name: 'extro_rf_tune')).not_to be_nil
   end
 
-  it 'exposes the extrospection toolset in the registry' do
-    PWN::AI::Agent::Registry.discover(force: true)
-    expect(PWN::AI::Agent::Registry.toolsets).to include('extrospection')
+  it 'registers the six new limb tools' do
+    %w[extro_osint extro_serial extro_telecomm extro_packet extro_vision extro_voice].each do |name|
+      expect(PWN::AI::Agent::Registry.lookup(name: name)).not_to be_nil
+    end
   end
 end

data/spec/lib/pwn/ffi/adalm_pluto_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::FFI::AdalmPluto do
+  it 'should display information for authors' do
+    expect(PWN::FFI::AdalmPluto).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(PWN::FFI::AdalmPluto).to respond_to :help
+  end
+
+  it 'should respond to available?' do
+    expect(PWN::FFI::AdalmPluto).to respond_to :available?
+  end
+
+  it 'should report library info when libiio is present' do
+    skip 'libiio not installed' unless PWN::FFI::AdalmPluto.available?
+
+    info = PWN::FFI::AdalmPluto.info
+    expect(info[:available]).to eq(true)
+    expect(info[:major]).to be_a(Integer)
+    expect(info[:minor]).to be_a(Integer)
+  end
+
+  it 'should list URIs (possibly empty) when libiio is present' do
+    skip 'libiio not installed' unless PWN::FFI::AdalmPluto.available?
+
+    list = PWN::FFI::AdalmPluto.list_uris
+    expect(list).to be_a(Array)
+  end
+
+  it 'should appear in PWN::FFI.backends' do
+    expect(PWN::FFI.backends).to have_key(:AdalmPluto)
+  end
+end

data/spec/lib/pwn/ffi/fftw_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::FFI::FFTW do
+  it 'should display information for authors' do
+    expect(PWN::FFI::FFTW).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(PWN::FFI::FFTW).to respond_to :help
+  end
+
+  it 'should respond to available?' do
+    expect(PWN::FFI::FFTW).to respond_to :available?
+  end
+
+  it 'should compute an rfft impulse response when libfftw3f is present' do
+    skip 'libfftw3f not installed' unless PWN::FFI::FFTW.available?
+
+    spec = PWN::FFI::FFTW.rfft(samples: [1.0, 0, 0, 0, 0, 0, 0, 0])
+    expect(spec.length).to eq(5) # n/2+1
+    expect(spec[0][0]).to be_within(1e-5).of(1.0)
+    expect(spec[0][1]).to be_within(1e-5).of(0.0)
+  end
+end

data/spec/lib/pwn/ffi/hack_rf_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::FFI::HackRF do
+  it 'should display information for authors' do
+    expect(PWN::FFI::HackRF).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(PWN::FFI::HackRF).to respond_to :help
+  end
+
+  it 'should respond to available?' do
+    expect(PWN::FFI::HackRF).to respond_to :available?
+  end
+
+  it 'should report library info when libhackrf is present' do
+    skip 'libhackrf not installed' unless PWN::FFI::HackRF.available?
+
+    info = PWN::FFI::HackRF.info
+    expect(info[:available]).to eq(true)
+    expect(info[:library_version]).to be_a(String)
+  end
+end

data/spec/lib/pwn/ffi/liquid_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::FFI::Liquid do
+  it 'should display information for authors' do
+    expect(PWN::FFI::Liquid).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(PWN::FFI::Liquid).to respond_to :help
+  end
+
+  it 'should respond to available?' do
+    expect(PWN::FFI::Liquid).to respond_to :available?
+  end
+
+  it 'should resample at half rate when libliquid is present' do
+    skip 'libliquid not installed' unless PWN::FFI::Liquid.available?
+
+    samples = Array.new(64) { |i| Math.sin(2 * Math::PI * i / 16.0) }
+    out = PWN::FFI::Liquid.resample(samples: samples, rate: 0.5)
+    expect(out.length).to be_between(24, 40)
+  end
+
+  it 'should FM-demod a complex tone when libliquid is present' do
+    skip 'libliquid not installed' unless PWN::FFI::Liquid.available?
+
+    iq = []
+    phase = 0.0
+    dphi = 2 * Math::PI * 0.05
+    64.times do
+      iq << Math.cos(phase)
+      iq << Math.sin(phase)
+      phase += dphi
+    end
+    audio = PWN::FFI::Liquid.freq_demod(iq: iq, kf: 0.5)
+    expect(audio.length).to eq(64)
+    # after settle, demod of constant dphi ≈ 0.1 (2*dphi when kf=0.5 → dphi/kf)
+    expect(audio[10]).to be_within(0.05).of(0.1)
+  end
+end

data/spec/lib/pwn/ffi/rtl_sdr_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::FFI::RTLSdr do
+  it 'should display information for authors' do
+    expect(PWN::FFI::RTLSdr).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(PWN::FFI::RTLSdr).to respond_to :help
+  end
+
+  it 'should respond to available?' do
+    expect(PWN::FFI::RTLSdr).to respond_to :available?
+  end
+
+  it 'should list devices (possibly empty) when librtlsdr is present' do
+    skip 'librtlsdr not installed' unless PWN::FFI::RTLSdr.available?
+
+    list = PWN::FFI::RTLSdr.list_devices
+    expect(list).to be_a(Array)
+  end
+end

data/spec/lib/pwn/ffi/soapy_sdr_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::FFI::SoapySDR do
+  it 'should display information for authors' do
+    expect(PWN::FFI::SoapySDR).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(PWN::FFI::SoapySDR).to respond_to :help
+  end
+
+  it 'should respond to available?' do
+    expect(PWN::FFI::SoapySDR).to respond_to :available?
+  end
+
+  it 'should report API info when libSoapySDR is present' do
+    skip 'libSoapySDR not installed' unless PWN::FFI::SoapySDR.available?
+
+    info = PWN::FFI::SoapySDR.info
+    expect(info[:available]).to eq(true)
+    expect(info[:api]).to match(/\d+\.\d+/)
+  end
+end

data/spec/lib/pwn/ffi/volk_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::FFI::Volk do
+  it 'should display information for authors' do
+    expect(PWN::FFI::Volk).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(PWN::FFI::Volk).to respond_to :help
+  end
+
+  it 'should respond to available?' do
+    expect(PWN::FFI::Volk).to respond_to :available?
+  end
+
+  it 'should unpack s16le to unit-range floats when libvolk is present' do
+    skip 'libvolk not installed' unless PWN::FFI::Volk.available?
+
+    raw = [0, 16_384, -16_384, 32_767].pack('s<*')
+    out = PWN::FFI::Volk.unpack_s16le(data: raw)
+    expect(out.length).to eq(4)
+    expect(out[0]).to be_within(1e-5).of(0.0)
+    expect(out[1]).to be_within(1e-3).of(0.5)
+    expect(out[2]).to be_within(1e-3).of(-0.5)
+    expect(out[3]).to be_within(1e-3).of(1.0)
+  end
+
+  it 'should accumulate floats when libvolk is present' do
+    skip 'libvolk not installed' unless PWN::FFI::Volk.available?
+
+    sum = PWN::FFI::Volk.accumulate(samples: [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0])
+    expect(sum).to be_within(1e-4).of(36.0)
+  end
+end

data/spec/lib/pwn/sdr/decoder/base_iq_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::SDR::Decoder::Base do
+  it 'responds to run_iq / resolve_iq_source' do
+    expect(PWN::SDR::Decoder::Base).to respond_to(:run_iq)
+    expect(PWN::SDR::Decoder::Base).to respond_to(:resolve_iq_source)
+    expect(PWN::SDR::Decoder::Base).to respond_to(:unpack_iq)
+    expect(PWN::SDR::Decoder::Base).to respond_to(:close_iq_source)
+  end
+
+  it 'resolves a cu8 capture file as an I/Q source' do
+    path = '/tmp/pwn_iq_test.cu8'
+    File.binwrite(path, ([127, 127] * 1024).pack('C*'))
+    src = PWN::SDR::Decoder::Base.resolve_iq_source(
+      freq_obj: { freq: 433_920_000 },
+      source: :file,
+      file: path,
+      sample_rate: 250_000
+    )
+    expect(src).to be_a(Hash)
+    expect(src[:kind]).to eq(:file)
+    expect(src[:format]).to eq(:cu8)
+    chunk = PWN::SDR::Decoder::Base.read_iq_chunk(source: src, bytes: 512)
+    expect(chunk.bytesize).to eq(512)
+    iq = PWN::SDR::Decoder::Base.unpack_iq(source: src, data: chunk)
+    expect(iq.length).to eq(512) # interleaved I/Q floats
+    PWN::SDR::Decoder::Base.close_iq_source(source: src)
+  ensure
+    FileUtils.rm_f(path)
+  end
+end
+
+describe PWN::SDR::Decoder::DSP do
+  it 'unpacks cu8 / cs16 and computes mag_sq / fm_demod_iq' do
+    cu8 = [127, 127, 200, 50].pack('C*')
+    expect(PWN::SDR::Decoder::DSP.unpack_cu8(data: cu8).length).to eq(4)
+    cs16 = [1000, -1000].pack('s<*')
+    expect(PWN::SDR::Decoder::DSP.unpack_cs16le(data: cs16).length).to eq(2)
+    iq = [0.5, 0.0, 0.0, 0.5, -0.5, 0.0]
+    m2 = PWN::SDR::Decoder::DSP.mag_sq(iq: iq)
+    expect(m2.length).to eq(3)
+    # Liquid freqdem returns n samples; pure-Ruby path returns n-1
+    fm = PWN::SDR::Decoder::DSP.fm_demod_iq(iq: iq)
+    expect(fm.length).to be_between(2, 3)
+  end
+end
+
+describe PWN::SDR::Decoder::ADSB do
+  it 'decodes Mode-S DF17 identity fields from a bit vector' do
+    bits = Array.new(112, 0)
+    # DF = 17 (10001)
+    [1, 0, 0, 0, 1].each_with_index { |b, i| bits[i] = b }
+    # ICAO = 0xABC123 → 24 bits starting at bit 8
+    icao = 0xABC123
+    24.times { |i| bits[8 + i] = (icao >> (23 - i)) & 1 }
+    # TC = 4 (identity) at bits 32..36
+    [0, 0, 1, 0, 0].each_with_index { |b, i| bits[32 + i] = b }
+    h = PWN::SDR::Decoder::ADSB.decode_modes(bits: bits)
+    expect(h[:df]).to eq(17)
+    expect(h[:icao24]).to eq('ABC123')
+    expect(h[:type_code]).to eq(4)
+  end
+end

data/spec/lib/pwn/sdr/decoder/dsp_spec.rb

@@ -4,12 +4,58 @@ require 'spec_helper'
 
 describe PWN::SDR::Decoder::DSP do
   it 'should display information for authors' do
-    authors_response = PWN::SDR::Decoder::DSP
-    expect(authors_response).to respond_to :authors
+    expect(PWN::SDR::Decoder::DSP).to respond_to :authors
   end
 
   it 'should display information for existing help method' do
-    help_response = PWN::SDR::Decoder::DSP
-    expect(help_response).to respond_to :help
+    expect(PWN::SDR::Decoder::DSP).to respond_to :help
+  end
+
+  it 'should expose a native toggle' do
+    expect(PWN::SDR::Decoder::DSP).to respond_to :native
+    expect(PWN::SDR::Decoder::DSP).to respond_to :native=
+  end
+
+  it 'should unpack s16le to unit-range floats (ruby path)' do
+    was = PWN::SDR::Decoder::DSP.native
+    PWN::SDR::Decoder::DSP.native = false
+    raw = [0, 16_384, -16_384, 32_767].pack('s<*')
+    out = PWN::SDR::Decoder::DSP.unpack_s16le(data: raw)
+    expect(out[0]).to be_within(1e-6).of(0.0)
+    expect(out[1]).to be_within(1e-3).of(0.5)
+    expect(out[2]).to be_within(1e-3).of(-0.5)
+    expect(out[3]).to be_within(1e-3).of(1.0)
+  ensure
+    PWN::SDR::Decoder::DSP.native = was
+  end
+
+  it 'should unpack s16le via Volk when available' do
+    skip 'libvolk not installed' unless PWN::FFI.available?(mod: :Volk)
+
+    was = PWN::SDR::Decoder::DSP.native
+    PWN::SDR::Decoder::DSP.native = true
+    raw = [0, 16_384, -16_384, 32_767].pack('s<*')
+    out = PWN::SDR::Decoder::DSP.unpack_s16le(data: raw)
+    expect(out[1]).to be_within(1e-3).of(0.5)
+  ensure
+    PWN::SDR::Decoder::DSP.native = was
+  end
+
+  it 'should resample pure-ruby and liquid paths to comparable length' do
+    samples = Array.new(200) { |i| Math.sin(2 * Math::PI * i / 40.0) }
+
+    was = PWN::SDR::Decoder::DSP.native
+    PWN::SDR::Decoder::DSP.native = false
+    ruby_out = PWN::SDR::Decoder::DSP.resample(samples: samples, src_rate: 48_000, dst_rate: 24_000)
+    expect(ruby_out.length).to eq(100)
+
+    if PWN::FFI.available?(mod: :Liquid)
+      PWN::SDR::Decoder::DSP.native = true
+      liq_out = PWN::SDR::Decoder::DSP.resample(samples: samples, src_rate: 48_000, dst_rate: 24_000)
+      # multi-stage resampler length can differ by a few samples due to delay
+      expect(liq_out.length).to be_between(90, 120)
+    end
+  ensure
+    PWN::SDR::Decoder::DSP.native = was
   end
 end

data/spec/lib/pwn/sdr/decoder/rds_spec.rb

@@ -4,12 +4,53 @@ require 'spec_helper'
 
 describe PWN::SDR::Decoder::RDS do
   it 'should display information for authors' do
-    authors_response = PWN::SDR::Decoder::RDS
-    expect(authors_response).to respond_to :authors
+    expect(PWN::SDR::Decoder::RDS).to respond_to :authors
   end
 
   it 'should display information for existing help method' do
-    help_response = PWN::SDR::Decoder::RDS
-    expect(help_response).to respond_to :help
+    expect(PWN::SDR::Decoder::RDS).to respond_to :help
+  end
+
+  it 'exposes a non-interactive .sample entry point (agents / automation)' do
+    expect(PWN::SDR::Decoder::RDS).to respond_to :sample
+  end
+
+  it 'exposes the interactive .decode entry point (TTY spinner)' do
+    expect(PWN::SDR::Decoder::RDS).to respond_to :decode
+  end
+
+  it 'aggregates RDS poll samples into pi/ps_name/radiotext/station' do
+    samples = [
+      { pi: '0000', ps: '', rt: '' },
+      { pi: '131D', ps: 'KBER    ', rt: 'KBER 101' },
+      { pi: '131D', ps: 'NIRVANA ', rt: 'KBER 101: Nirvana All Apologies' }
+    ]
+    result = PWN::SDR::Decoder::RDS.send(
+      :aggregate,
+      samples: samples,
+      settle_secs: 8.0
+    )
+    expect(result[:pi]).to eq('131D')
+    expect(result[:station]).to eq('KBER')
+    expect(result[:radiotext]).to include('Nirvana')
+    expect(result[:samples]).to eq(3)
+    expect(result[:settle_secs]).to eq(8.0)
+  end
+
+  it 'returns an error Hash from .sample when gqrx_sock is missing' do
+    # sample rescues ArgumentError only after resolve — missing sock raises first
+    expect do
+      PWN::SDR::Decoder::RDS.sample({})
+    end.to raise_error(ArgumentError, /gqrx_sock/)
+  end
+
+  it 'returns an error Hash when the RDS backend refuses enable' do
+    sock = Object.new
+    # Stub GQRX.cmd so U RDS 1 fails
+    allow(PWN::SDR::GQRX).to receive(:cmd).and_raise(StandardError.new('no rds'))
+    result = PWN::SDR::Decoder::RDS.sample(gqrx_sock: sock, settle_secs: 0.5)
+    expect(result).to be_a(Hash)
+    expect(result[:error]).to match(/RDS not supported/)
+    expect(result[:samples]).to eq(0)
   end
 end