pwn 0.5.781 → 0.5.783

data/spec/lib/pwn/ai/agent/learning_spec.rb

@@ -5,6 +5,34 @@ require 'tmpdir'
 require 'fileutils'
 
 describe PWN::AI::Agent::Learning do
+  describe 'worker lock ownership' do
+    include_context 'pwn tmp sandbox'
+
+    it 'does not inherit learning write ownership through copied request locals' do
+      lock = described_class.send(:learning_lock)
+      inherited = Thread.current[:pwn_learning_write_lock]
+      entered = Queue.new
+      acquired = Queue.new
+      worker = Thread.new do
+        Thread.current[:pwn_learning_write_lock] = inherited
+        entered << true
+        child_lock = described_class.send(:learning_lock)
+        acquired << child_lock
+      ensure
+        described_class.send(:learning_unlock, lock: child_lock) if child_lock
+      end
+      Timeout.timeout(2) { entered.pop }
+      expect(worker.join(0.05)).to be_nil
+      described_class.send(:learning_unlock, lock: lock)
+      lock = nil
+      expect(worker.join(2)).to eq(worker)
+      expect(acquired.pop).not_to be_nil
+    ensure
+      described_class.send(:learning_unlock, lock: lock) if lock
+      worker&.join(2)
+    end
+  end
+
   describe 'failure regression tasks' do
     include_context 'pwn tmp sandbox'
 
@@ -47,6 +75,41 @@ describe PWN::AI::Agent::Learning do
 
     after { FileUtils.rm_rf(@home) }
 
+    it 'migrates Unicode evidence byte-exactly and rolls back the original index' do
+      @trace.last[:content] = "café 日本語 🔒 e\u0301"
+      File.binwrite(@source, "#{@trace.map(&:to_json).join("\n")}\r\n")
+      original_source = File.binread(@source)
+      @original = "#{JSON.generate(session_id: @sid, task: 'résumé 日本語')}\r\n"
+      File.binwrite(@learning, @original)
+      expect(PWN::Sessions.dependency_index[:dependencies][@sid]).to include(@learning)
+      result = described_class.migrate_evidence(dry_run: false)
+      expect(result[:migrated_rows]).to eq(1)
+      row = JSON.parse(File.binread(@learning), symbolize_names: true)
+      expect(described_class.evidence_transcript(row: row)).to eq(@trace)
+      expect(described_class.evidence_complete?(row: row)).to be(true)
+      expect(File.binread(@source)).to eq(original_source)
+      migration = Digest::SHA256.hexdigest(@original)
+      backup = File.join(@root, 'learning', 'migrations', "#{migration}.backup.jsonl")
+      expect(File.binread(backup)).to eq(@original.b)
+      expect(described_class.rollback_evidence(migration: migration)[:restored]).to be(true)
+      expect(File.binread(@learning)).to eq(@original.b)
+    end
+
+    it 'verifies exact bytes without changing input encoding or accepting altered readback' do
+      target = File.join(@root, 'learning', 'probe.bin')
+      ['ASCII', 'café 日本語 🔒', "e\u0301", "\xFF\x00".b].each do |body|
+        encoding = body.encoding
+        original = body.dup
+        described_class.send(:evidence_write, path: target, body: body)
+        expect(File.binread(target)).to eq(original.b)
+        expect(body).to eq(original)
+        expect(body.encoding).to eq(encoding)
+      end
+      allow(described_class).to receive(:evidence_read).with(path: target).and_return('altered'.b)
+      expect { described_class.send(:evidence_write, path: target, body: 'café') }
+        .to raise_error(IOError, 'Evidence write verification failed')
+    end
+
     it 'keeps original references when artifact creation is interrupted and retries safely' do
       allow(described_class).to receive(:evidence_write).and_wrap_original do |method, opts|
         raise IOError, 'injected interruption' if opts[:path].include?('/evidence/')
@@ -82,7 +145,7 @@ describe PWN::AI::Agent::Learning do
       File.open(@source, 'a') { |file| file.puts(JSON.generate(role: 'user', content: 'new turn')) }
       expect(described_class.evidence_complete?(row: row)).to be(false)
       File.delete(artifact)
