pwn 0.5.783 → 0.5.784

data/spec/lib/pwn/session_cleanup_default_spec.rb

@@ -6,7 +6,167 @@ 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]
+      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'
+        maintenance = PWN::SessionCleanup.coordinate(dry_run: false)
+        raise 'missing coordinator phases' 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' => 11)
+  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 +181,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])
     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 +203,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

data/spec/lib/pwn/session_cleanup_payload_spec.rb

@@ -3,6 +3,337 @@
 require 'spec_helper'
 require File.expand_path('../../../etc/default_cron/session_cleanup', __dir__)
 
+RSpec.describe PWN::SessionCleanup do
+  include_context 'pwn tmp sandbox'
+
+  let(:id) { '20200101_010203_abcdef12' }
+  let(:title) { "pwn-ai session #{id}" }
+  let(:path) { File.join(PWN::Sessions.sessions_dir, "#{id}.jsonl") }
+  let(:meta_path) { path.sub('.jsonl', '.meta.json') }
+
+  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'))
+    PWN::Sessions.create(id: id)
+  end
+
+  def metadata(value)
+    File.write(meta_path, JSON.generate({ id: id, title: title, source: 'pwn-ai' }.merge(value)))
+  end
+
+  describe 'housekeeping inventory' do
+    it 'keeps filesystem metadata and bytes unchanged during status and maintenance dry-run' do
+      File.unlink(PWN::Sessions.support_path(kind: :lease, session_id: id))
+      snapshot = lambda do
+        Dir.glob(File.join(@tmp, '**', '*'), File::FNM_DOTMATCH).sort.to_h do |entry|
+          stat = File.lstat(entry)
+          [entry, [stat.ino, stat.mode, stat.size, stat.mtime, stat.ctime, stat.file? ? Digest::SHA256.file(entry).hexdigest : nil]]
+        end
+      end
+      before = snapshot.call
+      described_class.status
+      result = described_class.maintain(dry_run: true)
+      expect(result[:dry_run]).to be(true)
+      expect(snapshot.call).to eq(before)
+    end
+
+    it 'includes legacy migration backups as protected bounded inventory' do
+      directory = File.join(Dir.home, '.pwn', 'backup', '20261025_120000')
+      FileUtils.mkdir_p(directory)
+      File.write(File.join(directory, 'custom.json'), 'only-copy')
+      before = File.stat(directory)
+      row = described_class.status[:categories].fetch('backups')
+      expect(row).to include(files: 1, bytes: 9, unique_bytes: 9, incomplete: false,
+                             policy_mode: 'protected_evidence_no_automatic_deletion')
+      expect(row[:retention_days]).to be_nil
+      expect(File.stat(directory).mtime).to eq(before.mtime)
+      expect(described_class.prune_legacy_backups[:compacted]).to be_empty
+    end
+
+    it 'evicts real producer cache under budget pressure but not an active reader or unknown bytes' do
+      described_class.install
+      config = described_class.policy
+      config['budget_bytes']['cache'] = 0
+      File.write(File.join(Dir.home, '.pwn', 'maintenance', 'policy.json'), JSON.generate(config))
+      binary = File.join(@tmp, 'binary')
+      File.binwrite(binary, "binary\xFF".b)
+      allow(PWN::Plugins::Ghidra).to receive(:analyze).and_return(stdout: '分析', exit: 0)
+      expect(PWN::Plugins::Ghidra.decompile(bin: binary)[:stdout]).to eq('分析')
+      expect(PWN::Plugins::Ghidra.decompile(bin: binary)[:cached]).to be(true)
+      cache = File.join(Dir.home, '.pwn', 'cache', 'decompile', "#{Digest::SHA256.file(binary).hexdigest}.json")
+      unknown = File.join(File.dirname(cache), 'unknown')
+      File.write(unknown, 'keep')
+      File.open("#{cache}.lease", 'r') do |lease|
+        lease.flock(File::LOCK_SH)
+        expect(described_class.clean_disposables(dry_run: false)[:deleted]).to be_empty
+      end
+      expect(described_class.clean_disposables(dry_run: false)[:deleted]).to eq([cache])
+      expect(File.read(unknown)).to eq('keep')
+    end
+
+    it 'keeps the old cache intact when atomic replacement runs out of space' do
+      cache = File.join(Dir.home, '.pwn', 'cache', 'failure')
+      described_class.cache(path: cache, bytes: 'before')
+      allow(File).to receive(:rename).and_call_original
+      allow(File).to receive(:rename).with(anything, cache).and_raise(Errno::ENOSPC)
+      expect { described_class.cache(path: cache, bytes: 'after') }.to raise_error(Errno::ENOSPC)
+      expect(described_class.cache(path: cache)).to eq('before')
+      expect(Dir.glob("#{cache}.*").reject { |name| name.end_with?('.lease') }).to be_empty
+    end
+
+    it 'rotates real ordinary logs and protects debug writers through request closure' do
+      described_class.install
+      log = File.join(Dir.home, '.pwn', 'logs', 'pwn.log')
+      PWN::Plugins::Log.append(level: :info, msg: 'first', which_self: self)
+      expect(File.read(log)).to include('first')
+      File.open(log, 'a') { |file| file.write('x' * 1_024_000) }
+      PWN::Plugins::Log.append(level: :info, msg: 'second', which_self: self)
+      expect(File.read(log)).to include('second')
+      expect(File.size(log)).to be < 1_024_000
+      expect(Dir.glob("#{log}.*").reject { |name| name.end_with?('.lease') }.length).to eq(1)
+      debug = File.join(Dir.home, '.pwn', 'logs', 'request.log')
+      PWN::Plugins::Log.send(:open_debug_file!, path: debug)
+      expect { described_class.register_disposable(path: debug, category: 'logs') }.to raise_error(IOError, /active/)
+      PWN::Plugins::Log.send(:close_debug_file!)
+      manifest = File.join(Dir.home, '.pwn', 'maintenance', 'disposable', "#{Digest::SHA256.hexdigest(debug)}.json")
+      expect(File.file?(manifest)).to be(true)
+    ensure
+      PWN::Plugins::Log.send(:close_debug_file!)
+    end
+
+    it 'coalesces startup work without scanning and executes it once through the existing cron tick' do
+      cron = File.join(Dir.home, '.pwn', 'cron')
+      allow(PWN::Cron).to receive(:cron_dir).and_return(cron)
+      FileUtils.mkdir_p(cron)
+      expect(described_class).not_to receive(:status)
+      expect(described_class).not_to receive(:maintain)
+      PWN::Cron.install_defaults
+      request = File.join(Dir.home, '.pwn', 'maintenance', 'background.json')
+      bytes = File.binread(request)
+      PWN::Cron.install_defaults
+      expect(File.binread(request)).to eq(bytes)
+      allow(PWN::Cron).to receive(:due_jobs).and_return({})
+      job = PWN::Cron.list.values.find { |entry| entry[:name] == 'session_cleanup' }
+      expect(PWN::Cron).to receive(:run).with(id: job[:id]).once.and_return(status: 'success', duration: 0)
+      expect(PWN::Cron.tick.length).to eq(1)
+      expect(PWN::Cron.tick).to be_empty
+      expect(JSON.parse(File.read(request))['state']).to eq('completed')
+    end
+
+    it 'reports an interrupted broad transaction without losing the prepared ledger' do
+      described_class.install
+      allow(described_class).to receive(:maintenance_transaction).and_raise(Interrupt)
+      expect { described_class.maintain(dry_run: false) }.to raise_error(Interrupt)
+      ledger = Dir.glob(File.join(Dir.home, '.pwn', 'maintenance', 'runs', '*.json')).fetch(0)
+      expect(JSON.parse(File.read(ledger))).to include('state' => 'interrupted', 'error' => 'Interrupt')
+    end
+
+    it 'serializes cache publication across real processes and threads' do
+      cache = File.join(Dir.home, '.pwn', 'cache', 'concurrent')
+      described_class.cache(path: cache, bytes: 'initial')
+      workers = 2.times.map do |worker|
+        fork do
+          threads = 3.times.map do |thread|
+            Thread.new { 8.times { |index| described_class.cache(path: cache, bytes: JSON.generate(worker: worker, thread: thread, index: index, text: '日本語')) } }
+          end
+          threads.each(&:value)
+          exit! 0
+        rescue StandardError
+          exit! 1
+        end
+      end
+      workers.each { |pid| expect(Process.wait2(pid).last.success?).to be(true) }
+      body = described_class.cache(path: cache)
+      expect(JSON.parse(body)['text']).to eq('日本語')
+      manifest = File.join(Dir.home, '.pwn', 'maintenance', 'disposable', "#{Digest::SHA256.hexdigest(cache)}.json")
+      expect(JSON.parse(File.read(manifest))['sha256']).to eq(Digest::SHA256.hexdigest(body))
+    end
+
+    it 'bounds evidence migration without dropping unmigrated rows or breaking readers' do
+      other = '20200101_010204_abcdef12'
+      PWN::Sessions.create(id: other)
+      [id, other].each { |sid| PWN::Sessions.append(session_id: sid, role: 'user', content: '証拠') }
+      file = PWN::AI::Agent::Learning::LEARNING_FILE
+      File.write(file, [id, other].map { |sid| JSON.generate(session_id: sid, outcome: 'fixture') }.join("\n"))
+      result = PWN::AI::Agent::Learning.migrate_evidence(dry_run: false, max_sessions: 1)
+      expect(result[:migrated_rows]).to eq(1)
+      rows = File.readlines(file).map { |line| JSON.parse(line) }
+      expect(rows.length).to eq(2)
+      expect(rows.count { |row| row['evidence_ref'] }).to eq(1)
+      expect(PWN::Sessions.load(session_id: other).last[:content]).to eq('証拠')
+      expect(PWN::AI::Agent::Learning.migrate_evidence(dry_run: false, max_sessions: 1)[:migrated_rows]).to eq(1)
+    end
+
+    it 'honors session retention floors and cooperative cancellation before deletion' do
+      allow(described_class).to receive(:legacy_owners).and_return([])
+      described_class.install
+      config = File.join(Dir.home, '.pwn', 'maintenance', 'policy.json')
+      value = described_class.policy
+      value['retention_days']['sessions'] = 1
+      File.write(config, JSON.generate(value))
+      expect(described_class.run(dry_run: false)[:deleted_ids]).to be_empty
+      value['retention_days']['sessions'] = 0
+      File.write(config, JSON.generate(value))
+      control = double(stopping?: true)
+      Thread.current[:pwn_steering_input] = control
+      expect(described_class.run(dry_run: false)[:deleted_ids]).to be_empty
+      expect(File.file?(path)).to be(true)
+    ensure
+      Thread.current[:pwn_steering_input] = nil
+    end
+
+    it 'expires only committed verified disposable backups and retains prepared recovery evidence' do
+      file = File.join(Dir.home, '.pwn', 'tmp', 'expired-backup')
+      FileUtils.mkdir_p(File.dirname(file))
+      File.write(file, 'disposable')
+      described_class.register_disposable(path: file, category: 'tmp', expires_at: 0)
+      result = described_class.clean_disposables(dry_run: false)
+      backup = result[:records].first['backup']
+      old = Time.now - (100 * 86_400)
+      File.utime(old, old, result[:ledger])
+      expect(described_class.prune_quarantine(dry_run: true)[:eligible]).to eq([backup])
+      expect(File.file?(backup)).to be(true)
+      expect(described_class.prune_quarantine(dry_run: false)[:deleted]).to eq([backup])
+      expect(File.exist?(backup)).to be(false)
+      expect(JSON.parse(File.read(result[:ledger]))['state']).to eq('expired')
+    end
+
+    it 'requires explicit continuation retirement and preserves an active association' do
+      swarm = PWN::AI::Agent::Swarm
+      root = File.join(Dir.home, '.pwn', 'swarm')
+      stub_const('PWN::AI::Agent::Swarm::SWARM_ROOT', root)
+      sid = swarm.create[:swarm_id]
+      swarm.spawn(name: 'fixture', role: 'fixture', swarm_id: sid)
+      map = File.join(root, sid, 'personas.json')
+      File.write(map, JSON.generate('fixture' => id))
+      lease = PWN::Sessions.activate(session_id: id)
+      expect { swarm.retire(name: 'fixture', swarm_id: sid, local: true, continuation: true) }.to raise_error(IOError, /active/)
+      expect(JSON.parse(File.read(map))['fixture']).to eq(id)
+      PWN::Sessions.deactivate(lease: lease)
+      lease = nil
+      result = swarm.retire(name: 'fixture', swarm_id: sid, local: true, continuation: true)
+      expect(result[:continuation]).to include(session_id: id, state: 'committed')
+      expect(JSON.parse(File.read(map))).not_to have_key('fixture')
+      expect(File.exist?(path)).to be(true)
+      expect(swarm.send(:persona_session, swarm_id: sid, name: 'fixture')).not_to eq(id)
+    ensure
+      PWN::Sessions.deactivate(lease: lease) if lease
+    end
+
+    it 'bounds applying session batches without hiding remaining candidates' do
+      allow(described_class).to receive(:legacy_owners).and_return([])
+      PWN::Sessions.create(id: '20200101_010203_abcdef13')
+      described_class.install
+      config = File.join(Dir.home, '.pwn', 'maintenance', 'policy.json')
+      File.write(config, JSON.generate(described_class.policy.merge('batch_size' => 1)))
+      result = described_class.run(dry_run: false)
+      expect(result[:deleted_ids].length).to eq(1)
+      expect(result[:candidate_ids].length).to eq(2)
+      expect(result[:skipped][:batch_limit]).to eq(1)
+      expect(Dir.glob(File.join(PWN::Sessions.sessions_dir, '*.jsonl')).length).to eq(1)
+    end
+
+    it 'preserves failed writes and exposes interrupted prepared records instead of declaring completion' do
+      file = File.join(Dir.home, '.pwn', 'tmp', 'failure')
+      FileUtils.mkdir_p(File.dirname(file))
+      File.binwrite(file, "binary\xFF".b)
+      described_class.register_disposable(path: file, category: 'tmp', expires_at: 0)
+      allow(File).to receive(:unlink).and_call_original
+      allow(File).to receive(:unlink).with(file).and_raise(Errno::EACCES)
+      result = described_class.clean_disposables(dry_run: false)
+      expect(result[:state]).to eq('interrupted')
+      expect(File.binread(file)).to eq("binary\xFF".b)
+      ledger = JSON.parse(File.binread(result[:ledger]))
+      expect(ledger['records'].first['state']).to eq('prepared')
+      expect(File.binread(ledger['records'].first['backup'])).to eq(File.binread(file))
+    ensure
+      allow(File).to receive(:unlink).and_call_original
+    end
+
+    it 'recovers exact disposable backups without overwriting changed destinations' do
+      file = File.join(Dir.home, '.pwn', 'tmp', 'binary')
+      FileUtils.mkdir_p(File.dirname(file))
+      bytes = "café\xFF\x00".b
+      File.binwrite(file, bytes)
+      described_class.register_disposable(path: file, category: 'tmp', expires_at: 0)
+      result = described_class.clean_disposables(dry_run: false)
+      expect(described_class.recover(ledger: result[:ledger])[:restored]).to be_empty
+      expect(File.exist?(file)).to be(false)
+      expect(described_class.recover(ledger: result[:ledger], dry_run: false)[:restored]).to eq([file])
+      expect(File.binread(file)).to eq(bytes)
+      File.binwrite(file, 'later user edit')
+      expect { described_class.recover(ledger: result[:ledger], dry_run: false) }.to raise_error(IOError, /existing/)
+      expect(File.binread(file)).to eq('later user edit')
+    end
+
+    it 'serializes transcript compaction and append on a permanent writer inode' do
+      lock_path = "#{path}.write.lock"
+      writer = nil
+      File.open(lock_path, 'a') do |lock|
+        lock.flock(File::LOCK_EX)
+        entered = Queue.new
+        writer = Thread.new do
+          entered << true
+          PWN::Sessions.append(session_id: id, role: 'assistant', content: 'retained append')
+        end
+        entered.pop
+        expect(writer.join(0.05)).to be_nil
+      end
+      writer.join(2)
+      expect(writer).not_to be_alive
+      expect(PWN::Sessions.load(session_id: id).last[:content]).to eq('retained append')
+      inode = File.stat(lock_path).ino
+      PWN::Sessions.send(:compact_transcript!, path: path, assistant_content_max: 2)
+      expect(File.stat(lock_path).ino).to eq(inode)
+      expect(Dir.glob("#{path}.*.tmp")).to be_empty
+    ensure
+      writer&.join(2)
+    end
+
+    it 'dispatches maintenance status locally and shares routine cleanup with the cron entry point' do
+      expect(PWN::Plugins::REPL).to receive(:pwn_ai_print_result).with(value: hash_including(operation: 'status'))
+      expect(PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: '/maintenance status', raise_errors: true)).to be_truthy
+      allow(described_class).to receive(:legacy_owners).and_return([])
+      expect(described_class).to receive(:clean_disposables).with(dry_run: true).and_call_original
+      expect(described_class.maintain(dry_run: true)[:storage]).to include(operation: 'routine')
+    end
+
+    it 'cleans only verified expired disposable bytes and preserves active, changed and unknown files' do
+      root = File.join(Dir.home, '.pwn', 'cache')
+      FileUtils.mkdir_p(root)
+      paths = %w[expired active changed unknown].to_h { |name| [name, File.join(root, name)] }
+      paths.each_value { |file| File.binwrite(file, "café\x00".b) }
+      %w[expired active changed].each { |name| described_class.register_disposable(path: paths[name], category: 'cache', expires_at: Time.now.to_i - 1) }
+      File.binwrite(paths['changed'], 'new data')
+      File.open("#{paths['active']}.lease", 'a') do |lease|
+        lease.flock(File::LOCK_SH)
+        preview = described_class.clean_disposables(dry_run: true)
+        expect(preview[:eligible]).to eq([paths['expired']])
+        expect(File.exist?(paths['expired'])).to be(true)
+        result = described_class.clean_disposables(dry_run: false)
+        expect(result[:deleted]).to eq([paths['expired']])
+        expect(File.exist?(paths['expired'])).to be(false)
+        expect(JSON.parse(File.binread(result[:ledger]))['state']).to eq('committed')
+      end
+      %w[active changed unknown].each { |name| expect(File.file?(paths[name])).to be(true) }
+    end
+
+    it 'reports all storage categories read-only and preserves unknown files' do
+      root = File.join(Dir.home, '.pwn')
+      FileUtils.mkdir_p(File.join(root, 'tmp'))
+      unknown = File.join(root, 'tmp', 'unknown.bin')
+      File.binwrite(unknown, "\xFF\x00".b)
+      before = Dir.glob(File.join(root, '**', '*'), File::FNM_DOTMATCH).sort
+      status = described_class.status
+      expect(status[:categories].keys).to match_array(%w[sessions learning artifacts state logs cache tmp maintenance backups])
+      expect(status[:categories]['tmp']).to include(files: 1, bytes: 2)
+      expect(Dir.glob(File.join(root, '**', '*'), File::FNM_DOTMATCH).sort).to eq(before)
+      expect(File.binread(unknown)).to eq("\xFF\x00".b)
+    end
+  end
+end
+
 RSpec.describe PWN::SessionCleanup do
   include_context 'pwn tmp sandbox'
 
