pwn 0.5.783 → 0.5.785

data/spec/lib/pwn/redaction_yubikey_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'pwn/redaction'
+
+RSpec.describe PWN::Redaction, 'hardware and MFA field redaction' do
+  it 'masks complete management-secret containers in serialized text' do
+    samples = [
+      'scp_keys=["fixture-enc", "fixture-mac"] slot=2',
+      'scp_keys: {enc: "fixture-enc", nested: ["fixture-mac", "fixture ] bracket"]} slot=2',
+      "scp_keys=[\n\"fixture-enc\",\n[\"fixture-mac\"]\n] slot=2"
+    ]
+    samples.each do |text|
+      clean = described_class.redact(value: text)
+      expect(clean).not_to include('fixture-enc', 'fixture-mac', 'fixture ] bracket')
+      expect(clean).to include('[REDACTED]', 'slot=2')
+      expect(described_class.redact(value: clean)).to eq(clean)
+    end
+    expect(described_class.redact(value: 'scp_keys=["fixture-enc"')).to eq('scp_keys=[REDACTED]')
+    expect(described_class.redact(value: 'oath_secret="fixture truncated secret')).to eq('oath_secret=[REDACTED]')
+  end
+
+  it 'does not let an existing mask exempt an adjacent ordinary secret from capture' do
+    text = 'password=fixture-prefix[REDACTED]fixture-suffix'
+    clean = described_class.capture(value: text, vault: false)
+    expect(clean[:redacted]).not_to include('fixture-prefix', 'fixture-suffix')
+    expect(clean[:refs]).not_to be_empty
+  end
+
+  it 'masks key-value text before ordinary token hashing or loot capture' do
+    samples = [
+      'pin=123456', 'PUK: 654321', 'new_pin="123 456"', "'management_key' => 'fixture key'",
+      '--access-code=112233', 'oath_secret=fixture-oath', 'static_password=fixture-static',
+      'scp_enc=fixture-enc', 'mfa_code=102938', '{"pin": "123456", "puk": 654321}'
+    ]
+    expect(PWN::Plugins::Vault).not_to receive(:store)
+    expect(PWN::Plugins::Vault).not_to receive(:fetch)
+    expect(PWN::Plugins::Vault).not_to receive(:expand)
+    samples.each do |text|
+      clean = described_class.redact(value: text)
+      expect(clean).to include('[REDACTED]'), text
+      expect(clean).not_to match(/123|654|112|102|fixture|\[REDACTED:[^\]]+/), text
+      expect(described_class.redact(value: clean)).to eq(clean)
+      expect(described_class.capture(value: text, entropy: true, yubikey: { slot: 2 })).to eq(redacted: clean, refs: [])
+    end
+    expect(described_class.redact(value: { api_key: 'fixture-api' })).to eq(api_key: described_class.token(kind: 'api_key', value: 'fixture-api'))
+  end
+
+  it 'uses a constant mask for structured PINs, PUKs, MFA codes and management secrets' do
+    fields = %w[pin PIN new_pin current-pin admin_pin user_pin fido2_pin piv_pin openpgp_pin puk new_puk access_code management_key management_password oath_secret static_password scp scp_key scp_keys scp_enc scp_mac scp_dek scp03_enc_key mfa_code mfa_token otp totp hotp otp_code totp_secret recovery_code verification_code]
+    fields.each do |field|
+      first = described_class.redact(value: { field => '123456' })
+      second = described_class.redact(value: { field => '654321' })
+      expect(first).to eq(field => '[REDACTED]'), field
+      expect(second).to eq(first), field
+    end
+    input = { nested: [{ pin: 1234, puk: nil, scp_keys: %w[fixture-one fixture-two] }], slot: 2, serial: '12345678', shipping: 'public' }
+    expect(described_class.redact(value: input)).to eq(nested: [{ pin: '[REDACTED]', puk: nil, scp_keys: '[REDACTED]' }], slot: 2, serial: '12345678', shipping: 'public')
+    expect(input[:nested].first[:pin]).to eq(1234)
+  end
+end

