pwn 0.5.663 → 0.5.665

data/lib/pwn/sessions.rb

@@ -13,6 +13,15 @@ module PWN
   # session on each activation.
   module Sessions
     SESSIONS_DIR = File.join(Dir.home, '.pwn', 'sessions')
+    # Lean retention — pin gold/mistake refs; drop stubs and unreferenced age.
+    RETAIN_DAYS = 30
+    HOT_DAYS = 14
+    MIN_STUB_BYTES = 200
+    TOOL_CONTENT_MAX = 1_500
+    ASSISTANT_CONTENT_MAX = 8_000
+    COMPACT_SIZE_FLOOR = 100_000
+    MAX_FILES = 400
+    GOLD_MIN_SCORE = 0.6
 
     # Supported Method Parameters::
     #   dir = PWN::Sessions.sessions_dir
@@ -74,9 +83,21 @@ module PWN
       path = File.join(sessions_dir, "#{sid}.jsonl")
       raise "Session #{sid} not found" unless File.exist?(path)
 
+      role = (opts[:role] || 'user').to_s
+      content = opts[:content]
+      if content.is_a?(String)
+        # Write-path policy: cap bulk by role using compact limits so append
+        # cannot grow transcripts past TOOL_CONTENT_MAX / ASSISTANT_CONTENT_MAX.
+        cap = case role
+              when 'tool' then TOOL_CONTENT_MAX
+              when 'assistant' then ASSISTANT_CONTENT_MAX
+              else ASSISTANT_CONTENT_MAX * 2
+              end
+        content = "#{content[0, cap]}…[compacted]" if content.bytesize > cap
+      end
       entry = {
-        role: opts[:role] || 'user',
-        content: opts[:content],
+        role: role,
+        content: content,
         timestamp: Time.now.utc.iso8601
       }
       File.open(path, 'a') { |f| f.puts(JSON.dump(entry)) }
@@ -115,10 +136,22 @@ module PWN
     end
 
     # Supported Method Parameters::
-    #   PWN::Sessions.delete(session_id:)
+    #   PWN::Sessions.delete(
+    #     session_id: 'required',
+    #     force: 'optional - Boolean bypass pin policy (default false)'
+    #   )
+    # Refuses deletion of pinned sessions (hot/gold/mistake/current) unless force:true.
     public_class_method def self.delete(opts = {}) # rubocop:disable Naming/PredicateMethod
       sid = opts[:session_id]
+      raise 'ERROR: session_id required' if sid.to_s.empty?
+
+      force = opts[:force] ? true : false
       path = File.join(sessions_dir, "#{sid}.jsonl")
+      unless force
+        pins = protected_session_ids(current_session_id: opts[:current_session_id])
+        raise "ERROR: refusing to delete protected session #{sid.inspect} (pinned by HOT_DAYS/gold/mistakes/current; pass force:true)" if pins.include?(sid.to_s)
+      end
+
       FileUtils.rm_f(path)
       true
     end
@@ -135,6 +168,236 @@ module PWN
       }
     end
 