-      expect(PWN::Sessions.dependency_index[:dependencies][@sid]).to include(@learning)
+      expect(PWN::Sessions.dependency_index[:session_errors][@sid]).to include(@learning)
       expect(PWN::Sessions.protected_session_ids(hot_days: -1)).to include(@sid)
       expect(PWN::Sessions.load(session_id: @sid)).not_to be_empty
     end
@@ -249,7 +312,7 @@ describe PWN::AI::Agent::Learning do
       expect(described_class.migrate_evidence(dry_run: false)[:migrated_rows]).to eq(0)
       artifact = File.join(root, 'learning', 'evidence', "#{row[:evidence_ref][:sha256]}.json")
       File.write(artifact, '{}')
-      expect(PWN::Sessions.dependency_index[:dependencies]).to have_key(sid)
+      expect(PWN::Sessions.dependency_index[:session_errors]).to have_key(sid)
       expect { PWN::Sessions.load(session_id: sid) }.to raise_error(IOError)
     end
   end

data/spec/lib/pwn/ai/agent/swarm_spec.rb

@@ -233,9 +233,9 @@ describe PWN::AI::Agent::Swarm do
       text_only: true
     )
     expect(PWN::Sessions.sessions_dir).to eq(File.join(@swarm_home, 'sessions'))
-    expect(PWN::Sessions.list.length).to eq(1)
-    expect(PWN::Sessions.active?(session_id: PWN::Sessions.list.first[:id])).to be(false)
-    expect(PWN::Sessions.list.map { |session| session[:path] }).to all(start_with(File.join(@swarm_home, 'sessions', '')))
+    expect(PWN::Sessions.list(include_hidden: true).length).to eq(1)
+    expect(PWN::Sessions.active?(session_id: PWN::Sessions.list(include_hidden: true).first[:id])).to be(false)
+    expect(PWN::Sessions.list(include_hidden: true).map { |session| session[:path] }).to all(start_with(File.join(@swarm_home, 'sessions', '')))
     expect(described_class.honesty_unmet).to eq([])
     expect(Array(Thread.current[:pwn_swarm_honesty])).to eq([])
     expect(Thread.current[:pwn_swarm_id]).to be_nil

data/spec/lib/pwn/memory_spec.rb

@@ -4,7 +4,64 @@ require 'spec_helper'
 require 'tmpdir'
 require 'fileutils'
 
-describe PWN::Memory do
+RSpec.describe PWN::Memory do
+  describe 'store transactions' do
+    include_context 'pwn tmp sandbox'
+
+    it 'serializes concurrent read modify write and allows nested methods' do
+      threads = 4.times.map do |worker|
+        Thread.new { 10.times { |index| described_class.remember(key: "worker_#{worker}_#{index}", value: index) } }
+      end
+      threads.each(&:value)
+      expect(described_class.load.keys.grep(/worker_/).size).to eq(40)
+      described_class.transaction do
+        described_class.forget(key: 'worker_0_0')
+        described_class.lean!
+      end
+      expect(described_class.load.keys.map(&:to_s)).not_to include('worker_0_0')
+    end
+
+    it 'serializes mistake writers in separate processes on the permanent inode' do
+      children = 3.times.map do |worker|
+        fork do
+          8.times do |index|
+            PWN::AI::Agent::Mistakes.record(tool: "fixture_#{worker}_#{index}", error: 'fixture failure')
+          end
+          exit! 0
+        end
+      end
+      children.each { |pid| expect(Process.wait2(pid).last.exitstatus).to eq(0) }
+      expect(PWN::AI::Agent::Mistakes.load.size).to eq(24)
+    end
+
+    it 'keeps external Learning memory rewrites inside a transaction' do
+      described_class.remember(key: :fixture, value: 'retained')
+      allow(described_class).to receive(:save).and_wrap_original do |original, options|
+        expect(described_class.transaction_owned?).to be(true)
+        original.call(options)
+      end
+      allow(PWN::MemoryIndex).to receive(:available?).and_return(false)
+      PWN::AI::Agent::Learning.consolidate
+      PWN::AI::Agent::Learning.purge_noise
+    end
+
+    it 'does not expire a refreshed key from an old snapshot' do
+      described_class.remember(key: :refresh, value: 'old')
+      stale = described_class.load
+      described_class.remember(key: :refresh, value: 'new')
+      described_class.send(:archive_expired!, rows: stale)
+      expect(described_class.load[:refresh][:value]).to eq('new')
+    end
+
+    it 'refuses corrupt mistake input instead of overwriting it' do
+      path = PWN::AI::Agent::Mistakes::MISTAKES_FILE
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, '{corrupt')
+      expect { PWN::AI::Agent::Mistakes.record(tool: 'fixture', error: 'failure') }.to raise_error(JSON::ParserError)
+      expect(File.read(path)).to eq('{corrupt')
+    end
+  end
+
   it 'should display information for authors' do
     authors_response = PWN::Memory
     expect(authors_response).to respond_to :authors

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

