pwn 0.5.783 → 0.5.785

data/spec/lib/pwn/backups_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::Backups do
+  before do
+    @home = Dir.mktmpdir('pwn-backups-')
+    Thread.current[:pwn_backup_root] = nil
+    allow(Dir).to receive(:home).and_return(@home)
+    @source = File.join(@home, 'source')
+    File.write(@source, 'original')
+  end
+
+  after { FileUtils.remove_entry(@home) }
+
+  it 'retains no more than seven generations across producers' do
+    10.times { described_class.capture(path: @source, label: 'fixture') }
+    root = File.join(@home, '.pwn', 'backup')
+    expect(Dir.children(root).count { |name| File.directory?(File.join(root, name)) }).to eq(7)
+  end
+
+  it 'keeps interrupted transactions prepared and refuses an eighth pinned generation' do
+    7.times do
+      expect do
+        described_class.transaction do
+          described_class.capture(path: @source, label: 'fixture')
+          raise IOError, 'interrupted'
+        end
+      end.to raise_error(IOError, 'interrupted')
+    end
+    expect { described_class.capture(path: @source) }.to raise_error(IOError, /capacity/)
+    expect(File.read(@source)).to eq('original')
+  end
+
+  it 'pins actual evidence paths but not quoted inventory prose' do
+    copies = 7.times.map { described_class.capture(path: @source) }
+    File.write(File.join(@home, '.pwn', 'learning.jsonl'), JSON.generate(evidence_path: copies.first, prose: "old path #{copies[1]}"))
+    described_class.capture(path: @source)
+    expect(File).to exist(copies.first)
+    expect(File).not_to exist(copies[1])
+  end
+
+  it 'fails admission on malformed reference data without losing any recovery copy' do
+    copies = 7.times.map { described_class.capture(path: @source) }
+    File.write(File.join(@home, '.pwn', 'learning.jsonl'), '{broken')
+    expect { described_class.capture(path: @source) }.to raise_error(IOError, /references/)
+    expect(copies.all? { |path| File.file?(path) }).to be(true)
+  end
+
+  it 'uses one generation for nested producers and preserves failed result recovery' do
+    copies = []
+    described_class.transaction do
+      copies << described_class.capture(path: @source, label: 'learning')
+      copies << described_class.capture(path: @source, label: 'preferences')
+      { ok: false, error: 'fixture' }
+    end
+    generations = copies.map { |path| File.dirname(path, 2) }.uniq
+    expect(generations.length).to eq(1)
+    expect(JSON.parse(File.read(File.join(generations.first, '.generation.json')))['state']).to eq('prepared')
+  end
+
+  it 'serializes separate processes at the global seven-folder bound' do
+    root = File.join(@home, '.pwn', 'backup')
+    pids = 4.times.map do
+      fork do
+        4.times { described_class.capture(path: @source) }
+        exit! 0
+      rescue StandardError
+        exit! 1
+      end
+    end
+    expect(pids.map { |pid| Process.wait2(pid).last.exitstatus }).to eq([0, 0, 0, 0])
+    expect(Dir.children(root).count { |name| File.directory?(File.join(root, name)) }).to eq(7)
+  end
+
+  it 'requires exact manifest acknowledgement to release interrupted recovery' do
+    backup = nil
+    expect do
+      described_class.transaction do
+        backup = described_class.capture(path: @source)
+        raise IOError, 'interrupted'
+      end
+    end.to raise_error(IOError)
+    generation = File.basename(File.dirname(backup, 2))
+    manifest = File.join(File.dirname(backup, 2), '.generation.json')
+    expect { described_class.reconcile(generation: generation, confirmed: true, expected_sha256: 'wrong') }.to raise_error(IOError)
+    result = described_class.reconcile(generation: generation, confirmed: true, expected_sha256: Digest::SHA256.file(manifest).hexdigest, pinned: false)
+    expect(result).to include(state: 'complete', pinned: false)
+    expect(File.read(backup)).to eq('original')
+  end
+
+  it 'relocates only explicitly selected unreferenced legacy copies after quiescence confirmation' do
+    root = File.join(@home, '.pwn')
+    FileUtils.mkdir_p(root)
+    legacy = File.join(root, 'learning.jsonl.bak-lean-20200101')
+    File.write(legacy, 'legacy bytes')
+    expect(described_class.relocate_legacy(paths: [legacy])[:moved]).to eq([])
+    expect { described_class.relocate_legacy(paths: [legacy], dry_run: false) }.to raise_error(ArgumentError, /writers/)
+    File.write(File.join(root, 'memory.json'), JSON.generate(evidence: legacy))
+    expect { described_class.relocate_legacy(paths: [legacy], dry_run: false, writers_stopped: true) }.to raise_error(IOError, /referenced/)
+    File.write(File.join(root, 'memory.json'), '{}')
+    result = described_class.relocate_legacy(paths: [legacy], dry_run: false, writers_stopped: true)
+    expect(File).not_to exist(legacy)
+    expect(File.read(result[:moved].fetch(legacy))).to eq('legacy bytes')
+  end
+
+  it 'tightens an owned group-writable backup directory before writing' do
+    root = File.join(@home, '.pwn', 'backup')
+    FileUtils.mkdir_p(root)
+    File.chmod(0o775, root)
+    described_class.capture(path: @source, label: 'fixture')
+    expect(File.stat(root).mode & 0o777).to eq(0o700)
+  end
+end