data/spec/lib/pwn/session_cleanup_concurrency_spec.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'timeout'
+require File.expand_path('../../../etc/default_cron/session_cleanup', __dir__)
+
+RSpec.describe PWN::SessionCleanup, 'concurrent maintenance' do
+  include_context 'pwn tmp sandbox'
+
+  before do
+    allow(Dir).to receive(:home).and_return(File.join(@tmp, 'home'))
+    FileUtils.mkdir_p(File.join(Dir.home, '.pwn'))
+    stub_const('PWN::AI::Agent::Learning::LEARNING_FILE', File.join(Dir.home, '.pwn', 'learning.jsonl'))
+    @processes = File.join(@tmp, 'processes')
+    FileUtils.mkdir_p(@processes)
+    @children = []
+  end
+
+  after do
+    @children.each do |pid, input, output|
+      input.close unless input.closed?
+      output.close unless output.closed?
+      Timeout.timeout(5) { Process.wait(pid) }
+    rescue Timeout::Error
+      Process.kill('KILL', pid)
+      Process.wait(pid)
+    rescue Errno::ECHILD
+      nil
+    end
+  end
+
+  def worker(&block)
+    reader, output = IO.pipe
+    input, writer = IO.pipe
+    pid = fork do
+      reader.close
+      writer.close
+      @children.each do |_, old_input, old_output|
+        old_input.close
+        old_output.close
+      end
+      $0 = 'pwn-ai'
+      block.call(input, output)
+      exit! 0
+    rescue Exception => e # rubocop:disable Lint/RescueException -- communicate child assertion failures
+      output.puts("ERROR: #{e.class}: #{e.message}")
+      exit! 1
+    end
+    input.close
+    output.close
+    @children << [pid, writer, reader]
+    File.symlink("/proc/#{pid}", File.join(@processes, pid.to_s))
+    [writer, reader]
+  end
+
+  def message(reader)
+    raise 'Child did not respond before deadline' unless reader.wait_readable(10)
+
+    reader.gets&.strip
+  end
+
+  def maintain
+    Timeout.timeout(5) { described_class.maintain(proc_root: @processes) }
+  end
+
+  it 'retains two real active clients, deletes unrelated work and revisits released evidence' do
+    ids = 3.times.map { PWN::Sessions.create[:id] }
+    learning = PWN::AI::Agent::Learning
+    File.write(learning::LEARNING_FILE, "#{JSON.generate(session_id: ids.first, lesson: 'résumé 日本語')}\n")
+    clients = ids.first(2).map do |id|
+      worker do |input, output|
+        lease = PWN::Sessions.activate(session_id: id)
+        output.puts('ready')
+        input.gets
+        PWN::Sessions.append(session_id: id, role: 'assistant', content: 'final 日本語 evidence')
+        PWN::Sessions.deactivate(lease: lease)
+        output.puts('released')
+        input.gets
+      end
+    end
+    clients.each { |client| expect(message(client.last)).to eq('ready') }
+    expect(described_class.legacy_owners(@processes)).to eq([])
+    first = maintain
+    expect(first[:deleted_ids]).to eq([ids.last])
+    expect(first[:evidence_migration][:deferred_active_sessions]).to eq(1)
+    expect(JSON.parse(File.read(learning::LEARNING_FILE))).not_to have_key('evidence_ref')
+    ids.first(2).each { |id| expect(File).to exist(File.join(PWN::Sessions.sessions_dir, "#{id}.jsonl")) }
+    clients.each do |input, output|
+      input.puts('release')
+      expect(message(output)).to eq('released')
+    end
+    second = maintain
+    expect(second[:deleted_ids]).to match_array(ids.first(2))
+    expect(learning.session_evidence(session_id: ids.first).last[:content]).to eq('final 日本語 evidence')
+    expect(second[:evidence_migration][:migrated_rows]).to eq(1)
+  end
+
+  it 'defers promptly behind a real learning writer and retries without losing its write' do
+    id = PWN::Sessions.create[:id]
+    learning = PWN::AI::Agent::Learning
+    input, output = worker do |commands, replies|
+      PWN::Sessions.send(:register_activity_owner)
+      lock = learning.send(:learning_lock)
+      replies.puts('locked')
+      commands.gets
+      File.write(learning::LEARNING_FILE, "#{JSON.generate(session_id: id, lesson: 'preserved 日本語')}\n")
+      learning.send(:learning_unlock, lock: lock)
+      replies.puts('written')
+      commands.gets
+    end
+    expect(message(output)).to eq('locked')
+    result = maintain
+    expect(result[:evidence_migration]).to include(deferred: 'learning_writer_active', migrated_rows: 0)
+    expect(result[:apply_blocked]).to be(true)
+    expect(File).to exist(File.join(PWN::Sessions.sessions_dir, "#{id}.jsonl"))
+    input.puts('write')
+    expect(message(output)).to eq('written')
+    expect(maintain[:deleted_ids]).to eq([id])
+    expect(JSON.parse(File.read(learning::LEARNING_FILE))['lesson']).to eq('preserved 日本語')
+    expect(learning.session_evidence(session_id: id)).not_to be_empty
+  end
+
+  it 'retains a real provider-blocked title worker without delaying unrelated cleanup' do
+    id = PWN::Sessions.create[:id]
+    other = PWN::Sessions.create[:id]
+    PWN::Sessions.append(session_id: id, role: 'user', content: 'Title fixture topic')
+    input, output = worker do |commands, replies|
+      allow(PWN::AI::Router).to receive(:summarize) do
+        replies.puts('provider entered')
+        commands.gets
+        JSON.generate(title: 'Fixture conversation summary', summary: 'Offline provider fixture summary')
+      end
+      PWN::Sessions.refresh_title(session_id: id)
+      replies.puts('titled')
+      commands.gets
+    end
+    expect(message(output)).to eq('provider entered')
+    expect(described_class.legacy_owners(@processes)).to eq([])
+    expect(maintain[:deleted_ids]).to eq([other])
+    input.puts('finish provider')
+    expect(message(output)).to eq('titled')
+    expect(PWN::Sessions.title_status(session_id: id)[:is_summarized]).to be(true)
+    expect(maintain[:deleted_ids]).to eq([])
+  end
+
+  it 'serializes two real outcome writers with repeated maintenance and preserves every row' do
+    learning = PWN::AI::Agent::Learning
+    clients = 2.times.map do |index|
+      worker do |commands, replies|
+        PWN::Sessions.send(:register_activity_owner)
+        replies.puts('ready')
+        commands.gets
+        5.times { |turn| learning.note_outcome(task: "concurrent fixture #{index}/#{turn}", success: true) }
+        replies.puts('written')
+        commands.gets
+      end
+    end
+    clients.each { |client| expect(message(client.last)).to eq('ready') }
+    clients.each { |client| client.first.puts('start') } # rubocop:disable Style/CombinableLoops -- release only after both children are ready
+    3.times { maintain }
+    clients.each { |client| expect(message(client.last)).to eq('written') }
+    maintain
+    rows = File.readlines(learning::LEARNING_FILE).map { |line| JSON.parse(line) }
+    expect(rows.length).to eq(10)
+    expect(rows.map { |row| row.fetch('task') }.uniq.length).to eq(10)
+  end
+
+  it 'admits only one real maintenance owner and leaves a retry possible' do
+    id = PWN::Sessions.create[:id]
+    input, output = worker do |commands, replies|
+      PWN::Sessions.send(:register_activity_owner)
+      described_class.send(:with_maintenance_lock, dry_run: false) do
+        replies.puts('locked')
+        commands.gets
+      end
+      replies.puts('released')
+      commands.gets
+    end
+    expect(message(output)).to eq('locked')
+    expect { maintain }.to raise_error(IOError, /maintenance already running/)
+    expect(File).to exist(File.join(PWN::Sessions.sessions_dir, "#{id}.jsonl"))
+    input.puts('release')
+    expect(message(output)).to eq('released')
+    expect(maintain[:deleted_ids]).to eq([id])
+  end
+
+  it 'does not mistake a genuinely untracked real client for a cooperating owner' do
+    id = PWN::Sessions.create[:id]
+    _, output = worker do |commands, replies|
+      PWN::Sessions.instance_variable_get(:@activity_owners)&.each_value { |file| file.close unless file.closed? }
+      replies.puts('legacy')
+      commands.gets
+    end
+    expect(message(output)).to eq('legacy')
+    expect(described_class.legacy_owners(@processes)).to include(hash_including(reason: 'legacy_session_ownership_unknown'))
+    result = maintain
+    expect(result[:apply_blocked]).to be(true)
+    expect(result[:deleted_ids]).to eq([])
+    expect(File).to exist(File.join(PWN::Sessions.sessions_dir, "#{id}.jsonl"))
+  end
+end

