pwn 0.5.783 → 0.5.784

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[:deleted]).to eq(%w[20260101_000000 20260102_000000])
+    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,59 @@ describe PWN::Migrate do
       allow(PWN::Config).to receive(:pwn_skills_path).and_return(File.join(@tmp, 'skills'))
     end
 
+    it 'expires unique old history only after current recovery coverage is established' do
+      File.write(File.join(@tmp, 'memory.json'), '{"current":true}')
+      4.times do |i|
+        path = File.join(PWN::Migrate::BACKUP_ROOT, "2026010#{i + 1}_000000")
+        FileUtils.mkdir_p(path)
+        File.write(File.join(path, 'memory.json'), i == 3 ? '{"current":true}' : "{\"old\":#{i}}")
+      end
+      result = PWN::Migrate.prune_backups(dry_run: false, expire_history: true)
+      expect(result[:deleted]).to eq(['20260101_000000'])
+      expect(result[:retained].length).to eq(3)
+      expect(File).to exist(File.join(PWN::Migrate::BACKUP_ROOT, '.retention-manifest.json.gz'))
+      expect(File.read(File.join(@tmp, 'memory.json'))).to eq('{"current":true}')
+    end
+
+    context 'bounded historical expiry safeguards' do
+      before do
+        File.write(File.join(@tmp, 'memory.json'), '{}')
+        5.times do |i|
+          path = File.join(PWN::Migrate::BACKUP_ROOT, "2026010#{i + 1}_000000")
+          FileUtils.mkdir_p(path)
+          File.write(File.join(path, 'memory.json'), '{}')
+        end
+      end
+
+      it 'pins actual referenced evidence, not quoted inventory prose' do
+        File.write(File.join(@tmp, 'learning.jsonl'), "#{JSON.generate(evidence_path: "#{PWN::Migrate::BACKUP_ROOT}/20260101_000000/memory.json", prose: "old path #{PWN::Migrate::BACKUP_ROOT}/20260102_000000/memory.json")}\n")
+        FileUtils.cp(File.join(@tmp, 'learning.jsonl'), File.join(PWN::Migrate::BACKUP_ROOT, '20260105_000000', 'learning.jsonl'))
+        result = PWN::Migrate.prune_backups(dry_run: false, expire_history: true)
+        expect(result[:deleted]).to eq(['20260102_000000'])
+        expect(result[:pins]).to eq(['20260101_000000'])
+      end
+
+      it 'refuses expiry without current coverage or matching credential recovery' do
+        File.write(File.join(@tmp, 'pwn.yaml'), 'encrypted-current-fixture')
+        result = PWN::Migrate.prune_backups(dry_run: false, expire_history: true)
+        expect(result[:incomplete]).to be true
+        expect(result[:deleted]).to be_empty
+        File.write(File.join(PWN::Migrate::BACKUP_ROOT, '20260105_000000', 'pwn.yaml'), 'encrypted-old-fixture')
+        expect(PWN::Migrate.prune_backups(dry_run: false, expire_history: true)[:error]).to match(/encrypted configuration/)
+      end
+
+      it 'refuses symlinks and held producer locks and exhausted admission' do
+        File.symlink(File.join(@tmp, 'memory.json'), File.join(PWN::Migrate::BACKUP_ROOT, '20260101_000000', 'unsafe'))
+        expect(PWN::Migrate.prune_backups(dry_run: false, expire_history: true)[:deleted]).to be_empty
+        File.unlink(File.join(PWN::Migrate::BACKUP_ROOT, '20260101_000000', 'unsafe'))
+        File.open(File.join(PWN::Migrate::BACKUP_ROOT, '.retention.lock'), 'w') do |lock|
+          lock.flock(File::LOCK_EX)
+          expect(PWN::Migrate.prune_backups(dry_run: false, expire_history: true)[:error]).to eq('Backup maintenance active')
+        end
+        expect(PWN::Migrate.prune_backups(dry_run: false, expire_history: true, admission: ->(_bytes) { false })[:deleted]).to be_empty
+      end
+    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 +166,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])
       expected = Marshal.load(Marshal.dump(original))
       expected['custom']['model'] = nil
       expect(YAML.safe_load_file(path)).to eq(expected)
@@ -189,7 +275,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])
       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 +301,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])
       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 +326,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])
       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 +373,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])
       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 +397,72 @@ 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 'retains three recovery points and unique history but prunes verified duplicate snapshots' do