+    # Supported Method Parameters::
+    #   result = PWN::Sessions.lean!(
+    #     dry_run: 'optional - Boolean (default false)',
+    #     retain_days: 'optional - drop unreferenced older than this',
+    #     hot_days: 'optional - always keep newer than this',
+    #     max_files: 'optional - soft file cap after protections',
+    #     current_session_id: 'optional - never delete this id'
+    #   )
+    #
+    # Reference-protect sessions cited by gold learning outcomes and open
+    # mistakes. Delete stubs and aged unreferenced files. Compact oversized
+    # tool/assistant content on kept cold transcripts.
+    public_class_method def self.lean!(opts = {})
+      dry = opts[:dry_run] ? true : false
+      retain_days = (opts[:retain_days] || RETAIN_DAYS).to_f
+      hot_days = (opts[:hot_days] || HOT_DAYS).to_f
+      max_files = (opts[:max_files] || MAX_FILES).to_i
+      tool_max = (opts[:tool_content_max] || TOOL_CONTENT_MAX).to_i
+      asst_max = (opts[:assistant_content_max] || ASSISTANT_CONTENT_MAX).to_i
+      current = opts[:current_session_id].to_s
+      current = PWN::Env.dig(:ai, :session_id).to_s if current.empty? && defined?(PWN::Env)
+
+      dir = sessions_dir
+      files = Dir.glob(File.join(dir, '*.jsonl'))
+      before_bytes = files.sum { |f| File.size(f) }
+      now = Time.now.utc
+
+      protect = protected_session_ids(
+        current_session_id: current,
+        hot_days: hot_days,
+        retain_days: retain_days,
+        now: now
+      )
+
+      deleted = []
+      compacted = []
+      protected_n = 0
+
+      # Classify
+      entries = files.map do |path|
+        id = File.basename(path, '.jsonl')
+        mtime = File.mtime(path).utc
+        age = (now - mtime) / 86_400.0
+        size = File.size(path)
+        pinned = protect.include?(id) || age <= hot_days
+        protected_n += 1 if pinned
+        { id: id, path: path, age: age, size: size, pinned: pinned, mtime: mtime }
+      end
+
+      # Delete stubs and aged unreferenced
+      entries.each do |e|
+        next if e[:pinned]
+
+        stub = e[:size] < MIN_STUB_BYTES && stub_session?(path: e[:path])
+        aged = e[:age] > retain_days
+        next unless stub || aged
+
+        deleted << e[:id]
+        FileUtils.rm_f(e[:path]) unless dry
+      end
+
+      # Refresh remaining after deletes
+      remaining = entries.reject { |e| deleted.include?(e[:id]) }
+
+      # Enforce max_files on unpinned oldest-first
+      if remaining.size > max_files
+        unpinned = remaining.reject { |e| e[:pinned] }.sort_by { |e| e[:mtime] }
+        over = remaining.size - max_files
+        unpinned.first(over).each do |e|
+          deleted << e[:id]
+          FileUtils.rm_f(e[:path]) unless dry
+          remaining.delete(e)
+        end
+      end
+
+      # Compact large/cold kept files
+      remaining.each do |e|
+        next if e[:age] <= hot_days && e[:size] < COMPACT_SIZE_FLOOR
+        next if e[:size] < COMPACT_SIZE_FLOOR && e[:age] <= retain_days
+
+        changed = compact_transcript!(
+          path: e[:path],
+          tool_max: tool_max,
+          asst_max: asst_max,
+          dry_run: dry
+        )
+        compacted << e[:id] if changed
+      end
+
+      after_files = Dir.glob(File.join(dir, '*.jsonl'))
+      after_bytes = after_files.sum { |f| File.size(f) }
+
+      {
+        deleted: deleted.length,
+        deleted_ids: deleted.first(30),
+        compacted: compacted.length,
+        compacted_ids: compacted.first(30),
+        protected: protected_n,
+        remaining: after_files.size,
+        bytes_before: before_bytes,
+        bytes_after: dry ? before_bytes : after_bytes,
+        dry_run: dry
+      }
+    end
+
+    # Build the pin set from learning gold + open mistakes + hot files + current.
+    public_class_method def self.protected_session_ids(opts = {})
+      now = opts[:now] || Time.now.utc
+      hot_days = (opts[:hot_days] || HOT_DAYS).to_f
+      retain_days = (opts[:retain_days] || RETAIN_DAYS).to_f
+      pins = {}
+      pins[opts[:current_session_id].to_s] = true unless opts[:current_session_id].to_s.empty?
+
+      # Hot by mtime
+      Dir.glob(File.join(sessions_dir, '*.jsonl')).each do |path|
+        age = (now - File.mtime(path).utc) / 86_400.0
+        pins[File.basename(path, '.jsonl')] = true if age <= hot_days
+      end
+
+      # Learning gold
+      learn_file = File.join(Dir.home, '.pwn', 'learning.jsonl')
+      if File.exist?(learn_file)
+        File.foreach(learn_file) do |line|
+          r = JSON.parse(line, symbolize_names: true)
+          sid = r[:session_id].to_s
+          next if sid.empty?
+
+          gold = r[:success] == true && (
+            !r.key?(:score) || r[:score].to_f >= GOLD_MIN_SCORE
+          )
+          pins[sid] = true if gold
+        rescue StandardError
+          next
+        end
+      end
+
+      # Mistakes refs
+      mist_file = File.join(Dir.home, '.pwn', 'mistakes.json')
+      if File.exist?(mist_file)
+        begin
+          store = JSON.parse(File.read(mist_file), symbolize_names: true)
+          store.each_value do |m|
+            next unless m.is_a?(Hash)
+
+            openish = !m[:resolved] || m[:regressed]
+            recent_closed = false
+            if m[:resolved] && m[:last_seen]
+              begin
+                recent_closed = ((now - Time.parse(m[:last_seen].to_s)) / 86_400.0) <= retain_days
+              rescue StandardError
+                recent_closed = false
+              end
+            end
+            next unless openish || recent_closed
+
+            Array(m[:sessions]).each { |s| pins[s.to_s] = true if s.to_s != '' }
+          end
+        rescue StandardError
+          # ignore
+        end
+      end
+
+      pins.keys.reject(&:empty?)
+    end
+
+    private_class_method def self.stub_session?(opts = {})
+      path = opts[:path]
+      return true unless File.exist?(path)
+
+      rows = File.readlines(path).map do |l|
+        JSON.parse(l, symbolize_names: true)
+      rescue StandardError
+        nil
+      end.compact
+      substantive = rows.any? do |e|
+        role = e[:role].to_s
+        %w[user assistant].include?(role) && e[:content].to_s.strip.length > 20
+      end
+      !substantive
+    rescue StandardError
+      true
+    end
+
+    private_class_method def self.compact_transcript!(opts = {})
+      path = opts[:path]
+      tool_max = opts[:tool_max] || TOOL_CONTENT_MAX
+      asst_max = opts[:assistant_content_max] || opts[:asst_max] || ASSISTANT_CONTENT_MAX
+      dry = opts[:dry_run] ? true : false
+      return false unless File.exist?(path)
+
+      lines = File.readlines(path)
+      rows = lines.map do |l|
+        JSON.parse(l, symbolize_names: true)
+      rescue StandardError
+        nil
+      end.compact
+      return false if rows.empty?
+
+      # Preserve last assistant fully-ish; compact tools and older assistants
+      last_asst_i = rows.rindex { |e| e[:role].to_s == 'assistant' }
+      changed = false
+      rows.each_with_index do |e, i|
+        role = e[:role].to_s
+        content = e[:content].to_s
+        if role == 'tool' && content.bytesize > tool_max
+          e[:content] = "#{content[0, tool_max]}…[compacted]"
+          changed = true
+        elsif role == 'assistant' && i != last_asst_i && content.bytesize > asst_max
+          e[:content] = "#{content[0, asst_max]}…[compacted]"
+          changed = true
+        elsif role == 'assistant' && i == last_asst_i && content.bytesize > (asst_max * 2)
+          e[:content] = "#{content[0, asst_max * 2]}…[compacted]"
+          changed = true
+        end
+      end
+      return changed if dry || !changed
+
+      tmp = "#{path}.#{Process.pid}.tmp"
+      File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o644) do |f|
+        f.flock(File::LOCK_EX)
+        rows.each { |e| f.puts(JSON.generate(e)) }
+        f.flush
+        f.fsync
+      end
+      File.rename(tmp, path)
+      true
+    ensure
+      FileUtils.rm_f(tmp) if defined?(tmp) && tmp && File.exist?(tmp)
+    end
+
     # Author(s):: 0day Inc. <support@0dayinc.com>
 
     public_class_method def self.authors