@@ -9,6 +9,7 @@ describe 'operator workspace navigation' do
 
   before do
     allow(Dir).to receive(:home).and_return(@tmp)
+    FileUtils.mkdir_p(File.join(@tmp, '.pwn'))
     stub_const('PWN::AI::Agent::SkillReview::LEDGER', File.join(@tmp, 'skill_review.jsonl'))
     stub_const('PWN::AI::Agent::OpenGoal::GOAL_FILE', File.join(@tmp, 'open_goal.json'))
     allow(Pry).to receive(:history).and_return(Pry::History.new(file_path: File.join(@tmp, 'pwn_history')))
@@ -249,24 +250,162 @@ describe 'operator workspace navigation' do
     text = console.send(:operator_content).join
     expect(text).to include('ruby check.rb', 'observed failure', 'tested-revision', 'cancelled')
   end
+end
+
+describe 'session maintenance command workers' do
+  include_context 'pwn tmp sandbox'
+
+  before do
+    allow(Dir).to receive(:home).and_return(@tmp)
+    FileUtils.mkdir_p(File.join(@tmp, '.pwn'))
+    allow(Pry).to receive(:history).and_return(Pry::History.new(file_path: File.join(@tmp, 'pwn_history')))
+  end
+
+  let(:pry) { Pry.new }
+  let(:console) { PWN::Plugins::REPL::AIConsole::Console.new(pry: pry, input: StringIO.new, curses: nil, getch: nil) }
+
+  def open_view(line)
+    console.submit(line)
+    Timeout.timeout(5) do
+      while console.instance_variable_get(:@operator_view)&.dig(:loading)
+        console.instance_variable_get(:@operator_worker)&.join(0.01)
+        console.send(:drain)
+      end
+    end
+  end
+
+  after { console.send(:stop_worker) }
+
+  it 'routes cleanup off the input owner and delivers completion after safe cancellation' do
+    require File.expand_path('../../../../../etc/default_cron/session_cleanup', __dir__)
+    entered = Queue.new
+    release = Queue.new
+    owner = Thread.current
+    reader, writer = IO.pipe
+    console.instance_variable_set(:@input, reader)
+    console.instance_variable_set(:@tool_input, writer)
+    allow(PWN::SessionCleanup).to receive(:maintain) do |**options|
+      entered << [Thread.current, options]
+      release.pop
+      { fixture: 'committed deletion' }
+    end
+    allow(PWN::SessionCleanup).to receive(:summary) { |result| result }
+    allow(PWN::Plugins::REPL).to receive(:pwn_ai_print_result) do |value:|
+      console.instance_variable_get(:@events) << [:command, value.inspect]
+    end
+    Timeout.timeout(2) { console.submit('/sessions cleanup') }
+    thread, options = Timeout.timeout(2) { entered.pop }
+    expect(thread).not_to eq(owner)
+    expect(options[:dry_run]).to be(false)
+    console.handle("\u0014")
+    console.handle(:page_up)
+    console.submit('/sessions cleanup')
+    expect(PWN::SessionCleanup).to have_received(:maintain).once
+    console.handle("\u0003")
+    expect(thread).to be_alive
+    release << true
+    expect(thread.join(2)).to eq(thread)
+    console.send(:drain)
+    expect(console.send(:busy?)).to be_falsey
+    text = console.instance_variable_get(:@timeline).map { |row| row[1] }.join
+    expect(text).to include('committed deletion', 'not undone')
+    expect(text).not_to include('Request cancelled')
+  ensure
+    release << true if release
+    console.instance_variable_get(:@worker)&.join(2)
+    reader&.close
+    console.instance_variable_get(:@tool_input)&.close
+  end
+
+  it 'keeps navigation and input alive through the real maintenance learning lock 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'))
+    sid = PWN::Sessions.create[:id]
+    reader, writer = IO.pipe
+    console.instance_variable_set(:@input, reader)
+    console.instance_variable_set(:@tool_input, writer)
+    events = console.instance_variable_get(:@events)
+    output = PWN::Plugins::REPL::AIConsole::EventIO.new(events)
+    allow(PWN::Plugins::REPL).to receive(:pwn_ai_print_result).and_wrap_original do |method, **options|
+      method.call(options.merge(output: output))
+    end
+    lock = PWN::AI::Agent::Learning.send(:learning_lock)
+    entered = Queue.new
+    allow(PWN::AI::Agent::Learning).to receive(:migrate_evidence).and_wrap_original do |method, **options|
+      entered << true
+      method.call(options)
+    end
+    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
+    console.submit('/input fixture')
+    expect(reader.read_nonblock(8)).to eq("fixture\n")
+    console.handle("\u0014")
+    console.handle(:page_up)
+    console.handle("\u0003")
+    expect(File).to exist(File.join(PWN::Sessions.sessions_dir, "#{sid}.jsonl"))
+    PWN::AI::Agent::Learning.send(:learning_unlock, lock: lock)
+    lock = nil
+    expect(worker.join(5)).to eq(worker)
+    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')
+    console.submit('/sessions cleanup')
+    expect(console.instance_variable_get(:@worker).join(2)).not_to be_nil
+    console.send(:drain)
+    expect(console.instance_variable_get(:@timeline).map { |row| row[1] }.join).to include('IOError: fixture maintenance failed')
+    expect(console.send(:busy?)).to be_falsey
+  ensure
+    PWN::AI::Agent::Learning.send(:learning_unlock, lock: lock) if lock
+    console.instance_variable_get(:@worker)&.join(5)
+    reader&.close
+    console.instance_variable_get(:@tool_input)&.close
+  end
 
   it 'previews cleanup and applies only unchanged explicitly approved candidates' do
     require File.expand_path('../../../../../etc/default_cron/session_cleanup', __dir__)
     allow(PWN::SessionCleanup).to receive(:legacy_owners).and_return([])
     old = PWN::Sessions.create[:id]