+    root = described_class::BACKUP_ROOT
+    5.times do |i|
+      dir = File.join(root, "2026010#{i + 1}_000000")
+      FileUtils.mkdir_p(dir)
+      File.write(File.join(dir, 'learning.jsonl'), i.zero? ? 'unique evidence' : 'same evidence')
+    end
+    preview = described_class.prune_backups
+    expect(preview[:eligible].length).to eq(1)
+    expect(Dir.children(root).length).to eq(5)
+    applied = described_class.prune_backups(dry_run: false)
+    expect(applied[:deleted].length).to eq(1)
+    expect(File.binread(File.join(root, '20260101_000000', 'learning.jsonl'))).to eq('unique evidence')
+    expect(Dir.children(root).grep(/\A\d/).length).to eq(4)
+  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 symlinked backup trees and exhausted admission without deleting anything' do
+    root = described_class::BACKUP_ROOT
+    FileUtils.mkdir_p(root)
+    File.symlink(@tmp, File.join(root, '20260101_000000'))
+    expect(described_class.prune_backups(dry_run: false)[:incomplete]).to be(true)
+    File.unlink(File.join(root, '20260101_000000'))
+    4.times do |i|
+      dir = File.join(root, "2026010#{i + 1}_000000")
+      FileUtils.mkdir_p(dir)
+      File.write(File.join(dir, 'state'), 'same')
+    end
+    result = described_class.prune_backups(dry_run: false, admission: ->(_bytes) { false })
+    expect(result[:incomplete]).to be(true)
+    expect(result[:deleted]).to eq([])
+    expect(Dir.children(root).grep(/\A\d/).length).to eq(4)
+  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

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

@@ -15,6 +15,13 @@ describe PWN::Plugins::Log do
   end
 
   describe 'pwn-ai debug session' 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'))
+    end
+
     after do
       PWN::Plugins::Log.stop_debug if PWN::Plugins::Log.respond_to?(:stop_debug)
     end

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

@@ -317,7 +317,7 @@ describe 'session maintenance command workers' do
     console.instance_variable_get(:@tool_input)&.close
   end
 
-  it 'keeps navigation and input alive through the real maintenance learning lock and queues errors' do
+  it 'defers a real maintenance learning lock without blocking navigation and queues errors' do
     require File.expand_path('../../../../../etc/default_cron/session_cleanup', __dir__)
     allow(PWN::SessionCleanup).to receive(:legacy_owners).and_return([])
     stub_const('PWN::AI::Agent::Learning::LEARNING_FILE', File.join(@tmp, '.pwn', 'learning.jsonl'))
@@ -339,7 +339,7 @@ describe 'session maintenance command workers' do
     Timeout.timeout(2) { console.submit('/sessions cleanup') }
     Timeout.timeout(2) { entered.pop }
     worker = console.instance_variable_get(:@worker)
-    expect(worker.join(0.05)).to be_nil
+    expect(worker.join(5)).to eq(worker)
     console.submit('/input fixture')
     expect(reader.read_nonblock(8)).to eq("fixture\n")
     console.handle("\u0014")
@@ -350,6 +350,16 @@ describe 'session maintenance command workers' do
     lock = nil
     expect(worker.join(5)).to eq(worker)
     console.send(:drain)
+    # A busy writer defers before deletion admission without waiting for release.
+    # A fresh command must still delete, proving the stop state does not leak.
+    expect(File).to exist(File.join(PWN::Sessions.sessions_dir, "#{sid}.jsonl"))
+    ledgers = Dir.glob(File.join(@tmp, '.pwn', 'maintenance', 'runs', '*.json')).map { |path| JSON.parse(File.read(path)) }
+    expect(ledgers.last).to include('state' => 'blocked')
+    expect(ledgers.last.dig('result', 'evidence_migration', 'deferred')).to eq('learning_writer_active')
+    expect(console.send(:busy?)).to be_falsey
+    console.submit('/sessions cleanup')
+    expect(console.instance_variable_get(:@worker).join(5)).not_to be_nil
+    console.send(:drain)
     expect(File).not_to exist(File.join(PWN::Sessions.sessions_dir, "#{sid}.jsonl"))
     expect(console.instance_variable_get(:@timeline).select { |row| row[0] == :command }.map { |row| row[1] }.join).to include('deleted: 1')
     allow(PWN::SessionCleanup).to receive(:maintain).and_raise(IOError, 'fixture maintenance failed')
