pwn 0.5.664 → 0.5.665

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e88bcfaae1b1859df50e16528f8460a31cab0d7a8168206b9f48c3541c00b88
-  data.tar.gz: c143b22d04b09c1c30a7f6b2f7bfe17cf3dfb8812484db4e42daf9565ba12668
+  metadata.gz: d289c114e06e9e253df8f9071e23c0ed34786b946c04bf570521f808bca54bf2
+  data.tar.gz: c045f0f8e5df6b33a0c9927a72aca147c903010e6ff0a888fee7e2ef04b96ace
 SHA512:
-  metadata.gz: 06d533eb382b1b6509684e15db4dcb8e9bdd24d9ac628e1f07c090bfd7f099e7a608ef61e2c87969e54f245736fb6a10f170042cd650f1dbd023816c788e662c
-  data.tar.gz: c3243b7fd533a14ad0825546b60b88b465ae8bdc5b476f001dd00cad98788d73173b578c981467a6ec664f1e60815d4bd2f3efa6a6b659e17b85e6ab6d4ad09d
+  metadata.gz: 62f913dfe7d20f3154a55a5f2db7f91589141f87b57f0736d0da7bc1f5ae2a843f3f75cb2e274539ce68b9d1ea82cfed1584f0fcf5bf054fbbb2e28764a29028
+  data.tar.gz: 67f7cbcb82a68a099fe659caa47477877ce3e5164f3267903ef6b4191b1103d10f558574e5378967b698b1b07f41184ac4f8291598262db31439332b70389f73

data/lib/pwn/ai/agent/learning.rb

@@ -11,12 +11,14 @@ module PWN
       # PWN::AI::Agent::Learning is the self-improvement engine that closes
       # the pwn-ai feedback loop. It captures task outcomes, mines session
       # transcripts for durable lessons, promotes successful workflows into
-      # reusable skills, and prunes / consolidates persistent memory so the
-      # agent gets sharper over time instead of accumulating noise.
+      # reusable skills, and keeps ~/.pwn lean (memory + learning.jsonl +
+      # mistakes + sessions) so the agent gets sharper over time instead of
+      # accumulating noise.
       #
       # Data flows:
       #   Loop.run --(tool telemetry)--> Metrics.record
       #   Loop.run --(final answer)----> Learning.auto_introspect (opt-in)
+      #     auto_introspect --(throttled)--> Learning.gc_stores!  # ~/.pwn lean
       #   model    --(tool calls)------> learning_note_outcome / _distill_skill
       #   PromptBuilder <----------------- Learning.to_context + Metrics.to_context
       #
@@ -34,6 +36,22 @@ module PWN
         INTROSPECT_MIN_STAGES = %i[judge note_outcome fold_judge sentinel].freeze
 
         MAX_MEMORY_ENTRIES = 200
+        # Lean outcome retention — keep gold RL signal, drop bulk auto noise.
+        MAX_OUTCOME_ROWS = 800
+        OUTCOME_RETAIN_DAYS = 45
+        OUTCOME_RECENT_DAYS = 14
+        OUTCOME_DETAILS_MAX = 800
+        GOLD_MIN_SCORE = 0.6
+        EXEMPLARS_POOL_MIN = 200
+        FAILURE_WINDOW_MIN = 200
+        HIGH_VALUE_TAGS = %w[
+          needs_human extro_verify sdr gqrx rl pwn-ai curriculum hindsight her
+        ].freeze
+        LOW_VALUE_ONLY_TAGS = %w[
+          auto loop partial wrong solved offline_judge plan_cover_high
+        ].freeze
+        PRUNE_EVERY_N_APPENDS = 25
+
         # E3/P26 — only CVE-ids or software-name + full semver (x.y.z).
         # Two-part floats ("cap 0.2", "proxy 1.0", "judge 37.0") are RL
         # metric crumbs that were scraped by verify_as_reward and flooded
@@ -85,7 +103,7 @@ module PWN
             id: Digest::SHA256.hexdigest("#{task}-#{Time.now.to_f}")[0, 12],
             task: task,
             success: success,