data/spec/lib/pwn/session_cleanup_default_spec.rb

@@ -6,7 +6,169 @@ require 'open3'
 RSpec.describe 'Bundled session cleanup' do
   include_context 'pwn tmp sandbox'
 
+  it 'builds and installs the package into an isolated gem home for fresh and schema-10 upgrade paths' do
+    package = File.join(@tmp, 'pwn.gem')
+    repository = File.expand_path('../../..', __dir__)
+    output, error, built = Open3.capture3(RbConfig.ruby, '-S', 'gem', 'build', 'pwn.gemspec', '--output', package, chdir: repository)
+    expect(built.success?).to be(true), "#{output}\n#{error}"
+    gem_home = File.join(@tmp, 'gems')
+    env = { 'HOME' => File.join(@tmp, 'installed-home'), 'GEM_HOME' => gem_home,
+            'GEM_PATH' => [gem_home, *Gem.path].join(File::PATH_SEPARATOR), 'RUBYOPT' => nil, 'BUNDLE_GEMFILE' => nil,
+            'PWN_CRON_DIR' => File.join(@tmp, 'installed-home', '.pwn', 'cron') }
+    FileUtils.mkdir_p(env['HOME'])
+    output, error, installed = Open3.capture3(env, RbConfig.ruby, '-S', 'gem', 'install', '--local', package, '--ignore-dependencies', '--no-document', '--install-dir', gem_home)
+    expect(installed.success?).to be(true), "#{output}\n#{error}"
+    script = <<~RUBY
+      require 'pwn'
+      require 'json'
+      require 'stringio'
+      raise 'wrong gem activated' unless Gem.loaded_specs.fetch('pwn').full_gem_path.start_with?(ENV.fetch('GEM_HOME'))
+      PWN::Cron.install_defaults
+      jobs = File.binread(PWN::Cron.jobs_file)
+      PWN::Cron.install_defaults
+      raise 'non-idempotent jobs' unless File.binread(PWN::Cron.jobs_file) == jobs
+      policy = File.join(Dir.home, '.pwn', 'maintenance', 'policy.json')
+      config = JSON.parse(File.read(policy)).merge('batch_size' => 7)
+      File.write(policy, JSON.generate(config))
+      File.write(PWN::Migrate::SCHEMA_FILE, JSON.generate(schema: 10))
+      upgrade = PWN::Migrate.run(fix: false, backup: false, io: StringIO.new)
+      raise 'missing upgrade' unless upgrade[:applied_migrations] == [11, 12]
+      raise 'overwritten policy' unless JSON.parse(File.read(policy))['batch_size'] == 7
+      raise 'non-idempotent upgrade' unless PWN::Migrate.run(fix: false, backup: false, io: StringIO.new)[:applied_migrations].empty?
+      raise 'wrong helper' unless File.read(File.join(PWN::Cron.cron_dir, 'session_cleanup.rb')).include?('session_cleanup v10')
+      report = PWN::SessionCleanup.status
+      raise 'wrong inventory' unless report[:categories].length == 9
+      # Exercise the installed startup request and original next-slot guard.
+      configured = PWN::Cron.list
+      configured.each_value { |job| job[:enabled] = false unless job[:name] == 'session_cleanup' }
+      File.write(PWN::Cron.jobs_file, YAML.dump(configured))
+      tick = PWN::Cron.tick
+      raise 'startup failed' unless tick.length == 1 && tick.first[:status] == 'success'
+      raise 'startup guard bypassed' unless Dir.glob(File.join(Dir.home, '.pwn', 'maintenance', 'runs', '*.json')).empty?
+      raise 'startup not coalesced' unless PWN::Cron.tick.empty?
+      # Actual installed producer, with only external analysis transport replaced.
+      binary = File.join(Dir.home, 'fixture.bin')
+      File.binwrite(binary, 'fixture binary')
+      PWN::Plugins::Ghidra.define_singleton_method(:analyze) do |_opts = {}|
+        { stdout: 'fixture analysis', exit: 0 }
+      end
+      PWN::Plugins::Ghidra.decompile(bin: binary)
+      raise 'installed cache miss' unless PWN::Plugins::Ghidra.decompile(bin: binary)[:cached]
+      sid = PWN::Sessions.create[:id]
+      release = File.join(Dir.home, 'release-job')
+      command = "while [ ! -f \#{release} ]; do sleep 0.05; done; printf fixture-complete"
+      begin
+        job = PWN::Plugins::Jobs.start(command: command, session_id: sid, cwd: Dir.home, max_runtime: 20)
+        raise 'job not running' unless PWN::Plugins::Jobs.status(id: job[:id])[:status] == 'RUNNING'
+        proc_root = File.join(Dir.home, 'fixture-proc')
+        FileUtils.mkdir_p(proc_root)
+        maintenance = PWN::SessionCleanup.coordinate(dry_run: false, proc_root: proc_root)
+        raise "missing coordinator phases: \#{maintenance.inspect}" unless maintenance[:phases].keys == %i[maintenance memory_consolidation learning_retention mistakes_retention policy_retention]
+        raise 'active job session deleted' unless File.file?(File.join(PWN::Sessions.sessions_dir, sid + '.jsonl'))
+        raise 'job dependency omitted' unless PWN::Sessions.dependency_index[:dependencies].fetch(sid).any? { |path| path.include?('/jobs/') }
+        File.write(release, 'release')
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 10
+        while PWN::Plugins::Jobs.status(id: job[:id])[:status] == 'RUNNING'
+          raise 'job did not finish' if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+          sleep 0.02
+        end
+        raise 'job outcome changed' unless PWN::Plugins::Jobs.status(id: job[:id])[:status] == 'COMPLETED'
+      ensure
+        File.write(release, 'release')
+        PWN::Plugins::Jobs.stop(id: job[:id]) if job && PWN::Plugins::Jobs.status(id: job[:id])[:status] == 'RUNNING'
+      end
+      puts JSON.generate(installed: true, schema: PWN::Migrate.installed_schema, categories: report[:categories].keys)
+    RUBY
+    output, error, ran = Open3.capture3(env, RbConfig.ruby, '-e', script, chdir: @tmp)
+    expect(ran.success?).to be(true), "#{output}\n#{error}"
+    expect(JSON.parse(output)).to include('installed' => true, 'schema' => 12)
+  end
+
+  it 'never seeds curriculum on fresh install, upgrade or repeated migration after deletion' do
+    PWN::Cron.install_defaults
+    expect(PWN::Cron.list.values.map { |row| row[:name] }).not_to include('curriculum_practice_nightly', 'curriculum_train_weekly', 'curriculum_offline_judge')
+    PWN::Cron::CURRICULUM_JOBS.each do |spec|
+      job = PWN::Cron.create(spec.merge(sync_native: false))
+      PWN::Cron.remove(id: job[:id], sync_native: false)
+    end
+    custom = PWN::Cron.create(name: 'custom-curriculum', ruby: '42', enabled: false, sync_native: false)
+    File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 7))
+    2.times { PWN::Migrate.run(fix: false, backup: false, io: StringIO.new) }
+    expect(PWN::Cron.list.values.map { |row| row[:name] }).to contain_exactly('session_cleanup', 'custom-curriculum')
+    expect(PWN::Cron.list.fetch(custom[:id])).to eq(custom)
+  end
+
+  it 'coordinates evidence-first maintenance, memory consolidation and retention exactly once' do
+    require_relative '../../../etc/default_cron/session_cleanup'
+    allow(Dir).to receive(:home).and_return(@tmp)
+    FileUtils.mkdir_p(PWN::Sessions.sessions_dir)
+    cleanup = PWN::SessionCleanup
+    expect(cleanup).to receive(:maintain).with(dry_run: false, current_session_id: 'active', proc_root: '/proc').ordered.and_return(state: 'committed')
+    expect(PWN::AI::Agent::Learning).to receive(:consolidate).once.ordered.and_return(removed: 0)
+    expect(PWN::AI::Agent::Learning).to receive(:prune_outcomes!).with(dry_run: false).once.ordered.and_return(removed: 0)
+    expect(PWN::AI::Agent::Mistakes).to receive(:lean!).with(dry_run: false).once.ordered.and_return(removed: 0)
+    expect(PWN::AI::Agent::Policy).to receive(:lean!).with(dry_run: false).once.ordered.and_return(removed: 0)
+    expect(PWN::AI::Agent::Learning).not_to receive(:gc_stores!)
+    result = cleanup.coordinate(dry_run: false, current_session_id: 'active')
+    expect(result[:phases].keys).to eq(%i[maintenance memory_consolidation learning_retention mistakes_retention policy_retention])
+  end
+
+  it 'keeps blocked coordinator phases nonapplying' do
+    require_relative '../../../etc/default_cron/session_cleanup'
+    allow(Dir).to receive(:home).and_return(@tmp)
+    FileUtils.mkdir_p(PWN::Sessions.sessions_dir)
+    allow(PWN::SessionCleanup).to receive(:maintain).and_return(apply_blocked: true, state: 'blocked')
+    expect(PWN::AI::Agent::Learning).not_to receive(:consolidate)
+    expect(PWN::AI::Agent::Learning).not_to receive(:prune_outcomes!)
+    expect(PWN::AI::Agent::Mistakes).not_to receive(:lean!)
+    expect(PWN::AI::Agent::Policy).not_to receive(:lean!)
+    expect(PWN::SessionCleanup.coordinate[:state]).to eq('blocked')
+  end
+
+  it 'never applies retention during coordinator previews and rejects duplicate maintenance owners' do
+    require_relative '../../../etc/default_cron/session_cleanup'
+    allow(Dir).to receive(:home).and_return(@tmp)
+    FileUtils.mkdir_p(PWN::Sessions.sessions_dir)
+    allow(PWN::SessionCleanup).to receive(:maintain).and_return(state: 'planned')
+    expect(PWN::AI::Agent::Learning).not_to receive(:consolidate)
+    expect(PWN::AI::Agent::Learning).to receive(:prune_outcomes!).with(dry_run: true).once.and_return({})
+    expect(PWN::AI::Agent::Mistakes).to receive(:lean!).with(dry_run: true).once.and_return({})
+    expect(PWN::AI::Agent::Policy).to receive(:lean!).with(dry_run: true).once.and_return({})
+    expect(PWN::SessionCleanup.coordinate(dry_run: true)[:state]).to eq('planned')
+    expect(Dir.exist?(File.join(@tmp, '.pwn', 'maintenance', 'runs'))).to be(false)
+    PWN::SessionCleanup.send(:with_maintenance_lock, dry_run: false) do
+      thread = Thread.new do
+        expect { PWN::SessionCleanup.coordinate }.to raise_error(IOError, /already running/)
+      end
+      expect(thread.join(2)).to eq(thread)
+      thread.value
+    end
+  end
+
+  it 'preserves legacy maintenance jobs and avoids adding duplicate retention phases' do
+    legacy = PWN::Cron.create(name: 'learning_consolidate_nightly', ruby: 'custom', enabled: false, sync_native: false)
+    PWN::Cron.install_defaults
+    expect(PWN::Cron.list.fetch(legacy[:id])).to eq(legacy)
+    job = PWN::Cron.list.values.find { |row| row[:name] == 'session_cleanup' }
+    expect(job[:ruby]).to include('SessionCleanup.maintain(')
+    expect(job[:ruby]).not_to include('SessionCleanup.coordinate(')
+  end
+
+  it 'installs housekeeping defaults without overwriting policy edits' do
+    PWN::Cron.install_defaults
+    path = File.join(File.dirname(PWN::Cron.cron_dir), 'maintenance', 'policy.json')
+    expect(File.file?(path)).to be(true)
+    value = JSON.parse(File.read(path))
+    value['batch_size'] = 3
+    File.write(path, JSON.generate(value))
+    PWN::Cron.install_defaults
+    expect(JSON.parse(File.read(path))['batch_size']).to eq(3)
+  end
+
   it 'seeds a portable guarded daily job and helper only once' do