-    open_view('/sessions cleanup')
+    open_view('/sessions cleanup --dry-run')
     expect(console.send(:operator_content).join).to include(old)
     late = PWN::Sessions.create[:id]
     console.handle('a')
     expect(File).to exist(File.join(PWN::Sessions.sessions_dir, "#{old}.jsonl"))
-    console.handle("\r")
+    reader, writer = IO.pipe
+    console.instance_variable_set(:@input, reader)
+    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|
+      entered << true
+      release.pop
+      method.call(**options)
+    end
+    Timeout.timeout(2) { console.handle("\r") }
+    Timeout.timeout(2) { entered.pop }
+    console.handle("\e")
+    console.handle("\u0003")
+    release << true
+    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, "#{old}.jsonl"))
     expect(File).to exist(File.join(PWN::Sessions.sessions_dir, "#{late}.jsonl"))
+  ensure
+    release << true if release
+    console.instance_variable_get(:@worker)&.join(5)
+    reader&.close
+    console.instance_variable_get(:@tool_input)&.close
   end
 
   it 'searches sessions by stable ID and resumes the selected ID without changing a draft' do
     first = PWN::Sessions.create(title: 'Duplicate title')[:id]
     second = PWN::Sessions.create(title: 'Duplicate title')[:id]
+    [first, second].each do |id|
+      File.write(File.join(PWN::Sessions.sessions_dir, "#{id}.meta.json"), JSON.generate(title: 'Duplicate title', title_source: 'summary', summary: 'Fixture summary', summary_turns: 2))
+    end
     pry.config.pwn_ai_session_id = first
     editor = console.instance_variable_get(:@editor)
     editor.replace('unfinished draft')
@@ -287,6 +426,8 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
   include_context 'pwn tmp sandbox'
 
   before do
+    allow(Dir).to receive(:home).and_return(@tmp)
+    FileUtils.mkdir_p(File.join(@tmp, '.pwn'))
     @history_path = File.join(@tmp, 'pwn_history')
     @request_history = Pry::History.new(file_path: @history_path)
     allow(Pry).to receive(:history).and_return(@request_history)
@@ -373,6 +514,40 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     FileUtils.rm_rf(workspace) if workspace
   end
 
