pwn 0.5.784 → 0.5.787

data/spec/lib/pwn/plugins/repl/ai_swarm_spec.rb

@@ -100,7 +100,7 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
     controller = described_class.new(session_id: 'fixture')
     controller.execute(line: "/swarm mission #{request}")
     controller.send(:workers).each(&:join)
-    expect(controller.snapshot[:jobs].first).to include(state: 'incomplete', team: include(roles: include(protagonist: 'build')))
+    expect(controller.snapshot[:jobs].first).to include(state: 'incomplete', team: include(roles: include('protagonist' => 'build')))
   ensure
     controller&.close
   end
@@ -131,20 +131,20 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
   end
 
   it 'owns model interrupts on the job thread and copies request-local routing' do
-    entered = Queue.new
+    entered = PWNTestPipeQueue.new
     allow(PWN::AI::Agent::Swarm).to receive(:create).and_return(swarm_id: 'fixture')
     Thread.current[:pwn_workspace_fixture] = :copied
     allow(PWN::AI::Agent::Swarm).to receive(:ask) do |opts|
       control = opts[:steering]
-      entered << [control.instance_variable_get(:@owner), Thread.current, Thread.current[:pwn_workspace_fixture], Thread.current[:pwn_steering_input]]
+      entered << [control.instance_variable_get(:@owner) == Thread.current, Thread.current[:pwn_workspace_fixture], Thread.current[:pwn_steering_input].is_a?(PWN::Plugins::REPL::AISwarm::JobControl)]
       { reply: 'done' }
     end
     controller = described_class.new(session_id: 'fixture')
     controller.execute(line: '/swarm dm scout inspect')
-    owner, worker, local, marker = entered.pop
-    expect(owner).to eq(worker)
-    expect(local).to eq(:copied)
-    expect(marker).to be_a(PWN::Plugins::REPL::AISwarm::JobControl)
+    owner_matches, local, marker = entered.pop
+    expect(owner_matches).to be(true)
+    expect(local).to eq('copied')
+    expect(marker).to be(true)
   ensure
     controller&.close
     Thread.current[:pwn_workspace_fixture] = nil
@@ -152,9 +152,9 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
 
   it 'passes prior speakers to debate, preserves literal flag-like missions, and retains failures' do
     allow(PWN::AI::Agent::Swarm).to receive(:create).and_return(swarm_id: 'fixture')
-    calls = []
+    recorded = PWNTestPipeQueue.new
     allow(PWN::AI::Agent::Swarm).to receive(:ask) do |opts|
-      calls << opts
+      recorded << opts.slice(:request, :name)
       raise IOError, 'fixture unavailable' if opts[:name] == 'broken'
 
       { reply: "reply from #{opts[:name]}" }
@@ -162,6 +162,8 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
     controller = described_class.new(session_id: 'fixture')
     controller.execute(line: '/swarm debate scout,critic "--literal mission"')
     controller.send(:workers).each(&:join)
+    calls = []
+    calls << recorded.pop until recorded.empty?
     expect(calls.first[:request]).to eq('--literal mission')
     expect(calls.last[:request]).to include('reply from scout', '--literal mission')
     controller.execute(line: '/swarm dm broken inspect')
@@ -172,7 +174,7 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
   end
 
   it 'cancels only its owned blocked model and cannot switch swarms while it runs' do
-    entered = Queue.new
+    entered = PWNTestPipeQueue.new
     foreign = Thread.new { sleep }
     allow(PWN::AI::Agent::Swarm).to receive(:create).and_return(swarm_id: 'fixture')
     allow(PWN::AI::Agent::Swarm).to receive(:ask) do |opts|
@@ -199,12 +201,13 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
   end
 
   it 'runs, steers, and cancels a persona through the existing Swarm API' do
-    entered = Queue.new
+    entered = PWNTestPipeQueue.new
     allow(PWN::AI::Agent::Swarm).to receive(:ask) do |opts|
-      entered << opts[:steering]
+      entered << true
       opts[:on_tool].call('shell', { command: 'true' }, '{"success":true}')
-      sleep 0.01 until opts[:steering].instance_variable_get(:@stopping)
-      raise PWN::Plugins::REPL::AISwarm::JobControl::Stopped, 'cancelled'
+      sleep 0.01 while opts[:steering].instance_variable_get(:@pending).empty?
+      entered << opts[:steering].instance_variable_get(:@pending)
+      sleep 30
     end
     events = Queue.new
     controller = described_class.new(session_id: 'console-session')