data/spec/lib/pwn/config_redaction_yubikey_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe PWN::Config, 'YubiKey configuration redaction' do
+  it 'redacts string-keyed hardware settings inside arrays without hiding public selectors' do
+    config = { devices: [{ 'PIN' => '1', 'management-key' => 'synthetic-key', 'oath-secret' => 'synthetic-oath', 'serial' => '12345678', 'slot' => 2 }] }
+    result = described_class.redact_sensitive_artifacts(config: config)
+    masked = result[:devices].first
+    expect(masked.values_at('PIN', 'management-key', 'oath-secret').uniq).to eq(['>>> REDACTED >>> USE `pwn-vault` FOR ADMINISTRATION <<< REDACTED <<<'])
+    expect(masked).to include('serial' => '12345678', 'slot' => 2)
+    expect(config.dig(:devices, 0, 'PIN')).to eq('1')
+  end
+
+  it 'uses the same constant mask for short PINs and hardware secrets while retaining public selectors' do
+    fields = %i[pin new_pin admin_pin puk new_puk management_key new_management_key management_password access_code new_access_code oath_secret oath_password unlock_code unlock_password lock_code new_lock_code reset_code scp scp_key scp_keys scp03_key scp11_key static_password hmac_secret]
+    values = fields.to_h { |field| [field, '123456'] }
+    values[:pin] = '1'
+    values[:puk] = '87654321'
+    config = { plugins: { yubikey: values.merge(serial: '12345678', slot: 2, reader: 'fixture-reader') } }
+    before = Marshal.dump(config)
+    redacted = described_class.redact_sensitive_artifacts(config: config).dig(:plugins, :yubikey)
+    mask = described_class.redact_sensitive_artifacts(config: { password: 'different-value' })[:password]
+    fields.each { |field| expect(redacted[field]).to eq(mask), "#{field} must use the constant mask" }
+    expect(redacted).to include(serial: '12345678', slot: 2, reader: 'fixture-reader')
+    expect(Marshal.dump(config)).to eq(before)
+  end
+end