-            details: opts[:details].to_s[0, 2_000],
+            details: opts[:details].to_s[0, OUTCOME_DETAILS_MAX],
             session_id: opts[:session_id],
             tags: Array(opts[:tags]).map(&:to_s),
             timestamp: Time.now.utc.iso8601
@@ -93,6 +111,7 @@ module PWN
           entry[:score] = opts[:score].to_f if opts.key?(:score)
           FileUtils.mkdir_p(File.dirname(LEARNING_FILE))
           File.open(LEARNING_FILE, 'a') { |f| f.puts(JSON.generate(entry)) }
+          maybe_prune_outcomes!
 
           # M4 — default: outcomes live in learning.jsonl ONLY.
           # M4.1 — PROCESS SOPs (rubocop/rake/spec after code changes, etc.)
@@ -617,6 +636,20 @@ module PWN
             stages_skipped << :extrospect
           end
 
+          # Keep ~/.pwn RL stores lean on the feedback path (memory +
+          # learning.jsonl + mistakes + sessions). Throttled; never raises.
+          # Disk-only work: skip only hard budget / budget_hot.
+          begin
+            if !over_hard.call && !budget_hot && should_gc_stores?
+              stages_run << :lean_gc
+              gc_stores!(current_session_id: session_id)
+            elsif should_gc_stores?
+              stages_skipped << :lean_gc
+            end
+          rescue StandardError => e
+            warn "[pwn-ai/learning] post-introspect lean swallowed: #{e.class}: #{e.message}"
+          end
+
           {
             ok: ok,
             score: v[:score],
@@ -696,21 +729,44 @@ module PWN
           # confidence :heuristic auto-gen self-evicts first.
           if mem.size > cap
             now = Time.now.utc
-            sorted = mem.sort_by do |_k, v|
+            scored = mem.map do |k, v|
+              if defined?(PWN::Memory) && PWN::Memory.respond_to?(:protected_entry?) &&
+                 PWN::Memory.protected_entry?(key: k, entry: v)
+                next [k, Float::INFINITY]
+              end
+
               age_d = (now - Time.parse(v[:timestamp].to_s)) / 86_400.0
               ttl_d = (v[:ttl].to_f / 86_400.0)
               imp   = (v[:importance] || 0.5).to_f.clamp(0.05, 1.0)
               conf  = (v[:confidence] || (v[:source].to_s == 'human' ? 0.95 : 0.5)).to_f.clamp(0.05, 1.0)
               staleness = ttl_d.positive? ? age_d / ttl_d : age_d / 90.0
-              -(staleness / (imp * conf))
+              # lower score = drop first; Infinity protected sorts last
+              [k, -(staleness / (imp * conf))]
             rescue StandardError
-              0.0
+              [k, 0.0]
+            end
+            # sort ascending by score so lowest (most stale/low-imp) first
+            ordered = scored.sort_by { |_k, s| s }
+            drop = []
+            ordered.each do |pair|
+              k = pair[0]
+              break if mem.size - drop.size <= cap
+              next if defined?(PWN::Memory) && PWN::Memory.respond_to?(:protected_entry?) &&
+                      PWN::Memory.protected_entry?(key: k, entry: mem[k])
+
+              drop << k
             end
-            drop = sorted.first(mem.size - cap).map(&:first)
             drop.each { |k| mem.delete(k) }
             removed.concat(drop)
           end
           PWN::Memory.save(mem: mem, force: mem.empty?)
+          if PWN::Memory.respond_to?(:lean!)
+            begin
+              PWN::Memory.lean!
+            rescue StandardError => e
+              warn "[pwn-ai/learning] post-consolidate memory.lean! swallowed: #{e.class}: #{e.message}"
+            end
+          end
           { removed: removed.uniq.length, remaining: mem.size }
         end
 
@@ -1211,6 +1267,249 @@ module PWN
           values.first[0, 200]
         end
 
+        # Supported Method Parameters::
+        # result = PWN::AI::Agent::Learning.prune_outcomes!(
+        #   dry_run: 'optional - Boolean (default false)',
+        #   max_rows: 'optional - hard cap (default MAX_OUTCOME_ROWS)',
+        #   retain_days: 'optional - age floor for low-value drop',
+        #   recent_days: 'optional - always keep newer than this'
+        # )
+        #
+        # Keep gold RL rows (success+score>=0.6+session_id), recent window,
+        # high-value tags, and near-miss failures. Dedupe by task+success
+        # keeping best score. Truncate details. Never sacrifices exemplar pool.
+
+        public_class_method def self.prune_outcomes!(opts = {})
+          dry = opts[:dry_run] ? true : false
+          max_rows = (opts[:max_rows] || MAX_OUTCOME_ROWS).to_i
+          retain_days = (opts[:retain_days] || OUTCOME_RETAIN_DAYS).to_f
+          recent_days = (opts[:recent_days] || OUTCOME_RECENT_DAYS).to_f
+          details_max = (opts[:details_max] || OUTCOME_DETAILS_MAX).to_i
+          gold_min = (opts[:gold_min_score] || GOLD_MIN_SCORE).to_f
+
+          return { kept: 0, removed: 0, skipped: true } unless File.exist?(LEARNING_FILE)
+
+          before_bytes = File.size(LEARNING_FILE)
+          rows = File.readlines(LEARNING_FILE).map do |l|
+            JSON.parse(l, symbolize_names: true)
+          rescue StandardError
+            nil
+          end.compact
+
+          now = Time.now.utc
+          age_days = lambda do |r|
+            (now - Time.parse(r[:timestamp].to_s)) / 86_400.0
+          rescue StandardError
+            999.0
+          end
+
+          protected_row = lambda do |r|
+            tags = Array(r[:tags]).map(&:to_s)
+            a = age_days.call(r)
+            return true if a <= recent_days
+            return true if r[:success] == true && r.key?(:score) && r[:score].to_f >= gold_min && r[:session_id].to_s != ''
+            return true if r[:success] == true && !r.key?(:score) && r[:session_id].to_s != '' && a <= retain_days
+            return true if tags.intersect?(HIGH_VALUE_TAGS)
+            return true if r[:success] == false && r.key?(:score) && r[:score].to_f >= 0.5
+
+            false
+          end
+
+          rows.reject! { |r| r[:task].to_s.strip.empty? }
+
+          best = {}
+          rows.each do |r|
+            key = [r[:task].to_s.strip.downcase.gsub(/\s+/, ' ')[0, 160], r[:success].to_s]
+            prev = best[key]
+            if prev.nil?
+              best[key] = r
+            else
+              ps = prev.key?(:score) ? prev[:score].to_f : -1.0
+              rs = r.key?(:score) ? r[:score].to_f : -1.0
+              better = rs > ps || (rs == ps && r[:timestamp].to_s > prev[:timestamp].to_s)
+              better ||= protected_row.call(r) && !protected_row.call(prev)
+              best[key] = r if better
+            end
+          end
+          deduped = best.values
+          removed_dupes = rows.size - deduped.size
+
+          truncated = 0
+          deduped.each do |r|
+            d = r[:details].to_s
+            next if d.bytesize <= details_max
+
+            r[:details] = "#{d[0, details_max]}…[compacted]"
+            truncated += 1
+          end
+
+          protected, unprotected = deduped.partition { |r| protected_row.call(r) }
+
+          kept_unprot = unprotected.reject do |r|
+            a = age_days.call(r)
+            tags = Array(r[:tags]).map(&:to_s)
+            score = r.key?(:score) ? r[:score].to_f : 1.0
+            noise_tags = (tags - LOW_VALUE_ONLY_TAGS).empty? && tags.any?
+            a > retain_days && noise_tags && score < 0.4
+          end
+
+          gold = (protected + kept_unprot).select do |r|
+            r[:success] == true && r[:session_id].to_s != '' &&
+              (!r.key?(:score) || r[:score].to_f >= gold_min)
+          end
+          if gold.size < EXEMPLARS_POOL_MIN
+            need = EXEMPLARS_POOL_MIN - gold.size
+            extra = unprotected.select { |r| r[:success] == true && r[:session_id].to_s != '' }
+                               .sort_by { |r| r[:timestamp].to_s }
+                               .last(need)
+            kept_unprot = (kept_unprot + extra).uniq
+          end
+
+          fails = (protected + kept_unprot).reject { |r| r[:success] == true }
+          if fails.size < FAILURE_WINDOW_MIN
+            need = FAILURE_WINDOW_MIN - fails.size
+            extra = unprotected.reject { |r| r[:success] == true }
+                               .sort_by { |r| r[:timestamp].to_s }
+                               .last(need)
+            kept_unprot = (kept_unprot + extra).uniq
+          end
+
+          kept = (protected + kept_unprot).uniq
+          if kept.size > max_rows
+            prot_ids = protected.map { |r| r[:id] }.compact
+            over = kept.size - max_rows
+            victims = kept.reject { |r| prot_ids.include?(r[:id]) }
+                          .sort_by { |r| r[:timestamp].to_s }
+                          .first(over)
+            v_ids = victims.map { |r| r[:id] }
+            kept = kept.reject { |r| v_ids.include?(r[:id]) }
+          end
+
+          kept = kept.sort_by { |r| r[:timestamp].to_s }
+
+          atomic_jsonl_write(path: LEARNING_FILE, rows: kept) unless dry
+
+          {
+            kept: kept.size,
+            removed: (rows.size - kept.size) + removed_dupes,
+            deduped: removed_dupes,
+            truncated_details: truncated,
+            protected: protected.size,
+            bytes_before: before_bytes,
+            bytes_after: if dry
+                           before_bytes
+                         else
+                           (File.exist?(LEARNING_FILE) ? File.size(LEARNING_FILE) : 0)
+                         end,
+            dry_run: dry
+          }
+        end
+
+        # Memory lean + outcome prune.
+        public_class_method def self.lean!(opts = {})
+          dry = opts[:dry_run] ? true : false
+          out = { dry_run: dry }
+          out[:memory] = if defined?(PWN::Memory) && PWN::Memory.respond_to?(:lean!)
+                           PWN::Memory.lean!(dry_run: dry)
+                         else
+                           { skipped: true }
+                         end
+          out[:memory_consolidate] = consolidate(max_entries: opts[:max_entries] || MAX_MEMORY_ENTRIES) unless dry
+          out[:learning] = prune_outcomes!(
+            dry_run: dry,
+            max_rows: opts[:max_rows],
+            retain_days: opts[:retain_days],
+            recent_days: opts[:recent_days],
+            details_max: opts[:details_max],
+            gold_min_score: opts[:gold_min_score]
+          )
+          out
+        end
+
+        # One-shot lean across memory + learning + mistakes + sessions.
+        # Called from auto_introspect (throttled) so the RL feedback loop
+        # keeps ~/.pwn high-signal without a manual learning_gc_stores turn.
+        # Supported Method Parameters::
+        #   result = PWN::AI::Agent::Learning.gc_stores!(
+        #     dry_run: 'optional - Boolean (default false)',
+        #     current_session_id: 'optional - never delete this sessions id',
+        #     max_entries: 'optional - Memory consolidate cap',
+        #     max_rows: 'optional - learning.jsonl cap',
+        #     retain_days: 'optional - outcome / session age floor'
+        #   )
+        public_class_method def self.gc_stores!(opts = {})
+          dry = opts[:dry_run] ? true : false
+          res = lean!(
+            dry_run: dry,
+            max_entries: opts[:max_entries],
+            max_rows: opts[:max_rows],
+            retain_days: opts[:retain_days],
+            recent_days: opts[:recent_days],
+            details_max: opts[:details_max],
+            gold_min_score: opts[:gold_min_score]
+          )
+          res[:mistakes] = if defined?(Mistakes) && Mistakes.respond_to?(:lean!)
+                             Mistakes.lean!(dry_run: dry)
+                           else
+                             { skipped: true }
+                           end
+          res[:sessions] = if defined?(PWN::Sessions) && PWN::Sessions.respond_to?(:lean!)
+                             sess_opts = { dry_run: dry }
+                             sid = opts[:current_session_id].to_s
+                             sess_opts[:current_session_id] = sid unless sid.empty?
+                             sess_opts[:retain_days] = opts[:retain_days] if opts.key?(:retain_days)
+                             sess_opts[:max_files] = opts[:max_files] if opts.key?(:max_files)
+                             PWN::Sessions.lean!(**sess_opts)
+                           else
+                             { skipped: true }
+                           end
+          res
+        end
+
+        # True every PRUNE_EVERY_N_APPENDS rows, or once learning.jsonl
+        # exceeds MAX_OUTCOME_ROWS (forces lean even if modulo miss).
+        private_class_method def self.should_gc_stores?
+          return true unless File.exist?(LEARNING_FILE)
+
+          lines = File.foreach(LEARNING_FILE).count
+          return true if lines >= MAX_OUTCOME_ROWS
+          return true if lines.positive? && (lines % PRUNE_EVERY_N_APPENDS).zero?
+
+          false
+        rescue StandardError
+          false
+        end
+
+        private_class_method def self.maybe_prune_outcomes!
+          return unless File.exist?(LEARNING_FILE)
+
+          lines = File.foreach(LEARNING_FILE).count
+          return if lines < MAX_OUTCOME_ROWS && (lines % PRUNE_EVERY_N_APPENDS != 0)
+
+          prune_outcomes!
+        rescue StandardError => e
+          warn "[pwn-ai/learning] maybe_prune_outcomes! swallowed: #{e.class}: #{e.message}"
+        end
+
+        private_class_method def self.atomic_jsonl_write(opts = {})
+          path = opts[:path]
+          rows = Array(opts[:rows])
+          dir = File.dirname(path)
+          FileUtils.mkdir_p(dir)
+          bak = "#{path}.bak-lean-#{Time.now.utc.strftime('%Y%m%d')}"
+          FileUtils.cp(path, bak) if File.exist?(path) && !File.exist?(bak)
+          tmp = File.join(dir, ".#{File.basename(path)}.#{Process.pid}.tmp")
+          File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o644) do |f|
+            f.flock(File::LOCK_EX)
+            rows.each { |r| f.puts(JSON.generate(r)) }
+            f.flush
+            f.fsync
+          end
+          File.rename(tmp, path)
+        ensure
+          FileUtils.rm_f(tmp) if defined?(tmp) && tmp && File.exist?(tmp)
+        end
+
         # Supported Method Parameters::
         # PWN::AI::Agent::Learning.purge_noise
         #