@@ -212,11 +215,11 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
     allow(PWN::AI::Agent::Swarm).to receive(:spawn).and_return(name: 'scout')
     controller.execute(line: '/swarm spawn scout inspect evidence')
     queued = controller.execute(line: '/swarm dm scout inspect the fixture', on_event: ->(type, text) { events << [type, text] })
-    steering = entered.pop
+    expect(entered.pop).to be(true)
     expect(queued[:ok]).to eq(true)
     expect(controller.snapshot[:jobs].first[:state]).to eq('running')
     controller.execute(line: "/swarm steer #{queued[:job_id]} stop the scan")
-    expect(steering.instance_variable_get(:@pending)).to include('stop the scan')
+    expect(entered.pop).to include('stop the scan')
     controller.execute(line: "/swarm cancel #{queued[:job_id]}")
     sleep 0.05
     expect(controller.snapshot[:jobs].first[:state]).to eq('cancelled')

data/spec/lib/pwn/plugins/repl/ai_vault_edit_yubikey_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'stringio'
+
+RSpec.describe PWN::Plugins::REPL::AIConsole::VaultEdit, 'hardware vault editing' do
+  around do |example|
+    Dir.mktmpdir('vault-edit-yubikey-') do |root|
+      @root = root
+      example.run
+    end
+  end
+
+  before do
+    allow(Dir).to receive(:home).and_return(@root)
+    stub_const('PWN::Plugins::YubiKey', double('synthetic YubiKey'))
+    allow(PWN::Plugins::YubiKey).to receive(:challenge_response) do |opts|
+      OpenSSL::HMAC.digest('SHA1', 'synthetic-slot-secret', opts[:challenge])
+    end
+    @path = File.join(@root, 'selected-vault')
+    @original = { ai: { active: 'ollama', ollama: { model: 'fixture-model', key: 'synthetic-private-value' } }, retained: ['fixture-value'] }
+    File.binwrite(@path, PWN::Plugins::Vault.encrypt_data(data: YAML.dump(@original), yubikey: { slot: 2, serial: '12345678' }))
+    File.chmod(0o600, @path)
+    stub_const('PWN::Env', @original.merge(driver_opts: { pwn_env_path: @path, pwn_dec_path: File.join(@root, 'absent-sidecar') }))
+    stub_const('PWN::EnvRedacted', {})
+    allow(Pry).to receive(:history).and_return(Pry::History.new(file_path: File.join(@root, 'history')))
+  end
+
+  it 'keeps malformed YAML and cancellation private and leaves hardware ciphertext untouched' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    bytes = File.binread(@path)
+    console.submit('/vault edit')
+    console.instance_variable_get(:@vault_editor).replace('synthetic-private-value: [')
+    console.handle("\u0013")
+    expect(console.instance_variable_get(:@vault_error)).to include('Invalid YAML')
+    expect(console.instance_variable_get(:@vault_error)).not_to include('synthetic-private-value')
+    console.handle("\e")
+    expect(console.instance_variable_get(:@vault_editor)).to be_nil
+    expect(console.instance_variable_get(:@timeline).inspect).not_to include('synthetic-private-value', 'Invalid YAML')
+    expect(Pry.history.to_a.join).not_to include('synthetic-private-value')
+    expect(File.binread(@path)).to eq(bytes)
+  end
+
+  it 'preserves hardware ciphertext and Env when encryption fails or is interrupted' do
+    edit = described_class.new(%w[ai ollama model])
+    bytes = File.binread(@path)
+    env = PWN::Env
+    allow(PWN::Plugins::Vault).to receive(:encrypt_data).and_raise(IOError, 'synthetic-private-value')
+    expect { edit.save('new-model') }.to raise_error(described_class::Error, /Vault not saved/)
+    expect(File.binread(@path)).to eq(bytes)
+    expect(PWN::Env).to equal(env)
+    allow(PWN::Plugins::Vault).to receive(:encrypt_data).and_raise(Interrupt)
+    expect { edit.save('new-model') }.to raise_error(Interrupt)
+    expect(File.binread(@path)).to eq(bytes)
+    expect(PWN::Env).to equal(env)
+    expect(Dir.children(@root)).to eq(['selected-vault'])
+  end
+
+  it 'merges unrelated hardware edits and refuses a changed selected scope' do
+    edit = described_class.new(%w[ai ollama model])
+    described_class.new(['retained']).save("- changed\n")
+    edit.save('new-model')
+    expect(PWN::Plugins::Vault.dump(file: @path)[:retained]).to eq(['changed'])
+    bytes = File.binread(@path)
+    expect { edit.save('stale-model') }.to raise_error(described_class::Error, /scope changed/)
+    expect(File.binread(@path)).to eq(bytes)
+  end
+
+  it 'rejects a final ciphertext conflict without leaving a staging file' do
+    edit = described_class.new(%w[ai ollama model])
+    other = PWN::Plugins::Vault.encrypt_data(data: YAML.dump(@original.merge(retained: ['concurrent'])), yubikey: { slot: 2 })
+    allow(edit).to receive(:atomic_write).and_wrap_original do |method, encrypted, previous|
+      File.binwrite(@path, other)
+      method.call(encrypted, previous)
+    end
+    expect { edit.save('new-model') }.to raise_error(described_class::Error, /changed during save/)
+    expect(File.binread(@path)).to eq(other)
+    expect(Dir.children(@root)).to eq(['selected-vault'])
+  end
+
+  it 'fails closed with a different device response and redacted open errors' do
+    bytes = File.binread(@path)
+    allow(PWN::Plugins::YubiKey).to receive(:challenge_response).and_return('x' * 20)
+    expect { described_class.new([]) }.to raise_error(described_class::Error, /Cannot open vault/)
+    expect(File.binread(@path)).to eq(bytes)
+  end
+
+  it 'opens and saves the selected hardware scope without requiring or creating a decryptor' do
+    expect(PWN::Config).not_to receive(:refresh_env)
+    expect(PWN::Plugins::AuthenticationHelper).not_to receive(:mask_password)
+    edit = described_class.new(%w[ai ollama model])
+    expect(edit.text).to include('fixture-model')
+    expect(edit.save('new-model')).to eq(:saved)
+    expect(PWN::Plugins::Vault.hardware_encrypted?(file: @path)).to be(true)
+    document = PWN::Plugins::Vault.dump(file: @path)
+    expect(document.dig(:ai, :ollama, :model)).to eq('new-model')
+    expect(document[:retained]).to eq(['fixture-value'])
+    expect(PWN::Env.dig(:ai, :ollama, :model)).to eq('new-model')
+    expect(PWN::EnvRedacted.dig(:ai, :ollama, :key)).to include('REDACTED')
+    expect(Dir.children(@root)).to eq(['selected-vault'])
+  end
+end