data/spec/lib/pwn/config_yubikey_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+RSpec.describe PWN::Config, 'hardware vault configuration' do
+  around do |example|
+    Dir.mktmpdir('config-yubikey-') do |root|
+      @root = root
+      example.run
+    end
+  end
+
+  before do
+    allow(Dir).to receive(:home).and_return(@root)
+    stub_const('PWN::Env', {})
+    stub_const('PWN::EnvRedacted', {})
+    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
+    allow(described_class).to receive(:install_default_skills)
+    allow(described_class).to receive(:load_skills)
+    allow(PWN::Memory).to receive(:load)
+    allow(PWN::Cron).to receive(:install_defaults)
+    allow(PWN::Migrate).to receive(:needed?).and_return(false)
+    @path = File.join(@root, 'pwn.yaml')
+  end
+
+  it 'rejects an invalid hardware selector rather than falling back to a software sidecar' do
+    expect { described_class.default_env(pwn_env_path: @path, yubikey: false) }.to raise_error(ArgumentError)
+    expect(File).not_to exist(@path)
+    expect(File).not_to exist("#{@path}.decryptor")
+  end
+
+  it 'creates the default hardware configuration path when called directly' do
+    described_class.default_env(yubikey: { slot: 2 })
+    path = File.join(@root, '.pwn', 'pwn.yaml')
+    expect(PWN::Plugins::Vault.dump(file: path)).to eq(described_class.env_template)
+    expect(File).not_to exist("#{path}.decryptor")
+  end
+
+  it 'preserves multiline template values containing leading colons during creation' do
+    template = Marshal.load(Marshal.dump(described_class.env_template))
+    text = "before\n:leading-colon\nafter\n"
+    template[:ai][:ollama][:system_role_content] = text
+    allow(described_class).to receive(:env_template).and_return(template)
+    described_class.default_env(pwn_env_path: @path, yubikey: {})
+    expect(PWN::Plugins::Vault.dump(file: @path).dig(:ai, :ollama, :system_role_content)).to eq(text)
+  end
+
+  it 'retains software creation by default and honors the explicitly selected legacy decryptor' do
+    sidecar = File.join(@root, 'custom-sidecar')
+    expect(PWN::Plugins::YubiKey).not_to receive(:challenge_response)
+    described_class.refresh_env(pwn_env_path: @path, pwn_dec_path: sidecar)
+    expect(PWN::Plugins::Vault.hardware_encrypted?(file: @path)).to be(false)
+    credentials = YAML.safe_load_file(sidecar, symbolize_names: true)
+    expect(PWN::Plugins::Vault.dump(credentials.merge(file: @path))).to eq(described_class.env_template)
+    described_class.refresh_env(pwn_env_path: @path, pwn_dec_path: sidecar)
+    expect(PWN::Env.dig(:driver_opts, :pwn_dec_path)).to eq(sidecar)
+    expect(File).not_to exist("#{@path}.decryptor")
+  end
+
+  it 'creates a hardware vault only on explicit opt-in, without staging plaintext or making a sidecar' do
+    described_class.refresh_env(pwn_env_path: @path, yubikey: { slot: 2 })
+    expect(PWN::Plugins::Vault.hardware_encrypted?(file: @path)).to be(true)
+    expect(PWN::Plugins::Vault.dump(file: @path)).to eq(described_class.env_template)
+    expect(File).not_to exist("#{@path}.decryptor")
+    expect(File.stat(@path).mode & 0o777).to eq(0o600)
+    expect(PWN::Env).not_to have_key(:yubikey)
+  end
+
+  it 'leaves no plaintext configuration behind when opted-in hardware creation fails' do
+    allow(PWN::Plugins::YubiKey).to receive(:challenge_response).and_raise(IOError, 'synthetic device unavailable')
+    expect { described_class.default_env(pwn_env_path: @path, yubikey: { slot: 2 }) }.to raise_error(IOError)
+    expect(File).not_to exist(@path)
+    expect(File).not_to exist("#{@path}.decryptor")
+  end
+
+  it 'refreshes a self-describing hardware vault without a decryptor or software-key prompt' do
+    original = { ai: { active: 'ollama', ollama: { model: 'fixture-model' } }, retained: 'fixture-value' }
+    bytes = PWN::Plugins::Vault.encrypt_data(data: YAML.dump(original), yubikey: { slot: 2, serial: '12345678' })
+    File.binwrite(@path, bytes)
+    expect(PWN::Plugins::AuthenticationHelper).not_to receive(:mask_password)
+    described_class.refresh_env(pwn_env_path: @path)
+    expect(PWN::Env.dig(:ai, :ollama, :model)).to eq('fixture-model')
+    expect(PWN::Env[:retained]).to eq('fixture-value')
+    expect(PWN::Env.dig(:driver_opts, :pwn_env_path)).to eq(@path)
+    expect(File.binread(@path)).to eq(bytes)
+    expect(File).not_to exist("#{@path}.decryptor")
+  end
+end