+  it 'coalesces title jobs per session and never drops a different pending session' do
+    ids = 3.times.map { PWN::Sessions.create[:id] }
+    ids.each_with_index { |sid, index| PWN::Sessions.append(session_id: sid, role: 'user', content: "Session topic #{index}") }
+    reached = Queue.new
+    release = Queue.new
+    calls = []
+    allow(PWN::AI::Router).to receive(:summarize) do |opts|
+      calls << opts[:text]
+      if calls.length == 1
+        reached << true
+        release.pop
+      end
+      JSON.generate(title: "Conversation #{calls.length}", summary: opts[:text])
+    end
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    console.send(:queue_title_update, ids[0])
+    Timeout.timeout(5) { reached.pop }
+    console.send(:queue_title_update, ids[1])
+    console.send(:queue_title_update, ids[2])
+    console.send(:queue_title_update, ids[1])
+    release << true
+    Timeout.timeout(5) do
+      while console.instance_variable_get(:@title_worker)
+        console.send(:drain)
+        Thread.pass
+      end
+    end
+    expect(calls.length).to eq(3)
+    ids.each { |sid| expect(PWN::Sessions.title_status(session_id: sid)[:is_summarized]).to be(true) }
+  ensure
+    release << true if release
+    console&.instance_variable_get(:@title_worker)&.kill
+  end
+
   it 'paints provisional and asynchronously updated summary titles in the actual SESSION pane' do
     reached = Queue.new
     release = Queue.new
@@ -390,18 +565,27 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
       expect(PWN::Sessions.metadata(session_id: opts[:session_id])[:title]).to eq('Investigate login and repair all expired certificates')
       PWN::Sessions.append(session_id: opts[:session_id], content: opts[:request])
       PWN::Sessions.append(session_id: opts[:session_id], role: 'assistant', content: 'Certificate repaired')
+      PWN::Env[:ai] = { active: :ollama, ollama: { model: 'later-model', base_uri: 'http://fixture.invalid' } }
       'Certificate repaired'
     end
     submitted = false
     unblocked = false
-    launch('Investigate login and repair all expired certificates today'.chars) do
+    listed = false
+    keys = 'Investigate login and repair all expired certificates today'.chars
+    launch(keys) do
       unless submitted
         submitted = true
         @pry.config.pwn_ai_session_id = PWN::Sessions.create[:id]
         next "\r"
       end
-      if !reached.empty? && !unblocked
+      if !reached.empty? && !listed
+        listed = true
+        keys.concat("/sessions list\n".chars)
+      end
+      if listed && @rendered.map(&:last).join.include?('active: true') && !unblocked
         expect(@paint.join).to include('SESSION Investigate login and repair all expired certificates')
+        expect(@rendered.map(&:last).join).to include(@pry.config.pwn_ai_session_id, 'title: Investigate login and repair all expired certificates')
+        expect(PWN::Sessions.title_status(session_id: @pry.config.pwn_ai_session_id)[:is_summarized]).to be(false)
         unblocked = true
         release << true
       end
@@ -416,7 +600,8 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
   end
 
   it 'resumes the displayed title after async renaming through curses with surrounding whitespace and restores history' do
-    sid = PWN::Sessions.create(id: 'displayed_title', title: 'Café  "login" repair')[:id]
+    sid = PWN::Sessions.create(id: '20200101_010203_abcdef12', title: 'Café  "login" repair')[:id]
+    File.write(File.join(PWN::Sessions.sessions_dir, "#{sid}.meta.json"), JSON.generate(title: 'Café  "login" repair', title_source: 'summary', summary: 'Fixture summary', summary_turns: 1))
     PWN::Sessions.append(session_id: sid, role: 'user', content: 'Prior fixture request')
     PWN::Sessions.append(session_id: sid, role: 'assistant', content: 'Prior fixture answer')
     requested = false
@@ -2518,7 +2703,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
   it 'keeps network slash commands off the event thread so tool prompts can receive explicit input' do
     entered = Queue.new
     expect(PWN::AI::Agent::Loop).not_to receive(:run)
-    expect(PWN::Plugins::REPL).to receive(:pwn_ai_dispatch_slash!).with(request: '/mcp call fixture', pry: anything) do
+    expect(PWN::Plugins::REPL).to receive(:pwn_ai_dispatch_slash!).with(request: '/mcp call fixture', pry: anything, raise_errors: true) do
       entered << true
       puts "local command received: #{$stdin.gets}"
       true

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