data/spec/lib/pwn/plugins/repl/ai_yubikey_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+RSpec.describe PWN::Plugins::REPL, 'hardware vault settings persistence' do
+  around do |example|
+    Dir.mktmpdir('ai-yubikey-') do |root|
+      @root = root
+      example.run
+    end
+  end
+
+  before do
+    allow(Dir).to receive(:home).and_return(@root)
+    stub_const('PWN::Plugins::YubiKey', double('synthetic YubiKey'))
+    allow(PWN::Plugins::YubiKey).to receive(:challenge_response) do |opts|
+      OpenSSL::HMAC.digest('SHA1', 'synthetic-slot-secret', opts[:challenge])
+    end
+    @path = File.join(@root, 'selected-vault')
+    @original = { ai: { active: 'ollama', ollama: { model: 'fixture-model', system_role_content: 'fixture-role' } }, retained: 'fixture-value' }
+    File.binwrite(@path, PWN::Plugins::Vault.encrypt_data(data: YAML.dump(@original), yubikey: { slot: 2 }))
+    stub_const('PWN::Env', @original.merge(driver_opts: { pwn_env_path: @path, pwn_dec_path: File.join(@root, 'absent-sidecar') }))
+  end
+
+  it 'preserves ciphertext and Env on encryption failure without logging private exception content' do
+    bytes = File.binread(@path)
+    env = Marshal.dump(PWN::Env)
+    allow(PWN::Plugins::Vault).to receive(:encrypt_data).and_raise(IOError, 'synthetic-private-exception')
+    expect do
+      expect(described_class.persist_ai_selection(engine: 'ollama', model: 'new-model')).to be(false)
+    end.to output(/settings persist failed: IOError/).to_stderr
+    expect(File.binread(@path)).to eq(bytes)
+    expect(Marshal.dump(PWN::Env)).to eq(env)
+    expect(Dir.children(@root)).to eq(['selected-vault'])
+    expect do
+      described_class.persist_ai_selection(engine: 'ollama', model: 'new-model')
+    end.not_to output(/synthetic-private-exception/).to_stderr
+  end
+
+  it 'persists model and effort into the hardware vault without converting its format or losing other settings' do
+    expect(described_class.persist_ai_selection(engine: 'ollama', model: 'new-model', reasoning_effort: 'high')).to be(true)
+    expect(PWN::Plugins::Vault.hardware_encrypted?(file: @path)).to be(true)
+    expected = { ai: { active: 'ollama', ollama: { model: 'new-model', system_role_content: 'fixture-role', reasoning_effort: 'high' } }, retained: 'fixture-value' }
+    expect(PWN::Plugins::Vault.dump(file: @path)).to eq(expected)
+    expect(Dir.children(@root)).to eq(['selected-vault'])
+  end
+end