data/spec/lib/pwn/cron_spec.rb

@@ -34,6 +34,48 @@ describe PWN::Cron do
       FileUtils.remove_entry(@tmp) if @tmp && Dir.exist?(@tmp)
     end
 
+    it 'removes only a schedule without native effects when explicitly requested' do
+      target = described_class.create(name: 'curriculum_practice_nightly', enabled: false, sync_native: false)
+      other = described_class.create(name: 'custom', enabled: false, sync_native: false)
+      log = File.join(@tmp, "#{target[:id]}.log")
+      File.write(log, 'evidence')
+      expect(described_class).not_to receive(:remove_native_job)
+      described_class.remove(id: target[:id], sync_native: false)
+      expect(described_class.list).to eq(other[:id] => other)
+      expect(File.read(log)).to eq('evidence')
+    end
+
+    it 'does not resurrect a schedule removed during execution or erase concurrent creations' do
+      target = described_class.create(name: 'running', ruby: '42', sync_native: false)
+      allow(described_class).to receive(:eval) do
+        described_class.remove(id: target[:id], sync_native: false)
+        described_class.create(name: 'concurrent', ruby: '43', sync_native: false)
+        42
+      end
+      described_class.run(id: target[:id])
+      expect(described_class.list.values.map { |row| row[:name] }).to eq(['concurrent'])
+    end
+
+    it 'refuses destructive registry updates when existing YAML is corrupt' do
+      File.write(described_class.jobs_file, '--- [broken')
+      before = File.binread(described_class.jobs_file)
+      expect { described_class.remove(id: 'absent', sync_native: false) }.to raise_error(IOError)
+      expect(File.binread(described_class.jobs_file)).to eq(before)
+    end
+
+    it 'preserves concurrent process creations with atomic registry readback' do
+      count = 4
+      pids = Array.new(count) do |index|
+        fork do
+          5.times { |n| described_class.create(name: "process-#{index}-#{n}", ruby: '42', enabled: false, sync_native: false) }
+          exit! 0
+        end
+      end
+      pids.each { |pid| expect(Process.wait2(pid).last.success?).to be(true) }
+      expect(described_class.list.length).to eq(count * 5)
+      expect(Dir.glob("#{described_class.jobs_file}.*.tmp")).to be_empty
+    end
+
     it 'exposes worker control methods' do
       %i[
         due? due_jobs run_due tick worker_loop
@@ -155,9 +197,16 @@ describe PWN::Cron do
       expect(res[:started]).to be true
     end
   end
+end
+
+describe PWN::Cron do
   describe 'OS-agnostic scheduler' do
     before do
-      @tmp = Dir.mktmpdir('pwn-cron-os-spec-')
+      # install_defaults owns siblings of cron_dir (maintenance/cache/tmp).
+      # Give it a complete private root, never the shared Dir.tmpdir parent.
+      @root = Dir.mktmpdir('pwn-cron-os-spec-')
+      @tmp = File.join(@root, 'cron')
+      FileUtils.mkdir_p(@tmp)
       stub_const('PWN::Cron::CRON_DIR', @tmp)
       stub_const('PWN::Cron::JOBS_FILE', File.join(@tmp, 'jobs.yml'))
       stub_const('PWN::Cron::PID_FILE', File.join(@tmp, 'worker.pid'))
@@ -167,7 +216,53 @@ describe PWN::Cron do
 
     after do
       ENV.delete('PWN_CRON_DIR')
-      FileUtils.remove_entry(@tmp) if @tmp && Dir.exist?(@tmp)
+      FileUtils.remove_entry(@root) if @root && Dir.exist?(@root)
+    end
+
+    it 'keeps default housekeeping off every native installer' do
+      allow(described_class).to receive(:scheduler_backend).and_return(:systemd_user)
+      expect(described_class).not_to receive(:systemd_user)
+      described_class.install_defaults
+      expect(File.file?(File.join(@root, 'maintenance', 'policy.json'))).to be(true)
+      job = described_class.list.values.find { |row| row[:name] == 'session_cleanup' }
+      %i[install_native_job install_systemd_user_job install_crontab_job install_launchd_job install_schtasks_job].each do |method|
+        expect(described_class.public_send(method, job: job, apply: true)).to include(skipped: true, reason: :housekeeping_internal_only)
+      end
+      expect(Dir.glob(File.join(@tmp, 'native', "*#{job[:id]}*"))).to be_empty
+    end
+
+    it 'setup uses only the existing internal worker even with systemd available' do
+      allow(described_class).to receive(:systemd_user_available?).and_return(true)
+      expect(described_class).not_to receive(:install_scheduler)
+      expect(described_class).not_to receive(:uninstall_scheduler)
+      expect(described_class).not_to receive(:install_native_job)
+      allow(described_class).to receive(:worker_status).and_return({ running: false }, { running: true, pid: 123 })
+      expect(described_class).to receive(:ensure_worker).with(restart: false, interval: nil).once.and_return(started: true, pid: 123)
+      expect(PWN::Setup.ensure_cron(io: StringIO.new)).to include(ok: true, backend: :worker)
+    end
+
+    it 'preserves custom cron bytes and runs housekeeping identically by tick and manual run' do
+      custom = described_class.create(name: 'operator-custom', schedule: '12 9 * * *', ruby: '41', enabled: false)
+      described_class.install_defaults
+      expect(described_class.list[custom[:id]]).to eq(custom)
+      jobs = described_class.list
+      jobs.each_value { |job| job[:enabled] = false }
+      job = jobs.values.find { |row| row[:name] == 'session_cleanup' }
+      job.merge!(enabled: true, schedule: 'every 1s', ruby: 'PWN::SessionCleanup.maintain(dry_run: false)')
+      File.write(described_class.jobs_file, YAML.dump(jobs))
+      expect(PWN::SessionCleanup).to receive(:maintain).with(dry_run: false).twice.and_return(deleted: 0)
+      expect(described_class.run(id: job[:id])).to include(status: 'success', result: { deleted: 0 })
+      expect(described_class.tick(now: Time.now + 2)).to contain_exactly(include(id: job[:id], status: 'success'))
+      expect(described_class.list[custom[:id]]).to eq(custom)
+    end
+
+    it 'native worker markers exclude housekeeping while leaving custom jobs runnable' do
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with('PWN_CRON_NATIVE').and_return('1')
+      house = described_class.create(name: 'session_cleanup', ruby: 'raise "must not run"')
+      custom = described_class.create(name: 'operator-custom', schedule: 'every 1s', ruby: '41')
+      expect(described_class.tick).to contain_exactly(include(id: custom[:id], status: 'success'))
+      expect(described_class.list[house[:id]][:last_run]).to be_nil
     end
 
     it 'exposes scheduler control methods' do
@@ -178,12 +273,12 @@ describe PWN::Cron do
       ].each do |m|
         expect(PWN::Cron).to respond_to(m)
       end