@@ -151,7 +414,8 @@ module PWN
           hist = PWN::Sessions.to_response_history(session_id: sess[:id])
           PWN::Sessions.list
           PWN::Sessions.stats
-          PWN::Sessions.delete(session_id: sess[:id])
+          PWN::Sessions.delete(session_id: sess[:id], force: true)
+          PWN::Sessions.lean!(dry_run: true)  # pin gold/mistake refs; drop stubs/age
 
           #{self}.authors
       USAGE

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.663'
+  VERSION = '0.5.665'
 end

data/spec/integration/persistence_roundtrip_spec.rb

@@ -25,7 +25,7 @@ RSpec.describe 'PWN persistence stores — write → reload → delete round-tri
       hist = PWN::Sessions.to_response_history(session_id: s[:id])
       expect(hist).to be_a(Hash).or be_an(Array)
       expect(PWN::Sessions.stats[:total_sessions]).to be >= 1
-      expect(PWN::Sessions.delete(session_id: s[:id])).to be_truthy
+      expect(PWN::Sessions.delete(session_id: s[:id], force: true)).to be_truthy
       expect(PWN::Sessions.load(session_id: s[:id])).to eq([])
     end
   end
@@ -38,7 +38,7 @@ RSpec.describe 'PWN persistence stores — write → reload → delete round-tri
       expect(PWN::Memory.forget(key: 'rt_key')).to be_truthy
       expect(PWN::Memory.recall(query: 'needle')).to be_empty
       PWN::Memory.remember(key: 'x', value: 'y')