data/spec/lib/pwn/plugins/repl/mesh_vault_persistence_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+RSpec.describe PWN::Plugins::REPL, 'mesh vault persistence' do
+  before do
+    @home = Dir.mktmpdir('pwn-mesh-vault-')
+    allow(Dir).to receive(:home).and_return(@home)
+    @path = File.join(@home, 'custom-vault')
+    @decryptor = File.join(@home, 'independent-decryptor')
+    stub_const('PWN::Env', { driver_opts: { pwn_env_path: @path, pwn_dec_path: @decryptor }, plugins: {} })
+    @device = double('offline YubiKey')
+    stub_const('PWN::Plugins::YubiKey', @device)
+    allow(@device).to receive(:challenge_response) do |opts|
+      expect(opts).to include(slot: 2, serial: '123456')
+      OpenSSL::HMAC.digest('SHA1', 'synthetic-slot-secret', opts.fetch(:challenge))
+    end
+    @cfg = {
+      unrelated: 'keep', plugins: {
+        meshtastic: {
+          transport: 'mqtt', channel: { active: 'LongFast', LongFast: { psk: 'fixture-psk', topic: '2/e/LongFast/#' } },
+          mqtt: { username: 'fixture-user', password: 'fixture-password' }, serial: { port: '/dev/fixture-old', baud: 115_200 }
+        }
+      }
+    }
+    File.write(@path, YAML.dump(@cfg))
+    PWN::Plugins::Vault.encrypt(file: @path, yubikey: { slot: 2, serial: '123456' })
+    expect(PWN::Plugins::AuthenticationHelper).not_to receive(:mask_password)
+    allow(described_class).to receive(:mesh_ui_puts)
+    allow(ENV).to receive(:fetch).and_call_original
+    allow(ENV).to receive(:fetch).with('PWN_DECRYPTOR_KEY', nil).and_return(nil)
+    allow(ENV).to receive(:fetch).with('PWN_DECRYPTOR_IV', nil).and_return(nil)
+  end
+
+  after { FileUtils.remove_entry(@home) }
+
+  it 'merges menu settings into a hardware vault without a decryptor or plaintext rewrite' do
+    expect(PWN::Plugins::Vault).to receive(:update).with(file: @path, decryptor_file: @decryptor).and_call_original
+    expect(PWN::Plugins::Vault).not_to receive(:decrypt)
+    expect(PWN::Plugins::Vault).not_to receive(:encrypt)
+    expect(File).not_to receive(:write)
+    mesh = { 'transport' => 'serial', 'serial' => { 'port' => '/dev/fixture-new' }, 'channel' => { 'active' => 'LongFast' } }
+
+    expect(described_class.persist_mesh_env(mesh: mesh)).to be(true)
+    persisted = PWN::Plugins::Vault.dump(file: @path)
+    expect(persisted.dig(:plugins, :meshtastic)).to eq(@cfg.dig(:plugins, :meshtastic).merge(transport: 'serial', serial: { port: '/dev/fixture-new', baud: 115_200 }))
+    expect(persisted[:unrelated]).to eq('keep')
+    expect(File.binread(@path)).to start_with(PWN::Plugins::Vault::YUBIKEY_HEADER)
+    expect(File.stat(@path).mode & 0o777).to eq(0o600)
+    expect(Dir.children(@home)).to eq(['custom-vault'])
+    expect(described_class).not_to have_received(:mesh_ui_puts)
+  end
+
+  it 'keeps legacy credentials and nested mesh settings while staging ciphertext only' do
+    credentials = { key: Base64.strict_encode64('k' * 32), iv: Base64.strict_encode64('i' * 16) }
+    File.write(@decryptor, YAML.dump(credentials))
+    File.chmod(0o400, @decryptor)
+    File.write(@path, YAML.dump(@cfg))
+    PWN::Plugins::Vault.encrypt({ file: @path }.merge(credentials))
+    before = File.binread(@path)
+    sidecar_before = File.binread(@decryptor)
+    expect(File).not_to receive(:write)
+    expect(PWN::Plugins::Vault).not_to receive(:decrypt)
+    expect(PWN::Plugins::Vault).not_to receive(:encrypt)
+    expect(Tempfile).to receive(:create).and_wrap_original do |create, *args, &block|
+      create.call(*args) do |temp|
+        expect(temp).to receive(:write).and_wrap_original do |write, bytes|
+          plaintext = PWN::Plugins::Vault.decrypt_data(credentials.merge(data: bytes))
+          expect(YAML.safe_load(plaintext, permitted_classes: [Symbol], symbolize_names: true).dig(:plugins, :meshtastic, :serial)).to eq(port: '/dev/fixture-new', baud: 115_200)
+          expect(bytes).not_to include('fixture-password', 'fixture-psk')
+          expect(File.binread(@path)).to eq(before)
+          expect(temp.stat.mode & 0o777).to eq(0o600)
+          write.call(bytes)
+        end
+        block.call(temp)
+      end
+    end
+
+    expect(described_class.persist_mesh_env(mesh: { serial: { port: '/dev/fixture-new' } })).to be(true)
+    persisted = PWN::Plugins::Vault.dump({ file: @path }.merge(credentials))
+    expect(persisted.dig(:plugins, :meshtastic)).to eq(@cfg.dig(:plugins, :meshtastic).merge(serial: { port: '/dev/fixture-new', baud: 115_200 }))
+    expect(persisted[:unrelated]).to eq('keep')
+    expect(File.binread(@decryptor)).to eq(sidecar_before)
+    expect(File.stat(@decryptor).mode & 0o777).to eq(0o400)
+    expect(File.stat(@path).mode & 0o777).to eq(0o600)
+    expect(Dir.children(@home)).to match_array(%w[custom-vault independent-decryptor])
+  end
+
+  it 'uses the default vault and live mesh settings when no overrides are supplied' do
+    default_path = File.join(@home, '.pwn', 'pwn.yaml')
+    FileUtils.mkdir_p(File.dirname(default_path))
+    FileUtils.cp(@path, default_path)
+    before = File.binread(@path)
+    PWN::Env[:driver_opts] = {}
+    PWN::Env[:plugins][:meshtastic] = { transport: 'serial' }
+
+    expect(described_class.persist_mesh_env).to be(true)
+    expect(PWN::Plugins::Vault.dump(file: default_path).dig(:plugins, :meshtastic)).to eq(@cfg.dig(:plugins, :meshtastic).merge(transport: 'serial'))
+    expect(File.binread(@path)).to eq(before)
+    expect(Dir.children(File.dirname(default_path))).to eq(['pwn.yaml'])
+  end
+
+  it 'does not overwrite a concurrent ciphertext change' do
+    concurrent = PWN::Plugins::Vault.encrypt_data(data: YAML.dump(@cfg.merge(unrelated: 'newer')), yubikey: { slot: 2, serial: '123456' })
+    allow(PWN::Plugins::Vault).to receive(:encrypt_data).and_wrap_original do |encrypt, opts|
+      ciphertext = encrypt.call(opts)
+      File.binwrite(@path, concurrent)
+      ciphertext
+    end
+
+    expect(described_class.persist_mesh_env(mesh: { transport: 'serial' })).to be(false)
+    expect(File.binread(@path)).to eq(concurrent)
+    expect(Dir.children(@home)).to eq(['custom-vault'])
+    expect(described_class).to have_received(:mesh_ui_puts).with(text: '[pwn-mesh] persist skipped: IOError')
+  end
+
+  it 'does not use a software sidecar when the hardware device is unavailable' do
+    File.write(@decryptor, YAML.dump(key: Base64.strict_encode64('k' * 32), iv: Base64.strict_encode64('i' * 16)))
+    before = File.binread(@path)
+    sidecar_before = File.binread(@decryptor)
+    allow(@device).to receive(:challenge_response).and_raise(IOError, 'synthetic-private-error')
+    expect(PWN::Plugins::Vault).not_to receive(:encrypt_data)
+
+    expect(described_class.persist_mesh_env(mesh: { transport: 'serial' })).to be(false)
+    expect(File.binread(@path)).to eq(before)
+    expect(File.binread(@decryptor)).to eq(sidecar_before)
+    expect(described_class).to have_received(:mesh_ui_puts).with(text: '[pwn-mesh] persist skipped: IOError')
+  end
+
+  it 'leaves hardware ciphertext untouched when the device disappears during re-encryption' do
+    before = File.binread(@path)
+    calls = 0
+    allow(@device).to receive(:challenge_response) do |opts|
+      calls += 1
+      raise IOError, 'synthetic-private-error' if calls > 1
+
+      OpenSSL::HMAC.digest('SHA1', 'synthetic-slot-secret', opts.fetch(:challenge))
+    end
+    expect(PWN::Plugins::Vault).not_to receive(:decrypt)
+    expect(File).not_to receive(:write)
+    expect(Tempfile).not_to receive(:create)
+
+    expect(described_class.persist_mesh_env(mesh: { transport: 'serial' })).to be(false)
+    expect(described_class).to have_received(:mesh_ui_puts).with(text: '[pwn-mesh] persist skipped: IOError')
+    expect(File.binread(@path)).to eq(before)
+    expect(Dir.children(@home)).to eq(['custom-vault'])
+  end
+end