-      expect(PWN::Cron::DEFAULT_JOBS.length).to eq(6)
+      expect(PWN::Cron::DEFAULT_JOBS.length).to eq(1)
       names = PWN::Cron::DEFAULT_JOBS.map { |j| j[:name] }
-      expect(names).to include('pwn_stores_lean_nightly')
-      expect(names).to include('learning_consolidate_nightly')
+      expect(names).to eq(['session_cleanup'])
       enabled = PWN::Cron::DEFAULT_JOBS.reject { |j| j[:enabled] == false }.map { |j| j[:name] }
-      expect(enabled).to contain_exactly('pwn_stores_lean_nightly', 'learning_consolidate_nightly', 'session_cleanup')
+      expect(enabled).to contain_exactly('session_cleanup')
+      expect(PWN::Cron::CURRICULUM_JOBS.length).to eq(3)
     end
 
     it 'picks a native backend per OS without consulting live daemons' do
@@ -237,6 +332,7 @@ describe PWN::Cron do
       expect(body).to include('<key>KeepAlive</key>')
       PWN::Cron.list.each_value do |job|
         next unless job[:enabled]
+        next if described_class.send(:housekeeping_job?, job: job)
 
         plist = File.join(@tmp, 'native', "com.0dayinc.pwn.cron.job.#{job[:id]}.plist")
         expect(File).to exist(plist)