@@ -289,14 +620,16 @@ RSpec.describe PWN::SessionCleanup do
     cron_id = PWN::Sessions.create[:id]
     payload = PWN::Cron::DEFAULT_JOBS.find { |job| job[:name] == 'session_cleanup' }[:ruby]
     allow(PWN::Cron).to receive(:cron_dir).and_return(File.expand_path('../../../etc/default_cron', __dir__))
-    expect(eval(payload)[:deleted_ids]).to eq([cron_id]) # rubocop:disable Security/Eval -- execute the exact bundled local job
+    coordinated = eval(payload) # rubocop:disable Security/Eval -- execute the exact bundled local job
+    expect(coordinated.dig(:phases, :maintenance, :deleted_ids)).to eq([cron_id])
+    expect(File).not_to exist(File.join(PWN::Sessions.sessions_dir, "#{cron_id}.jsonl"))
     legacy_id = PWN::Sessions.create[:id]
     expect(described_class.run(dry_run: false)[:deleted_ids]).to eq([legacy_id])
   end
 
   it 'does not migrate evidence or delete while legacy ownership is unresolved' do
     allow(described_class).to receive(:legacy_owners).and_return([{ pid: 123, reason: 'legacy_session_ownership_unknown' }])
-    expect(PWN::AI::Agent::Learning).to receive(:migrate_evidence).with(dry_run: true).and_call_original
+    expect(PWN::AI::Agent::Learning).to receive(:migrate_evidence).with(hash_including(dry_run: true, max_sessions: 100)).and_call_original
     expect(described_class.maintain[:apply_blocked]).to be(true)
     expect(File).to exist(path)
   end