data/spec/lib/pwn/plugins/repl/vault_yaml_serialization_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe PWN::Plugins::REPL::AIConsole::VaultEdit, 'YAML scalar fidelity' do
+  it 'preserves colon-prefixed lines inside nested mapping and array values' do
+    value = { setting: "before\n:leading-colon\nafter\n", rows: [{ text: "line\n:other: value\n" }] }
+    editor = described_class.allocate
+    expect(editor.parse(editor.serialize(value))).to eq(value)
+  end
+end

data/spec/lib/pwn/plugins/repl/vault_yubikey_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'stringio'
+
+RSpec.describe PWN::Plugins::REPL::Vault, 'hardware pwn-vault command' do
+  around do |example|
+    Dir.mktmpdir('repl-vault-yubikey-') do |root|
+      @root = root
+      example.run
+    end
+  end
+
+  before do
+    allow(Dir).to receive(:home).and_return(@root)
+    stub_const('PWN::Plugins::YubiKey', double('synthetic YubiKey'))
+    allow(PWN::Plugins::YubiKey).to receive(:challenge_response) do |opts|
+      OpenSSL::HMAC.digest('SHA1', 'synthetic-slot-secret', opts[:challenge])
+    end
+    @path = File.join(@root, 'selected-vault')
+    original = { ai: { active: 'ollama', ollama: { model: 'fixture-model' } } }
+    File.binwrite(@path, PWN::Plugins::Vault.encrypt_data(data: YAML.dump(original), yubikey: { slot: 2 }))
+    stub_const('PWN::Env', { driver_opts: { pwn_env_path: @path } })
+    described_class.add_commands
+    @command = Pry::Commands.find_command('pwn-vault').new(pry_instance: Pry.new, output: StringIO.new)
+  end
+
+  it 'edits and refreshes a hardware vault without requiring a sidecar or passing software keys' do
+    expect(PWN::Plugins::Vault).to receive(:edit).with({ file: @path, yubikey: { slot: 2 } }) do |opts|
+      PWN::Plugins::Vault.update(opts) { |cfg| cfg[:ai][:ollama][:model] = 'new-model' }
+    end
+    expect(PWN::Config).to receive(:refresh_env).with({ pwn_env_path: @path, pwn_dec_path: "#{@path}.decryptor", yubikey: { slot: 2 } })
+    @command.process
+    expect(PWN::Plugins::Vault.dump(file: @path).dig(:ai, :ollama, :model)).to eq('new-model')
+    expect(PWN::Plugins::Vault.hardware_encrypted?(file: @path)).to be(true)
+    expect(Dir.children(@root)).to eq(['selected-vault'])
+  end
+end

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