@@ -1264,6 +1563,9 @@ module PWN
               PWN::AI::Agent::Learning.exemplars_for(request: 'nmap sweep 10/8')  # few-shot for Loop.run
               PWN::AI::Agent::Learning.export_finetune(format: :sharegpt)        # -> ~/.pwn/finetune/*.jsonl
               PWN::AI::Agent::Learning.consolidate(max_entries: 200)         # M1 semantic-merge + M3 importance-evict
+              PWN::AI::Agent::Learning.lean!                                 # memory + learning.jsonl prune
+              PWN::AI::Agent::Learning.gc_stores!                            # full ~/.pwn RL lean (mem/learn/mistakes/sessions)
+              PWN::AI::Agent::Learning.prune_outcomes!                       # learning.jsonl gold-keep cap
               PWN::AI::Agent::Learning.purge_noise                            # one-shot GC of pre-R1 garbage lessons
               PWN::AI::Agent::Learning.to_context(limit: 5)                  # injected by PromptBuilder
               PWN::AI::Agent::Learning.stats
@@ -1271,6 +1573,8 @@ module PWN
 
               Enable end-of-run auto-learning with:
                 PWN::Env[:ai][:agent][:auto_introspect] = true
+              # auto_introspect throttles gc_stores! every PRUNE_EVERY_N_APPENDS
+              # outcomes so ~/.pwn stays lean without a manual GC turn.
 
               #{self}.authors
           USAGE