@@ -247,6 +343,15 @@ describe PWN::Cron do
       end
     end
 
+    it 'rejects housekeeping execution from a systemd invocation without evaluating the payload' do
+      job = described_class.create(name: 'session_cleanup', ruby: 'raise "must not run"')
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with('/proc/self/cgroup').and_return('0::/user.slice/pwn-cron-worker.service')
+      expect(described_class.run(id: job[:id])).to include(skipped: true, reason: :housekeeping_internal_only)
+      expect(described_class.list[job[:id]][:last_run]).to be_nil
+      expect(described_class.tick).to eq([])
+    end
+
     it 'systemd backend emits OnCalendar that matches each default schedule' do
       PWN::Cron.install_defaults
       res = PWN::Cron.install_scheduler(backend: :systemd_user, apply: false)
@@ -256,6 +361,7 @@ describe PWN::Cron do
       expect(unit).to include('Restart=always')
       PWN::Cron.list.each_value do |job|
         next unless job[:enabled]
+        next if described_class.send(:housekeeping_job?, job: job)
 
         tmr = File.join(@tmp, 'native', "pwn-cron-j#{job[:id]}.timer")
         expect(File).to exist(tmr)
@@ -273,6 +379,7 @@ describe PWN::Cron do
       expect(worker).to include('PWN::Cron.ensure_worker')
       PWN::Cron.list.each_value do |job|
         next unless job[:enabled]
+        next if described_class.send(:housekeeping_job?, job: job)
 
         preview = File.read(File.join(@tmp, 'native', "job-#{job[:id]}.crontab"))
         expect(preview).to include(job[:schedule])

data/spec/lib/pwn/migrate_spec.rb

@@ -2,6 +2,39 @@
 
 require 'spec_helper'
 
+describe PWN::Migrate, 'exact migration snapshot scope' do
+  include_context 'pwn tmp sandbox'
+
+  it 'backs up nested registry paths and directory trees without cron runtime copies' do
+    FileUtils.mkdir_p(File.join(@tmp, 'cron', 'schedule-backups'))
+    FileUtils.mkdir_p(File.join(@tmp, 'skills', 'custom'))
+    File.write(File.join(@tmp, 'cron', 'jobs.yml'), "--- []\n")
+    File.write(File.join(@tmp, 'cron', 'worker.log'), 'diagnostic')
+    File.write(File.join(@tmp, 'cron', 'schedule-backups', 'receipt.json'), '{}')
+    File.write(File.join(@tmp, 'skills', 'custom', 'SKILL.md'), 'custom recovery')
+    snapshot = described_class.send(:backup!)
+    expect(File.read(File.join(snapshot, 'cron', 'jobs.yml'))).to eq("--- []\n")
+    expect(File.read(File.join(snapshot, 'skills', 'custom', 'SKILL.md'))).to eq('custom recovery')
+    expect(File).not_to exist(File.join(snapshot, 'cron', 'worker.log'))
+    expect(File).not_to exist(File.join(snapshot, 'cron', 'schedule-backups'))
+  end
+
+  it 'does not require new cron logs and maintenance copies in recovery coverage' do
+    File.write(File.join(@tmp, 'memory.json'), '{}')
+    5.times do |i|
+      path = File.join(described_class::BACKUP_ROOT, "2026010#{i + 1}_000000")
+      FileUtils.mkdir_p(path)
+      File.write(File.join(path, 'memory.json'), '{}')
+    end
+    FileUtils.mkdir_p(File.join(@tmp, 'cron', 'schedule-backups'))
+    File.write(File.join(@tmp, 'cron', 'worker.log'), 'new diagnostic')
+    File.write(File.join(@tmp, 'cron', 'schedule-backups', 'receipt.json'), '{}')
+    result = described_class.prune_backups(dry_run: false, expire_history: true)
+    expect(result).to include(deleted: [], keep: 7, scope: 'global')
+    expect(File.read(File.join(@tmp, 'cron', 'worker.log'))).to eq('new diagnostic')
+  end
+end
+
 describe PWN::Migrate do
   it 'should display information for authors' do
     authors_response = PWN::Migrate