@@ -118,6 +118,8 @@ describe PWN::Plugins::REPL, 'mesh terminal layout' do
     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.const_defined?(:MeshSndrWin)).to be(false)
+    expect(PWN.const_defined?(:MeshRcvrWin)).to be(false)
     expect(PWN::MeshTxWin).to equal(old)
     expect(old).not_to have_received(:close)
   ensure

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

@@ -17,7 +17,14 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
       File.write("#{path}.decryptor", YAML.dump(key: key, iv: iv))
       PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
       PWN::Env[:driver_opts] = { pwn_env_path: path, pwn_dec_path: "#{path}.decryptor" }
+      expect(PWN::Plugins::Vault).not_to receive(:decrypt)
+      allow(File).to receive(:write).and_wrap_original do |method, target, bytes, *args|
+        expect(bytes.to_s).not_to include('new role')
+        method.call(target, bytes, *args)
+      end
       expect(described_class.pwn_ai_apply_system_role(engine: 'openai', content: "new role\nsecond line")).to eq(:saved)
+      RSpec::Mocks.space.proxy_for(PWN::Plugins::Vault).reset
+      RSpec::Mocks.space.proxy_for(File).reset
       expect(PWN::Env.dig(:ai, :openai, :system_role_content)).to eq("new role\nsecond line")
       expect(File.read(path)).not_to include('new role')
       PWN::Plugins::Vault.decrypt(file: path, key: key, iv: iv)