data/lib/pwn/ai/agent/loop.rb

@@ -172,6 +172,9 @@ module PWN
 
         # P17 — evidence-enough early final: latest tool rounds already answer
         # the ask → force synthesis instead of burning iters into text-only tail.
+        # Must NOT fire on routine tool JSON {"success":true} while a multi-step
+        # English plan still has open tasks — that blocks legitimate completion
+        # (mid-fix "write the complete final answer now" thrash).
         private_class_method def self.evidence_enough_to_finalize?(opts = {})
           messages = Array(opts[:messages])
           turn_fails = opts[:turn_fails] || {}
@@ -186,10 +189,23 @@ module PWN
           fail_n = turn_fails.values.sum
           return false if fail_n >= 3
 
+          # English-task gate: multi-step plans only early-final on/after the
+          # last tangible task. plan_idx is 0-based; open work => not enough.
+          ts_state = opts[:ts_state]
+          if ts_state.is_a?(Hash)
+            plan = Array(ts_state[:plan])
+            if plan.length >= 2
+              idx = ts_state[:plan_idx].to_i
+              return false if idx < (plan.length - 1)
+            end
+          end
+
           tools_ok = messages.select { |msg| msg[:role].to_s == 'tool' }
           return false if tools_ok.size < 2
 
           # Last two tool payloads should look like successful evidence, not errors.