-      PWN::Memory.clear
+      PWN::Memory.clear(force: true)
       expect(PWN::Memory.load).to eq({})
     end
   end

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

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'json'
+require 'fileutils'
+require 'tmpdir'
+require 'time'
+
+RSpec.describe 'lean RL stores' do
+  let(:tmpdir) { Dir.mktmpdir('pwn-lean-') }
+  after { FileUtils.rm_rf(tmpdir) }
+
+  def with_store_paths
+    mem = File.join(tmpdir, 'memory.json')
+    learn = File.join(tmpdir, 'learning.jsonl')
+    mist = File.join(tmpdir, 'mistakes.json')
+    sess = File.join(tmpdir, 'sessions')
+    FileUtils.mkdir_p(sess)
+
+    stub_const('PWN::Memory::MEMORY_FILE', mem)
+    stub_const('PWN::AI::Agent::Learning::LEARNING_FILE', learn)
+    stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', mist)
+    stub_const('PWN::Sessions::SESSIONS_DIR', sess)
+    yield(mem: mem, learn: learn, mist: mist, sess: sess)
+  end
+
+  it 'Memory.lean! drops expired session_* but keeps prefs and SOPs' do
+    with_store_paths do
+      PWN::Memory.remember(key: :operator_pref_x, value: 'keep me', category: :preference, importance: 1.0)
+      PWN::Memory.remember(key: :process_sop_y, value: 'always rake', category: :lesson, importance: 1.0)
+      PWN::Memory.remember(
+        key: :session_old_context,
+        value: 'ephemeral',
+        category: :fact,
+        ttl: 1
+      )
+      # backdate
+      m = PWN::Memory.load
+      m[:session_old_context][:timestamp] = (Time.now.utc - 86_400).iso8601
+      PWN::Memory.save(mem: m)
+
+      r = PWN::Memory.lean!
+      expect(r[:removed]).to be >= 1
+      left = PWN::Memory.load
+      expect(left.keys.map(&:to_s)).to include('operator_pref_x', 'process_sop_y')
+      expect(left.keys.map(&:to_s)).not_to include('session_old_context')
+    end
+  end
+
+  it 'Learning.prune_outcomes! keeps gold success+score and never empties failure window' do
+    with_store_paths do |paths|
+      now = Time.now.utc
+      rows = []
+      # gold
+      5.times do |i|
+        rows << {
+          id: "g#{i}", task: "gold task #{i}", success: true, score: 0.9,
+          session_id: "sid_gold_#{i}", tags: %w[auto loop], details: 'x' * 50,
+          timestamp: (now - i).iso8601
+        }
+      end
+      # bulk old low-score auto noise
+      40.times do |i|
+        rows << {
+          id: "n#{i}", task: "noise #{i % 3}", success: false, score: 0.1,
+          session_id: "sid_n_#{i}", tags: %w[auto loop wrong], details: 'y' * 1200,
+          timestamp: (now - ((50 + i) * 86_400)).iso8601
+        }
+      end
+      File.write(paths[:learn], "#{rows.map { |r| JSON.generate(r) }.join("\n")}\n")
+
+      r = PWN::AI::Agent::Learning.prune_outcomes!(max_rows: 30, retain_days: 45, recent_days: 14)
+      kept = File.readlines(paths[:learn]).map { |l| JSON.parse(l, symbolize_names: true) }
+      gold_left = kept.select { |r| r[:id].to_s.start_with?('g') }
+      expect(gold_left.size).to eq(5)
+      expect(kept.size).to be <= 30
+      expect(r[:kept]).to eq(kept.size)
+      # details truncated
+      expect(kept.any? { |r| r[:details].to_s.include?('[compacted]') || r[:details].to_s.bytesize <= 800 }).to be true
+    end
+  end
+
+  it 'Mistakes.lean! never drops unresolved signatures' do
+    with_store_paths do |paths|
+      store = {
+        open1: {
+          signature: 'open1', tool: 'shell', error: 'boom', snippet: 'x' * 300,
+          sample_args: 'a' * 400, count: 2, first_seen: Time.now.utc.iso8601,
+          last_seen: Time.now.utc.iso8601, sessions: %w[s1 s2 s3 s4],
+          resolved: false, fix: nil
+        },
+        oldres: {
+          signature: 'oldres', tool: 'shell', error: 'old', snippet: 's',
+          sample_args: 'a', count: 1, first_seen: (Time.now.utc - (40 * 86_400)).iso8601,
+          last_seen: (Time.now.utc - (40 * 86_400)).iso8601,
+          resolved_at: (Time.now.utc - (40 * 86_400)).iso8601,
+          sessions: %w[s9], resolved: true, fix: 'do the thing'
+        }
+      }
+      File.write(paths[:mist], JSON.pretty_generate(store))
+      # memory already has fix lesson
+      PWN::Memory.remember(key: :mistake_fix_oldres, value: 'AVOID: shell → old — FIX: do the thing', category: :lesson)
+
+      r = PWN::AI::Agent::Mistakes.lean!
+      after = PWN::AI::Agent::Mistakes.load
+      expect(after.keys.map(&:to_s)).to include('open1')
+      expect(after[:open1][:sample_args].to_s.bytesize).to be <= PWN::AI::Agent::Mistakes::SAMPLE_ARGS_MAX
+      expect(Array(after[:open1][:sessions]).size).to be <= PWN::AI::Agent::Mistakes::SESSIONS_KEEP
+      expect(r[:unresolved]).to eq(1)
+    end
+  end
+
+  it 'Sessions.lean! pins gold session ids and deletes unreferenced stubs' do
+    with_store_paths do |paths|
+      gold_id = '20260101_000000_gold0001'
+      stub_id = '20260101_000000_stub0001'
+      old_id = '20260101_000000_old00001'
+
+      File.write(File.join(paths[:sess], "#{gold_id}.jsonl"), "#{JSON.generate(role: 'user', content: 'do gold work here', timestamp: Time.now.utc.iso8601)}\n")
+      File.write(File.join(paths[:sess], "#{stub_id}.jsonl"), "#{JSON.generate(role: 'system', content: 'Session started', timestamp: Time.now.utc.iso8601)}\n")
+      File.write(File.join(paths[:sess], "#{old_id}.jsonl"), "#{JSON.generate(role: 'user', content: 'old stuff session', timestamp: (Time.now.utc - (60 * 86_400)).iso8601)}\n")
+      # age the old/stub mtimes
+      old_t = Time.now - (60 * 86_400)
+      File.utime(old_t, old_t, File.join(paths[:sess], "#{old_id}.jsonl"))
+      File.utime(old_t, old_t, File.join(paths[:sess], "#{stub_id}.jsonl"))
+
+      gold_row = {
+        id: '1', task: 't', success: true, score: 0.95, session_id: gold_id,
+        tags: [], details: 'ok', timestamp: Time.now.utc.iso8601
+      }
+      File.write(paths[:learn], "#{JSON.generate(gold_row)}\n")
+      File.write(paths[:mist], '{}')
+
+      r = PWN::Sessions.lean!(retain_days: 30, hot_days: 14, max_files: 400)
+      expect(File.exist?(File.join(paths[:sess], "#{gold_id}.jsonl"))).to be true
+      expect(File.exist?(File.join(paths[:sess], "#{stub_id}.jsonl"))).to be false
+      expect(File.exist?(File.join(paths[:sess], "#{old_id}.jsonl"))).to be false
+      expect(r[:deleted]).to be >= 2
+    end
+  end
+
+  it 'Learning.consolidate does not evict protected operator_pref keys' do
+    with_store_paths do
+      5.times do |i|
+        PWN::Memory.remember(key: :"noise_#{i}", value: "noise lesson #{i} " * 5, category: :lesson, importance: 0.1, confidence: 0.2)
+      end
+      PWN::Memory.remember(key: :operator_pref_keep, value: 'must survive', category: :preference, importance: 1.0, confidence: 1.0)
+      r = PWN::AI::Agent::Learning.consolidate(max_entries: 3)
+      left = PWN::Memory.load
+      expect(left.keys.map(&:to_s)).to include('operator_pref_keep')
+      expect(left.size).to be <= 3
+      expect(r[:remaining]).to eq(left.size)
+    end
+  end
+
+  it 'Learning.should_gc_stores? gates on PRUNE_EVERY_N_APPENDS and MAX_OUTCOME_ROWS' do
+    with_store_paths do |paths|
+      # empty / missing → true (force initial lean opportunity)
+      FileUtils.rm_f(paths[:learn])
+      expect(PWN::AI::Agent::Learning.send(:should_gc_stores?)).to be true
+
+      n = PWN::AI::Agent::Learning::PRUNE_EVERY_N_APPENDS
+      rows = n.times.map do |i|
+        {
+          id: "r#{i}", task: "t#{i}", success: false, score: 0.2,
+          session_id: "s#{i}", tags: %w[auto loop], details: 'd',
+          timestamp: Time.now.utc.iso8601
+        }
+      end
+      File.write(paths[:learn], "#{rows.map { |r| JSON.generate(r) }.join("\n")}\n")
+      expect(PWN::AI::Agent::Learning.send(:should_gc_stores?)).to be true
+
+      # one under the modulo boundary
+      short = rows.first(n - 1)
+      File.write(paths[:learn], "#{short.map { |r| JSON.generate(r) }.join("\n")}\n")
+      expect(PWN::AI::Agent::Learning.send(:should_gc_stores?)).to be false
+    end
+  end
+
+  it 'Learning.gc_stores! leans memory+learning+mistakes+sessions and pins current_session_id' do
+    with_store_paths do |paths|
+      now = Time.now.utc
+      cur = '20260101_000000_current1'
+      stub_id = '20260101_000000_stub9999'
+      File.write(File.join(paths[:sess], "#{cur}.jsonl"), "#{JSON.generate(role: 'user', content: 'active turn', timestamp: now.iso8601)}\n")
+      File.write(File.join(paths[:sess], "#{stub_id}.jsonl"), "#{JSON.generate(role: 'system', content: 'Session started', timestamp: now.iso8601)}\n")
+      old_t = Time.now - (60 * 86_400)
+      File.utime(old_t, old_t, File.join(paths[:sess], "#{stub_id}.jsonl"))
+
+      PWN::Memory.remember(key: :session_tmp_gc, value: 'ephemeral', category: :fact, ttl: 1)
+      m = PWN::Memory.load
+      m[:session_tmp_gc][:timestamp] = (now - 86_400).iso8601
+      PWN::Memory.save(mem: m)
+
+      # modulo-aligned noise outcomes
+      n = PWN::AI::Agent::Learning::PRUNE_EVERY_N_APPENDS
+      rows = n.times.map do |i|
+        {
+          id: "n#{i}", task: "noise #{i % 2}", success: false, score: 0.1,
+          session_id: "sid_#{i}", tags: %w[auto loop wrong], details: 'z' * 50,
+          timestamp: (now - ((50 + i) * 86_400)).iso8601
+        }
+      end
+      File.write(paths[:learn], "#{rows.map { |r| JSON.generate(r) }.join("\n")}\n")
+      File.write(paths[:mist], JSON.pretty_generate({}))
+
+      res = PWN::AI::Agent::Learning.gc_stores!(current_session_id: cur)
+      expect(res).to include(:memory, :learning, :mistakes, :sessions)
+      expect(File.exist?(File.join(paths[:sess], "#{cur}.jsonl"))).to be true
+      expect(File.exist?(File.join(paths[:sess], "#{stub_id}.jsonl"))).to be false
+      left_mem = PWN::Memory.load
+      expect(left_mem.keys.map(&:to_s)).not_to include('session_tmp_gc')
+    end
+  end
+
+  it 'auto_introspect runs :lean_gc via gc_stores! when should_gc_stores?' do
+    with_store_paths do |paths|
+      # Enable auto_introspect for this process
+      PWN::Env[:ai] ||= {}
+      PWN::Env[:ai][:agent] ||= {}
+      prev = PWN::Env[:ai][:agent][:auto_introspect]
+      PWN::Env[:ai][:agent][:auto_introspect] = true
+
+      n = PWN::AI::Agent::Learning::PRUNE_EVERY_N_APPENDS
+      now = Time.now.utc
+      # Leave learning at n-1 so note_outcome append hits modulo n and should_gc fires
+      rows = (n - 1).times.map do |i|
+        {
+          id: "pre#{i}", task: "pre #{i}", success: true, score: 0.9,
+          session_id: "sid_pre_#{i}", tags: %w[auto loop solved], details: 'ok',
+          timestamp: now.iso8601
+        }
+      end
+      File.write(paths[:learn], "#{rows.map { |r| JSON.generate(r) }.join("\n")}\n")
+      File.write(paths[:mist], '{}')
+      FileUtils.mkdir_p(paths[:sess])
+
+      called = []
+      allow(PWN::AI::Agent::Learning).to receive(:gc_stores!).and_wrap_original do |m, **opts|
+        called << opts
+        m.call(**opts)
+      end
+      # Avoid LLM/slow stages
+      allow(PWN::AI::Agent::Reward).to receive(:judge).and_return(
+        { score: 0.8, success: true, verdict: :solved, rationale: 'ok', confidence: 0.7 }
+      )
+      allow(PWN::AI::Agent::Reward).to receive(:prm)
+      allow(PWN::AI::Agent::Reward).to receive(:sentinel)
+      allow(PWN::AI::Agent::Curriculum).to receive(:critic).and_return(verdict: :pass, source: :test)
+      allow(PWN::AI::Agent::Learning).to receive(:reflect)
+      allow(PWN::AI::Agent::Extrospection).to receive(:auto_extrospect) if defined?(PWN::AI::Agent::Extrospection)
+
+      sid = '20260101_000000_introspect'
+      File.write(File.join(paths[:sess], "#{sid}.jsonl"), "#{JSON.generate(role: 'user', content: 'hi', timestamp: now.iso8601)}\n")
+
+      out = PWN::AI::Agent::Learning.auto_introspect(
+        session_id: sid,
+        request: 'keep stores lean please',
+        final: 'done lean'
+      )
+      expect(out).to be_a(Hash)
+      expect(Array(out[:stages_run])).to include(:lean_gc)
+      expect(called).not_to be_empty
+      expect(called.last[:current_session_id]).to eq(sid)
+    ensure
+      PWN::Env[:ai][:agent][:auto_introspect] = prev if defined?(prev)
+    end
+  end
+end