@@ -43,6 +76,19 @@ describe PWN::Migrate do
       allow(PWN::Config).to receive(:pwn_skills_path).and_return(File.join(@tmp, 'skills'))
     end
 
+    it 'upgrades the existing three-folder policy to seven without pruning legacy data' do
+      FileUtils.mkdir_p(described_class::BACKUP_ROOT, mode: 0o700)
+      policy = File.join(described_class::BACKUP_ROOT, '.retention-policy.json')
+      File.write(policy, JSON.generate(version: 1, keep: 3, pins: [], expire_history: true))
+      File.write(described_class::SCHEMA_FILE, JSON.generate(schema: 11))
+      result = described_class.run(backup: false, io: io)
+      expect(result[:applied_migrations]).to eq([12])
+      expect(JSON.parse(File.read(policy))).to include('keep' => 7, 'scope' => 'global')
+      bytes = File.binread(policy)
+      expect(described_class.run(backup: false, io: io)[:applied_migrations]).to eq([])
+      expect(File.binread(policy)).to eq(bytes)
+    end
+
     it '.needed? / .status on a fresh (empty) root' do
       expect(PWN::Migrate.installed_schema).to eq(0)
       expect(PWN::Migrate.needed?).to be true
@@ -80,7 +126,7 @@ describe PWN::Migrate do
       File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 2))
       expect(described_class.needed?).to be(true)
       result = described_class.run(fix: false, backup: false, io: io)
-      expect(result[:applied_migrations]).to eq([3, 4, 5, 6, 7, 8, 9, 10])
+      expect(result[:applied_migrations]).to eq([3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
       expected = Marshal.load(Marshal.dump(original))
       expected['custom']['model'] = nil
       expect(YAML.safe_load_file(path)).to eq(expected)
@@ -189,7 +235,7 @@ describe PWN::Migrate do
       File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 3))
       expect(described_class.needed?).to be(true)
       result = described_class.run(fix: true, backup: false, io: io)
-      expect(result[:applied_migrations]).to eq([4, 5, 6, 7, 8, 9, 10])
+      expect(result[:applied_migrations]).to eq([4, 5, 6, 7, 8, 9, 10, 11, 12])
       creds = YAML.safe_load_file(dec, symbolize_names: true)
       user = PWN::Plugins::Vault.dump(file: yaml, key: creds[:key], iv: creds[:iv])
       expect(user[:ai][:active]).to eq('grok')
@@ -215,7 +261,7 @@ describe PWN::Migrate do
       PWN::Plugins::Vault.create(file: yaml, decryptor_file: dec)
       File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 4))
       result = described_class.run(fix: true, backup: false, io: io)
-      expect(result[:applied_migrations]).to eq([5, 6, 7, 8, 9, 10])
+      expect(result[:applied_migrations]).to eq([5, 6, 7, 8, 9, 10, 11, 12])
       creds = YAML.safe_load_file(dec, symbolize_names: true)
       user = PWN::Plugins::Vault.dump(file: yaml, key: creds[:key], iv: creds[:iv])
       expect(user.dig(:ai, :agent, :skill_review)).to eq('off')
@@ -240,7 +286,7 @@ describe PWN::Migrate do
       File.write(yaml, YAML.dump(stale).gsub(/^(\s*):/, '\1'))
       PWN::Plugins::Vault.create(file: yaml, decryptor_file: dec)
       File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 5))
-      expect(described_class.run(fix: true, backup: false, io: io)[:applied_migrations]).to eq([6, 7, 8, 9, 10])
+      expect(described_class.run(fix: true, backup: false, io: io)[:applied_migrations]).to eq([6, 7, 8, 9, 10, 11, 12])
       creds = YAML.safe_load_file(dec, symbolize_names: true)
       user = PWN::Plugins::Vault.dump(file: yaml, key: creds[:key], iv: creds[:iv])
       theme = user.dig(:ai, :tui, :theme)