@@ -379,10 +389,12 @@ describe 'session maintenance command workers' do
     console.instance_variable_set(:@tool_input, writer)
     entered = Queue.new
     release = Queue.new
-    allow(PWN::SessionCleanup).to receive(:run).and_wrap_original do |method, **options|
+    # Pause inside the admitted deletion transaction, not before run checks stop.
+    # Cancellation here must finish the backed-up commit without deleting late IDs.
+    allow(PWN::Sessions).to receive(:delete).and_wrap_original do |method, **options|
       entered << true
       release.pop
-      method.call(**options)
+      method.call(options)
     end
     Timeout.timeout(2) { console.handle("\r") }
     Timeout.timeout(2) { entered.pop }

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

@@ -5,6 +5,17 @@ require 'spec_helper'
 describe PWN::Plugins::REPL::AISwarm::Controller do
   include_context 'pwn tmp sandbox'
 
+  it 'routes explicit continuation retirement through the slash command without changing ordinary retire' do
+    controller = described_class.new(session_id: 'fixture')
+    allow(PWN::AI::Agent::Swarm).to receive(:create).and_return(swarm_id: 'fixture-swarm')
+    expect(PWN::AI::Agent::Swarm).to receive(:retire).with(hash_including(name: 'scout', continuation: true)).and_return(retired: true)
+    expect(PWN::AI::Agent::Swarm).to receive(:retire).with(hash_including(name: 'critic', continuation: false)).and_return(retired: true)
+    controller.execute(line: '/swarm retire scout --continuation')
+    controller.execute(line: '/swarm retire critic')
+  ensure
+    controller&.close
+  end
+
   it 'retains cancellation evidence and forwards bounded mission options unchanged' do
     allow(PWN::AI::Agent::Swarm).to receive(:solve) do |opts|
       expect(opts).to include(worktree: true, rounds: 2, verification_timeout: 120, role_timeout: 45)

data/spec/lib/pwn/redaction_spec.rb

@@ -40,22 +40,25 @@ RSpec.describe 'Persistence redaction' do
   it 'sanitizes regular, learning, debug, mirror, stderr and fallback writes' do
     Dir.mktmpdir do |dir|
       secret = 'ASIAABCDEFGHIJKLMNOP'
-      path = File.join(dir, 'log')
-      allow(File).to receive(:open).and_call_original
-      allow(File).to(receive(:open).with('/tmp/pwn.log', 'a').and_wrap_original { |m, _, mode| m.call(path, mode) })
+      allow(Dir).to receive(:home).and_return(dir)
+      path = File.join(dir, '.pwn', 'logs', 'pwn.log')
       PWN::Plugins::Log.append(level: :info, msg: secret, which_self: secret)
       PWN::Plugins::Log.append(level: :info, msg: { api_key: 'nested-fixture-only' })
       expect(File.read(path)).not_to include(secret, 'nested-fixture-only')
       expect(File.read(path)).to include('[REDACTED:aws:')
-      PWN::Plugins::Log.start_debug(path: path)
-      PWN::Plugins::Log.progress(msg: secret)
-      PWN::Plugins::Log.mirror_tui!(msg: secret)
-      PWN::Plugins::Log.capture_stderr!(text: "#{secret}\n")
+      debug_path = File.join(dir, '.pwn', 'logs', 'debug.log')
+      PWN::Plugins::Log.start_debug(path: debug_path)
+      PWN::Plugins::Log.progress(msg: "progress-sink #{secret}")
+      PWN::Plugins::Log.mirror_tui!(msg: "mirror-sink #{secret}")
+      PWN::Plugins::Log.capture_stderr!(text: "stderr-sink #{secret}\n")
       allow(PWN::Plugins::Log).to receive(:progress).and_return(false)
-      PWN::Plugins::Log.note_interrupt!(where: secret)
+      PWN::Plugins::Log.note_interrupt!(where: "fallback-sink #{secret}")
       PWN::Plugins::Log.stop_debug
-      expect(File.read(path)).not_to include(secret)
-      expect(File.read(path)).to include('[REDACTED:aws:')
+      body = File.read(debug_path)
+      expect(body).not_to include(secret)
+      %w[progress-sink mirror-sink stderr-sink fallback-sink].each do |sink|
+        expect(body).to include("#{sink} [REDACTED:aws:")
+      end
     ensure
       PWN::Plugins::Log.stop_debug
     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