@@ -158,7 +158,7 @@ describe 'menu chronology routing' do
   let(:records) { [{ id: 'new-record', timestamp: 10 }, { id: 'old-record', timestamp: 0 }] }
 
   {
-    '/sessions list' => ['PWN::Sessions', :list, :array],
+    '/sessions list' => ['PWN::Sessions', :catalog, :nested],
     '/cron list' => ['PWN::Cron', :list, :map],
     '/cron create hourly fixture' => ['PWN::Cron', :create, :nested],
     '/cron run fixture' => ['PWN::Cron', :run, :json],
@@ -176,7 +176,7 @@ describe 'menu chronology routing' do
                when :nested then { results: records }
                when :json then JSON.generate(results: records)
                end
-      result = [{ id: 'new-record', mtime: 10 }, { id: 'old-record', mtime: 0 }] if line == '/sessions list'
+      result = { sessions: [{ id: 'new-record', mtime: 10 }, { id: 'old-record', mtime: 0 }] } if line == '/sessions list'
       original = Marshal.dump(result)
       allow(Object.const_get(namespace)).to receive(method).and_return(result)
       allow(PWN::AI::MCP).to receive(:backends).and_return([{ name: 'fixture' }]) if namespace == 'PWN::AI::MCP'

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

@@ -93,14 +93,15 @@ describe 'menu command result routes' do
   end
 
   it 'resumes by exact Unicode title or id through plural commands and lists both fields' do
-    session = PWN::Sessions.create(id: 'resume_title', title: 'Café  "login" repair')
-    ['/sessions resume Café  "login" repair', '/sessions resume \'Café  "login" repair\'', '/sessions resume resume_title', '　/sessions　resume　Café  "login" repair　'].each do |line|
+    session = PWN::Sessions.create(id: '20200101_010203_abcdef13', title: 'Café  "login" repair')
+    File.write(File.join(PWN::Sessions.sessions_dir, '20200101_010203_abcdef13.meta.json'), JSON.generate(title: 'Café  "login" repair', title_source: 'summary', summary: 'Reviewed the login repair.', summary_turns: 1))
+    ['/sessions resume Café  "login" repair', '/sessions resume \'Café  "login" repair\'', '/sessions resume 20200101_010203_abcdef13', '　/sessions　resume　Café  "login" repair　'].each do |line|
       pry.config.pwn_ai_session_id = 'before'
       expect(PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: line, pry: pry)).to be(true)
       expect(pry.config.pwn_ai_session_id).to eq(session[:id])
     end
     ['/sessions list'].each do |line|
-      expect { PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: line, pry: pry) }.to output(a_string_including('id: resume_title', 'title: Café  "login" repair')).to_stdout
+      expect { PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: line, pry: pry) }.to output(a_string_including('id: 20200101_010203_abcdef13', 'title: Café  "login" repair')).to_stdout
     end
   end
 
@@ -118,14 +119,14 @@ describe 'menu command result routes' do
 
   it 'lists and resumes the same seven-word legacy title with stable id fallback on collisions' do
     title = 'One two three four five six seven'
-    PWN::Sessions.create(id: 'capped_resume')
-    File.write(File.join(PWN::Sessions.sessions_dir, 'capped_resume.meta.json'), JSON.generate(title: "#{title} eight nine", title_source: 'summary'))
+    PWN::Sessions.create(id: '20200101_010203_abcdef14')
+    File.write(File.join(PWN::Sessions.sessions_dir, '20200101_010203_abcdef14.meta.json'), JSON.generate(title: "#{title} eight nine", title_source: 'summary', summary: 'Summarized the prior conversation.', summary_turns: 1))
     expect { PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: '/sessions list', pry: pry) }.to output(a_string_including("title: #{title}\n")).to_stdout
     PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: "/sessions resume '#{title}'", pry: pry)
-    expect(pry.config.pwn_ai_session_id).to eq('capped_resume')
+    expect(pry.config.pwn_ai_session_id).to eq('20200101_010203_abcdef14')
     PWN::Sessions.create(id: 'capped_duplicate', title: "#{title} ten")