@@ -42,7 +49,11 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
       PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
       ciphertext = File.binread(path)
       PWN::Env[:driver_opts] = { pwn_env_path: path, pwn_dec_path: "#{path}.decryptor" }
-      allow(PWN::Plugins::Vault).to receive(:encrypt).and_raise(IOError, 'fixture encryption failure')
+      allow(OpenSSL::Cipher).to receive(:new).and_wrap_original do |method, *args|
+        cipher = method.call(*args)
+        allow(cipher).to receive(:encrypt).and_raise(IOError, 'fixture encryption failure')
+        cipher
+      end
       expect { described_class.pwn_ai_apply_system_role(engine: 'openai', content: 'unsaved') }.to raise_error(/not saved/)
       expect(PWN::Env.dig(:ai, :openai, :system_role_content)).to eq('original')
       expect(File.binread(path)).to eq(ciphertext)
@@ -51,6 +62,47 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
       PWN::Env[:driver_opts] = previous_driver_opts
     end
 
+    it 'leaves no plaintext staging bytes when killed at encryption startup' do
+      previous_driver_opts = PWN::Env[:driver_opts]
+      path = File.join(@tmp, 'kill-model.yaml')
+      key = Base64.strict_encode64('k' * 32)
+      iv = Base64.strict_encode64('i' * 16)
+      File.write(path, YAML.dump(ai: { active: 'openai' }, fixture: 'PRIVATE_FIXTURE_SENTINEL'))
+      File.write("#{path}.decryptor", YAML.dump(key: key, iv: iv))
+      PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
+      ciphertext = File.binread(path)
+      PWN::Env[:driver_opts] = { pwn_env_path: path }
+      reader, writer = IO.pipe
+      pid = fork do
+        reader.close
+        allow(OpenSSL::Cipher).to receive(:new).and_wrap_original do |method, *args|
+          cipher = method.call(*args)
+          allow(cipher).to receive(:encrypt) do
+            writer.write('ready')
+            sleep 60
+          end
+          cipher
+        end
+        described_class.persist_ai_selection(engine: 'openai', model: 'offline')
+        exit! 1
+      end
+      writer.close
+      Timeout.timeout(5) { expect(reader.read(5)).to eq('ready') }
+      Process.kill('KILL', pid)
+      Process.wait(pid)
+      pid = nil
+      expect(File.binread(path)).to eq(ciphertext)
+      # Shared Vault.update encrypts before allocating a ciphertext-only stage.
+      stages = Dir.glob(File.join(@tmp, '{.pwn-ai-selection*,.pwn-vault-*}'))
+      expect(stages).to be_empty
+    ensure
+      Process.kill('KILL', pid) if pid
+      Process.wait(pid) if pid
+      reader&.close
+      writer&.close unless writer&.closed?
+      PWN::Env[:driver_opts] = previous_driver_opts
+    end
+
     it 'rejects role saves without a decryptor or after switching the active engine' do
       previous_driver_opts = PWN::Env[:driver_opts]
       PWN::Env[:driver_opts] = { pwn_env_path: File.join(@tmp, 'missing.yaml'), pwn_dec_path: File.join(@tmp, 'missing.decryptor') }
@@ -783,15 +835,14 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
         yaml = File.join(dir, 'pwn.yaml')
         dec = "#{yaml}.decryptor"
         File.write(yaml, YAML.dump({ plugins: { meshtastic: { transport: 'mqtt', channel: { active: 'LongFast' } } } }))
-        File.write(dec, YAML.dump({ key: 'k' * 32, iv: 'i' * 16 }))
-        allow(PWN::Plugins::Vault).to receive(:decrypt)
-        allow(PWN::Plugins::Vault).to receive(:encrypt)
+        PWN::Plugins::Vault.create(file: yaml, decryptor_file: dec)
+        credentials = YAML.safe_load_file(dec, symbolize_names: true)
         prev = PWN::Env[:driver_opts]
         PWN::Env[:driver_opts] = { pwn_env_path: yaml, pwn_dec_path: dec }
         described_class.persist_mesh_env(
           mesh: { transport: 'serial', channel: { active: 'LongFast' }, serial: { port: '/dev/ttyACM0' } }
         )