+          # Agent tool wrappers always emit "success":true on ok — that alone is
+          # NOT proof the user goal is done (do not match bare success JSON).
           last2 = tools_ok.last(2)
           return false if last2.any? do |msg|
             content = msg[:content].to_s
@@ -203,11 +219,14 @@ module PWN
           deep_enough = tools_ok.size >= 3 || (short_plan && tools_ok.size >= plan_steps)
           return false unless deep_enough
 
-          # Request looks satisfied if tool names/content echo key nouns from request
-          # OR we clearly completed a mutation (write/patch/resolve) successfully.
           recent_txt = last2.map { |msg| msg[:content].to_s[0, 500] }.join(' ')
-          return true if recent_txt.match?(/"success"\s*:\s*true|syntax ok|wrote |patched|resolved|File\.write|ruby -c/i)
-          return true if short_plan && tools_ok.size >= plan_steps && fail_n.zero?
+          # Goal-shaped completion only — write/patch/verify, not shell success wrappers.
+          mutation_done = recent_txt.match?(
+            /syntax ok|wrote |patched|resolved|File\.write|ruby -c|0 offenses|examples?,\s*0 failures/i
+          )
+          return true if mutation_done
+          return true if short_plan && tools_ok.size >= plan_steps && fail_n.zero? &&
+                         request.match?(/\b(what|who|when|where|which|how many|status|list|show|print|uname|cwd|version)\b/i)
 
           false
         rescue StandardError