+    allow(PWN::Cron).to receive(:systemd_user_available?).and_return(true)
+    expect(PWN::Cron).not_to receive(:install_native_job)
+    expect(PWN::Cron).not_to receive(:install_scheduler)
     PWN::Cron.install_defaults
     jobs = PWN::Cron.list.values.select { |job| job[:name] == 'session_cleanup' }
     expect(jobs.length).to eq(1)
@@ -21,10 +183,13 @@ RSpec.describe 'Bundled session cleanup' do
   end
 
   it 'upgrades schema 7 and preserves an existing job identity, schedule and payload' do
+    allow(PWN::Cron).to receive(:systemd_user_available?).and_return(true)
+    expect(PWN::Cron).not_to receive(:install_native_job)
+    expect(PWN::Cron).not_to receive(:install_scheduler)
     original = PWN::Cron.create(name: 'session_cleanup', schedule: '12 9 * * *', ruby: 'custom guard', enabled: false)
     File.write(File.join(@tmp, '.schema'), JSON.generate(schema: 7))
     result = PWN::Migrate.run(fix: false, backup: false, io: StringIO.new)
-    expect(result[:applied_migrations]).to eq([8, 9, 10])
+    expect(result[:applied_migrations]).to eq([8, 9, 10, 11, 12])
     expect(PWN::Cron.list.fetch(original[:id])).to eq(original)
     expect(PWN::Cron.list.values.count { |job| job[:name] == 'session_cleanup' }).to eq(1)
     expect(File).to exist(File.join(PWN::Cron.cron_dir, 'session_cleanup.rb'))