-        cfg = YAML.load_file(yaml, symbolize_names: true)
+        cfg = PWN::Plugins::Vault.dump({ file: yaml }.merge(credentials))
         expect(cfg.dig(:plugins, :meshtastic, :transport).to_s).to eq('serial')
         expect(cfg.dig(:plugins, :meshtastic, :channel, :active).to_s).to eq('LongFast')
         expect(cfg.dig(:plugins, :meshtastic, :serial, :port)).to eq('/dev/ttyACM0')

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe PWN::Plugins::TransparentBrowser, 'jev action loop' do
+  let(:browser) { double('browser', goto: nil) }
+  let(:browser_obj) { { type: :headless, browser: browser } }
+
+  before do
+    Thread.current[:pwn_jev_model] = nil
+    allow(PWN::Env).to receive(:dig).and_call_original
+    allow(PWN::Env).to receive(:dig).with(:ai, :openwebui).and_return({ base_uri: 'https://ow.example', key: 'token', model: 'llama' })
+    allow(PWN::Env).to receive(:dig).with(:ai, :active).and_return(:grok)
+    allow(PWN::Env).to receive(:dig).with(:ai, :grok, :model).and_return('grok-4')
+    allow(PWN::AI::OpenWebUI).to receive(:get_models).and_return([{ id: 'jev-27b' }])
+  end
+
+  after { Thread.current[:pwn_jev_model] = nil }
+
+  it 'stays inactive when Open WebUI has no Jev model' do
+    allow(PWN::AI::OpenWebUI).to receive(:get_models).and_return([{ id: 'llama' }])
+    expect(described_class.act(browser_obj: browser_obj, goal: 'find the article')).to include(available: false, status: 'unavailable')
+  end
+
+  it 'asks Jev for the operation and the active engine only for typed text' do
+    scripts = []
+    allow(browser).to receive(:execute_script) do |script|
+      if script.include?('querySelectorAll')
+        { 'url' => 'https://example.test', 'title' => 'Example', 'rows' => [{ 'index' => 1, 'role' => 'textbox', 'name' => 'Where to?', 'value' => '' }] }
+      else
+        scripts << script
+        { 'status' => scripts.length == 1 ? 'acted' : 'done' }
+      end
+    end
+    decisions = ['{"operation":"TYPE_TEXT","target":1}', '{"operation":"DONE","target":0}']
+    allow(PWN::AI::OpenWebUI).to receive(:chat) { { choices: [{ role: 'assistant', content: decisions.shift }] } }
+    allow(PWN::AI::Grok).to receive(:chat).and_return({ choices: [{ role: 'assistant', content: '{"text":"London"}' }] })
+
+    result = described_class.act(browser_obj: browser_obj, goal: 'Search for London', steps: 2)
+
+    expect(result).to include(available: true, status: 'done', jev_model: 'jev-27b', text_engine: :grok, text_model: 'grok-4')
+    expect(PWN::AI::Grok).to have_received(:chat)
+    expect(scripts.first).to include('London')
+    expect(scripts.first).not_to include('querySelectorAll')
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe PWN::Plugins::Vault, 'native YubiKey selectors' do
+  before do
+    @device = double('offline native YubiKey')
+    stub_const('PWN::Plugins::YubiKey', @device)
+    allow(@device).to receive(:challenge_response) { |opts| OpenSSL::HMAC.digest('SHA1', 'fixture-slot', opts[:challenge]) }
+  end
+
+  it 'forwards caller-owned native controls unchanged and persists only public slot and serial selectors' do
+    connection = double('native connection', exchange: ''.b)
+    selector = { slot: 1, serial: '001234', device_path: '/fixture/native-device', connection: connection, timeout: 1.5 }.freeze
+    expect(@device).to receive(:challenge_response).with(hash_including(selector)).twice
+    envelope = described_class.seal_credentials(credentials: { token: 'fixture' }, yubikey: selector)
+    expect(envelope.fetch('yubikey').keys).to contain_exactly('slot', 'serial', 'challenge')
+    expect(envelope.fetch('yubikey')).to include('slot' => 1, 'serial' => '001234')
+    expect(described_class.open_credentials(envelope: envelope, yubikey: selector)).to eq('token' => 'fixture')
+  end
+
+  it 'accepts an exact caller-owned smartcard reader without serial and never persists it' do
+    selector = { slot: 2, reader: ' Fixture NFC reader ' }.freeze
+    expect(@device).to receive(:challenge_response).with(hash_including(selector)).twice
+    envelope = described_class.seal_credentials(credentials: {}, yubikey: selector)
+    expect(envelope.fetch('yubikey').keys).to contain_exactly('slot', 'challenge')
+    expect(described_class.open_credentials(envelope: envelope, yubikey: selector)).to eq({})
+  end
+end