@@ -1072,7 +1091,8 @@ module PWN
               i: i,
               max_iters: max_iters,
               request: request,
-              plan_steps: plan_steps
+              plan_steps: plan_steps,
+              ts_state: ts_state
             ) && turn_fails['evidence_final'].to_i < 1
               turn_fails['evidence_final'] += 1
               messages << {

data/lib/pwn/ai/agent/mistakes.rb

@@ -35,6 +35,14 @@ module PWN
       module Mistakes
         MISTAKES_FILE    = File.join(Dir.home, '.pwn', 'mistakes.json')
         REPEAT_THRESHOLD = 3
+        # Lean retention for mistakes.json
+        SAMPLE_ARGS_MAX = 160
+        SNIPPET_MAX = 160
+        ERROR_MAX = 300
+        SESSIONS_KEEP = 3
+        MAX_RESOLVED_KEPT = 80
+        RESOLVED_MIN_AGE_DAYS = 21
+        FIX_MAX = 500
 
         CORRECTION_RX = /
           \b(
@@ -169,8 +177,8 @@ module PWN
           norm  = normalize_error(error: error)
 
           m = store[key] ||= {
-            signature: sig, tool: tool, error: norm,
-            snippet: error.to_s.strip[0, 300],
+            signature: sig, tool: tool, error: norm.to_s[0, ERROR_MAX],
+            snippet: error.to_s.strip[0, SNIPPET_MAX],
             count: 0, drift_count: 0, first_seen: now, sessions: [],
             resolved: false, fix: nil, source: (opts[:source] || :tool).to_s
           }
@@ -186,9 +194,10 @@ module PWN
             m[:count] += 1
           end
           m[:last_seen]    = now
-          m[:snippet]      = error.to_s.strip[0, 300]
-          m[:sample_args]  = opts[:args].to_s[0, 200] if opts[:args]
-          m[:sessions]     = (Array(m[:sessions]) + [opts[:session_id]]).compact.uniq.last(10)
+          m[:error]        = norm.to_s[0, ERROR_MAX]
+          m[:snippet]      = error.to_s.strip[0, SNIPPET_MAX]
+          m[:sample_args]  = opts[:args].to_s[0, SAMPLE_ARGS_MAX] if opts[:args]
+          m[:sessions]     = (Array(m[:sessions]) + [opts[:session_id]]).compact.uniq.last(SESSIONS_KEEP)
           # 2.2 — recoverable shape for repair routing
           if opts[:shape]
             m[:shape] = opts[:shape].to_s
@@ -229,7 +238,7 @@ module PWN
 
           store[key][:resolved]    = true
           store[key][:regressed]   = false
-          store[key][:fix]         = fix.strip[0, 500]
+          store[key][:fix]         = fix.strip[0, FIX_MAX]
           store[key][:resolved_at] = Time.now.utc.iso8601
           # 2.3 — structured fix payload (strategy/tool/args_template/holdouts).
           # Prose-only resolve is why shell sigs regressed after auto-curriculum.
@@ -473,6 +482,115 @@ module PWN
           nil
         end
 
+        # Supported Method Parameters::
+        # result = PWN::AI::Agent::Mistakes.lean!(
+        #   dry_run: 'optional - Boolean (default false)',
+        #   max_resolved_kept: 'optional - cap on resolved-with-fix records',
+        #   resolved_min_age_days: 'optional - age before resolved count=1 may drop'
+        # )
+        #
+        # Compact text fields on every record. Never drops unresolved,
+        # regressed, or high-count repeaters. Aged resolved-once fixes may
+        # drop after Memory already holds mistake_fix_<sig>.
+
+        public_class_method def self.lean!(opts = {})
+          dry = opts[:dry_run] ? true : false
+          max_resolved = (opts[:max_resolved_kept] || MAX_RESOLVED_KEPT).to_i
+          min_age = (opts[:resolved_min_age_days] || RESOLVED_MIN_AGE_DAYS).to_f
+          store = load
+          before_bytes = File.exist?(MISTAKES_FILE) ? File.size(MISTAKES_FILE) : 0
+          now = Time.now.utc
+          compacted = 0
+          dropped = []
+
+          store.each_value do |m|
+            before = begin
+              m.to_json.bytesize
+            rescue StandardError
+              0
+            end
+            m[:sample_args] = m[:sample_args].to_s[0, SAMPLE_ARGS_MAX] if m[:sample_args].to_s.bytesize > SAMPLE_ARGS_MAX
+            m[:snippet] = m[:snippet].to_s[0, SNIPPET_MAX] if m[:snippet].to_s.bytesize > SNIPPET_MAX
+            m[:error] = m[:error].to_s[0, ERROR_MAX] if m[:error].to_s.bytesize > ERROR_MAX
+            m[:sessions] = Array(m[:sessions]).compact.uniq.last(SESSIONS_KEEP)
+            after = begin
+              m.to_json.bytesize
+            rescue StandardError
+              before
+            end
+            compacted += 1 if after < before
+          end
+
+          age_days = lambda do |m|
+            t = m[:resolved_at] || m[:last_seen]
+            (now - Time.parse(t.to_s)) / 86_400.0
+          rescue StandardError
+            0.0
+          end
+
+          protected_m = lambda do |m|
+            return true unless m[:resolved]
+            return true if m[:regressed]
+            return true if effective_count(mistake: m) >= REPEAT_THRESHOLD
+            return true if m[:count].to_i >= 2 && m[:fix].to_s.strip != ''
+            return true if m[:fix].to_s.strip != '' && age_days.call(m) < min_age
+
+            false
+          end
+
+          # Drop aged resolved-once when fix lives in Memory or past age
+          store.each do |sig, m|
+            next if protected_m.call(m)
+            next unless m[:resolved] && m[:fix].to_s.strip != '' && m[:count].to_i <= 1
+            next unless age_days.call(m) >= min_age
+
+            mem_has = false
+            if defined?(PWN::Memory)
+              begin
+                mem_has = PWN::Memory.load.key?(:"mistake_fix_#{sig}")
+              rescue StandardError
+                mem_has = false
+              end
+            end
+            # Drop when Memory has the fix OR age is well past (2× min) even without mem key
+            dropped << sig.to_s if mem_has || age_days.call(m) >= (min_age * 2)
+          end
+
+          dropped.each { |s| store.delete(s.to_sym) } unless dry
+
+          # Cap resolved-with-fix by oldest resolved_at
+          resolved = store.select { |_s, m| m[:resolved] && m[:fix].to_s.strip != '' }
+          if resolved.size > max_resolved
+            excess = resolved.sort_by { |_s, m| m[:resolved_at].to_s }
+                             .first(resolved.size - max_resolved)
+            excess.each do |sig, m|
+              next if m[:regressed] || m[:count].to_i >= 2
+              next if effective_count(mistake: m) >= REPEAT_THRESHOLD
+
+              dropped << sig.to_s
+              store.delete(sig) unless dry
+            end
+          end
+
+          save(store: store) unless dry
+
+          open_n = store.values.count { |m| !m[:resolved] }
+          {
+            compacted_fields: compacted,
+            dropped: dropped.uniq.length,
+            dropped_sigs: dropped.uniq.first(20),
+            remaining: store.size,
+            unresolved: open_n,
+            bytes_before: before_bytes,
+            bytes_after: if dry
+                           before_bytes
+                         else
+                           (File.exist?(MISTAKES_FILE) ? File.size(MISTAKES_FILE) : 0)
+                         end,
+            dry_run: dry
+          }
+        end
+
         # Supported Method Parameters::
         # PWN::AI::Agent::Mistakes.reset
 

data/lib/pwn/ai/agent/tools/learning.rb

@@ -219,3 +219,25 @@ PWN::AI::Agent::Registry.register(
     { previous: prev, current: ai[:agent][:auto_introspect] ? true : false }
   }
 )
+
+PWN::AI::Agent::Registry.register(
+  name: 'learning_gc_stores',
+  toolset: 'learning',
+  schema: {
+    name: 'learning_gc_stores',
+    description: 'Lean-keep ~/.pwn RL stores (memory, learning.jsonl, mistakes.json, ' \
+                 'sessions/) without dropping gold outcomes, open mistakes, prefs/SOPs, ' \
+                 'or reference-pinned session transcripts. dry_run:true plans only.',
+    parameters: {
+      type: 'object',
+      properties: {
+        dry_run: { type: 'boolean', default: false, description: 'Report only; do not rewrite.' }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Learning) && PWN::AI::Agent::Learning.respond_to?(:gc_stores!) },
+  handler: lambda { |args|
+    PWN::AI::Agent::Learning.gc_stores!(dry_run: args[:dry_run] ? true : false)
+  }
+)