-    expect { PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: "/sessions resume #{title}", pry: pry) }.to output(a_string_including('NOTICE', 'Ambiguous', 'capped_resume', 'capped_duplicate', '/sessions resume <ID>')).to_stdout
-    expect(pry.config.pwn_ai_session_id).to eq('capped_resume')
+    expect { PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: "/sessions resume #{title}", pry: pry) }.to output(a_string_including('NOTICE', 'Ambiguous', '20200101_010203_abcdef14', 'capped_duplicate', '/sessions resume <ID>')).to_stdout
+    expect(pry.config.pwn_ai_session_id).to eq('20200101_010203_abcdef14')
     PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: '/sessions resume capped_duplicate', pry: pry)
     expect(pry.config.pwn_ai_session_id).to eq('capped_duplicate')
   end
@@ -139,11 +140,27 @@ describe 'menu command result routes' do
     expect(pry.config.pwn_ai_session_id).to eq('original')
   end
 
+  it 'keeps the current provisional session in both command routes without summary provenance' do
+    allow(Dir).to receive(:home).and_return(@tmp)
+    sid = PWN::Sessions.create[:id]
+    PWN::Sessions.provisional_title(session_id: sid, request: 'Investigate certificate chain')
+    pry.config.pwn_ai_session_id = sid
+    expect { PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: '/sessions list', pry: pry) }.to output(a_string_including("id: #{sid}", 'active: true', 'title: Investigate certificate chain')).to_stdout
+    PWN::Plugins::REPL::AI.add_commands
+    allow(Pry).to receive(:history).and_return(Pry::History.new(file_path: File.join(@tmp, 'active_history')))
+    output = StringIO.new
+    legacy = Pry.new(output: output, quiet: true)
+    legacy.config.pwn_ai_session_id = sid
+    legacy.eval('pwn-ai-sessions list')
+    expect(output.string).to include("id: #{sid}", 'active: true', 'title: Investigate certificate chain')
+    expect(PWN::Sessions.title_status(session_id: sid)[:is_summarized]).to be(false)
+  end
+
   it 'preserves the configured Pry output stream for legacy command aliases' do
     PWN::Plugins::REPL::AI.add_commands
     allow(Pry).to receive(:history).and_return(Pry::History.new(file_path: File.join(@tmp, 'alias_history')))
     allow(PWN::Memory).to receive(:recall).and_return(record)
-    allow(PWN::Sessions).to receive_messages(list: record, stats: record)
+    allow(PWN::Sessions).to receive_messages(catalog: record, stats: record)
     allow(PWN::Cron).to receive_messages(list: record, run: record)
     ['pwn-ai-memory list', 'pwn-ai-memory recall fixture', 'pwn-ai-sessions list', 'pwn-ai-sessions stats', 'pwn-ai-cron list', 'pwn-ai-cron run fixture'].each do |line|
       output = StringIO.new
@@ -166,8 +183,8 @@ describe 'menu command result routes' do
     '/cron' => ['PWN::Cron', :list],
     '/cron list' => ['PWN::Cron', :list],
     '/cron run fixture' => ['PWN::Cron', :run],
-    '/sessions' => ['PWN::Sessions', :list],
-    '/sessions list' => ['PWN::Sessions', :list],
+    '/sessions' => ['PWN::Sessions', :catalog],
+    '/sessions list' => ['PWN::Sessions', :catalog],
     '/sessions stats' => ['PWN::Sessions', :stats],
     '/memory' => ['PWN::Memory', :recall],
     '/memory list' => ['PWN::Memory', :recall],

data/spec/lib/pwn/session_cleanup_default_spec.rb

@@ -40,7 +40,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 v6')
+    expect(File.read(helper)).to include('# PWN managed default: session_cleanup v9')
     expect(File.read(PWN::Cron.jobs_file)).to eq(bytes)
   end
 
@@ -67,6 +67,6 @@ RSpec.describe 'Bundled session cleanup' do
       RbConfig.ruby, '-I', File.expand_path('../../../lib', __dir__), helper, '--dry-run'
     )
     expect(status.success?).to be(true), error
-    expect(JSON.parse(output)).to include('dry_run' => true, 'scanned' => 0, 'deleted_ids' => [])
+    expect(JSON.parse(output)).to include('dry_run' => true, 'scanned' => 0, 'deleted' => 0)
   end
 end