@@ -287,7 +333,7 @@ describe PWN::Migrate do
       File.write(yaml, YAML.dump(stale).gsub(/^(\s*):/, '\1'))
       PWN::Plugins::Vault.create(file: yaml, decryptor_file: dec)
       File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 8))
-      expect(described_class.run(fix: true, backup: false, io: io)[:applied_migrations]).to eq([9, 10])
+      expect(described_class.run(fix: true, backup: false, io: io)[:applied_migrations]).to eq([9, 10, 11, 12])
       creds = YAML.safe_load_file(dec, symbolize_names: true)
       user = PWN::Plugins::Vault.dump(file: yaml, key: creds[:key], iv: creds[:iv])
       long_fast = user.dig(:plugins, :meshtastic, :channel, :LongFast)
@@ -311,3 +357,60 @@ describe PWN::Migrate do
     end
   end
 end
+
+describe PWN::Migrate, 'backup housekeeping' do
+  include_context 'pwn tmp sandbox'
+  let(:io) { StringIO.new }
+
+  it 'does not snapshot or rewrite the stamp on a no-op migration' do
+    File.write(File.join(@tmp, '.schema'), JSON.generate(schema: described_class::SCHEMA_VERSION))
+    before = File.binread(File.join(@tmp, '.schema'))
+    expect(described_class).not_to receive(:backup!)
+    result = described_class.run(io: io)
+    expect(result[:backup]).to be_nil
+    expect(File.binread(File.join(@tmp, '.schema'))).to eq(before)
+  end
+
+  it 'leaves legacy snapshots alone instead of running a competing pruner' do
+    root = described_class::BACKUP_ROOT
+    8.times do |i|
+      dir = File.join(root, "2026010#{i + 1}_000000")
+      FileUtils.mkdir_p(dir)
+      File.write(File.join(dir, 'learning.jsonl'), 'unique evidence')
+    end
+    result = described_class.prune_backups(dry_run: false, keep: 3, expire_history: true)
+    expect(result).to include(keep: 7, scope: 'global', deleted: [])
+    expect(Dir.children(root).length).to eq(8)
+    expect { described_class.send(:backup!) }.to raise_error(IOError)
+    expect(Dir.children(root).grep(/\A\d/).length).to eq(8)
+  end
+
+  it 'publishes a verified scoped snapshot and fails closed on a copy failure' do
+    File.write(File.join(@tmp, 'learning.jsonl'), 'historical evidence')
+    FileUtils.mkdir_p(File.join(@tmp, 'logs'))
+    File.write(File.join(@tmp, 'logs', 'debug.log'), 'not migration input')
+    path = described_class.send(:backup!)
+    expect(File.binread(File.join(path, 'learning.jsonl'))).to eq('historical evidence')
+    expect(File).not_to exist(File.join(path, 'logs'))
+    manifest = JSON.parse(File.binread(File.join(path, '.snapshot-manifest.json')))
+    expect(manifest['complete']).to be(true)
+    expect(manifest['files']).to have_key('learning.jsonl')
+    allow(FileUtils).to receive(:cp_r).and_raise(IOError, 'copy failed')
+    expect { described_class.send(:backup!) }.to raise_error(IOError, 'copy failed')
+  end
+
+  it 'rejects a symlinked backup root without touching its target' do
+    root = described_class::BACKUP_ROOT
+    File.symlink(@tmp, root)
+    expect { described_class.send(:backup!) }.to raise_error(IOError, /Symlink/)
+    expect(File.symlink?(root)).to be(true)
+  end
+
+  it 'skips backups for fix mode when schema, files and vault have no drift' do
+    File.write(File.join(@tmp, '.schema'), JSON.generate(schema: described_class::SCHEMA_VERSION))
+    allow(described_class).to receive(:vault_drift).and_return({ missing: [] })
+    allow(described_class).to receive(:status).and_return({ schema_installed: described_class::SCHEMA_VERSION, schema_current: described_class::SCHEMA_VERSION, incompatible: [], pwn_version: 'test' })
+    expect(described_class).not_to receive(:backup!)
+    expect(described_class.run(fix: true, io: io)[:backup]).to be_nil
+  end
+end