@@ -40,7 +205,7 @@ RSpec.describe 'Bundled session cleanup' do
     bytes = File.read(PWN::Cron.jobs_file)
     expect(PWN::Cron).not_to receive(:install_native_job)
     PWN::Cron.install_defaults
-    expect(File.read(helper)).to include('# PWN managed default: session_cleanup v9')
+    expect(File.read(helper)).to include('# PWN managed default: session_cleanup v10')
     expect(File.read(PWN::Cron.jobs_file)).to eq(bytes)
   end
 

data/spec/lib/pwn/session_cleanup_legacy_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require File.expand_path('../../../etc/default_cron/session_cleanup', __dir__)
+
+RSpec.describe PWN::SessionCleanup do
+  include_context 'pwn tmp sandbox'
+
+  before do
+    allow(Dir).to receive(:home).and_return(File.join(@tmp, 'home'))
+    @root = File.join(Dir.home, '.pwn')
+    FileUtils.mkdir_p(File.join(@root, 'logs'))
+    FileUtils.mkdir_p(File.join(@root, 'sessions'))
+    File.write(File.join(@root, 'sessions', '.maintenance.lock'), '')
+    @path = File.join(@root, 'logs', 'pwn-ai-DEBUG-abc123-R1.log')
+    File.write(@path, 'debug session stop')
+    File.utime(Time.at(1), Time.at(1), @path)
+    allow(described_class).to receive(:legacy_open_files).and_return([])
+    @manifest = File.join(@tmp, 'expiry.json.gz')
+  end
+
+  it 'retains open descriptors, referenced paths, recent and unrecognized logs' do
+    File.write(File.join(@root, 'memory.json'), JSON.generate(evidence: @path))
+    expect(described_class.expire_legacy[:retained].first[:reason]).to eq('evidence_reference')
+    File.unlink(File.join(@root, 'memory.json'))
+    stat = File.stat(@path)
+    allow(described_class).to receive(:legacy_open_files).and_return([[stat.dev, stat.ino]])
+    expect(described_class.expire_legacy[:retained].first[:reason]).to eq('open_descriptor')
+    allow(described_class).to receive(:legacy_open_files).and_return([])
+    File.utime(Time.now, Time.now, @path)
+    expect(described_class.expire_legacy[:candidates]).to be_empty
+    File.utime(Time.at(1), Time.at(1), @path)
+    File.rename(@path, File.join(@root, 'logs', 'unknown.log'))
+    expect(described_class.expire_legacy[:candidates]).to be_empty
+  end
+
+  it 'fails closed on symlinks, changed inodes, unreadable proc and held maintenance locks' do
+    original = @path
+    File.rename(original, "#{original}.save")
+    File.symlink("#{original}.save", original)
+    expect { described_class.expire_legacy }.to raise_error(IOError, /Unsafe/)
+    File.unlink(original)
+    File.rename("#{original}.save", original)
+    allow(described_class).to receive(:legacy_open_files).and_raise(Errno::EACCES)
+    expect { described_class.expire_legacy }.to raise_error(Errno::EACCES)
+    allow(described_class).to receive(:legacy_open_files).and_return([])
+    File.open(File.join(@root, 'sessions', '.maintenance.lock'), 'r+') do |lock|
+      lock.flock(File::LOCK_EX)
+      expect { described_class.expire_legacy }.to raise_error(IOError, /Maintenance active/)
+    end
+    allow(described_class).to receive(:legacy_manifest).and_wrap_original do |method, *args|
+      method.call(*args)
+      File.write(original, 'replacement')
+    end
+    expect { described_class.expire_legacy(dry_run: false, manifest: @manifest) }.to raise_error(IOError, /changed/)
+    expect(File.read(original)).to eq('replacement')
+  end
+
+  it 'requires external metadata and preserves unclosed diagnostics' do
+    expect { described_class.expire_legacy(dry_run: false, manifest: File.join(@root, 'manifest.gz')) }.to raise_error(ArgumentError)
+    File.write(@path, 'still running')
+    File.utime(Time.at(1), Time.at(1), @path)
+    expect(described_class.expire_legacy[:candidates]).to be_empty
+  end
+
+  it 'expires triage cache only when byte-identical evidence survives outside the cache' do
+    directory = File.join(@root, 'cache', 'triage')
+    FileUtils.mkdir_p(directory)
+    cache = File.join(directory, "#{'a' * 64}.json")
+    File.write(cache, JSON.generate(sha256: 'a' * 64, path: '/missing/input'))
+    File.utime(Time.at(1), Time.at(1), cache)
+    FileUtils.mkdir_p(File.join(@root, 'artifacts', 'test'))
+    evidence = File.join(@root, 'artifacts', 'test', 'copy.bin')
+    FileUtils.cp(cache, evidence)
+    result = described_class.expire_legacy(dry_run: false, manifest: @manifest)
+    expect(result[:removed].map { |row| row[:path] }).to include(cache)
+    expect(File.exist?(evidence)).to be(true)
+  end
+
+  it 'keeps three valid recovery copies per known family and preserves exact evidence pins' do
+    File.write(File.join(@root, 'learning.jsonl'), "{}\n")
+    backups = (1..5).map do |day|
+      path = File.join(@root, format('learning.jsonl.bak-lean-202001%02d', day))
+      File.write(path, "{}\n")
+      File.utime(Time.at(day), Time.at(day), path)
+      path
+    end
+    File.write(File.join(@root, 'memory.json'), JSON.generate(evidence: backups.first))
+    result = described_class.expire_legacy(dry_run: false, manifest: @manifest)
+    expect(result[:removed].map { |row| row[:path] }).to include(backups[1])
+    expect(backups.select { |path| File.exist?(path) }).to eq(backups.values_at(0, 2, 3, 4))
+  end
+
+  it 'expires only closed recognized diagnostics with an external metadata manifest' do
+    result = described_class.expire_legacy(dry_run: false, manifest: @manifest)
+    expect(result[:removed].map { |row| row[:path] }).to eq([@path])
+    expect(File.exist?(@path)).to be(false)
+    expect(JSON.parse(Zlib::GzipReader.open(@manifest, &:read))['removed'].first['sha256']).to eq(Digest::SHA256.hexdigest('debug session stop'))
+    expect(Dir.children(File.join(@root, 'logs'))).to be_empty
+  end
+end