pwn 0.5.663 → 0.5.665

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)
+  }
+)

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

@@ -60,16 +60,19 @@ PWN::AI::Agent::Registry.register(
   toolset: 'memory',
   schema: {
     name: 'memory_forget',
-    description: 'Delete a persistent memory entry by key.',
+    description: 'Delete a persistent memory entry by key. Protected keys (operator_pref_*, process_sop_*, mistake_fix_*, memory_*, category preference) require force:true.',
     parameters: {
       type: 'object',
-      properties: { key: { type: 'string' } },
+      properties: {
+        key: { type: 'string' },
+        force: { type: 'boolean', description: 'Bypass protect policy (default false).' }
+      },
       required: %w[key]
     }
   },
   check: -> { defined?(PWN::Memory) },
   handler: lambda { |args|
-    PWN::Memory.forget(key: args[:key].to_s.to_sym)
+    PWN::Memory.forget(key: args[:key].to_s.to_sym, force: args[:force] == true)
     { forgotten: args[:key] }
   }
 )
@@ -96,7 +99,29 @@ PWN::AI::Agent::Registry.register(
     raise ArgumentError, 'refusing to clear memory without confirm:true' unless args[:confirm] == true
 
     before = PWN::Memory.load.keys.length
-    PWN::Memory.clear
+    PWN::Memory.clear(force: true)
     { cleared: true, entries_removed: before, file: PWN::Memory::MEMORY_FILE }
   }
 )
+
+PWN::AI::Agent::Registry.register(
+  name: 'memory_lean',
+  toolset: 'memory',
+  schema: {
+    name: 'memory_lean',
+    description: 'Drop expired ephemeral session_* memory keys and truncate overlong ' \
+                 'values. Never removes operator prefs, process SOPs, or mistake_fix_* ' \
+                 'lessons. dry_run:true plans only.',
+    parameters: {
+      type: 'object',
+      properties: {
+        dry_run: { type: 'boolean', default: false }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::Memory) && PWN::Memory.respond_to?(:lean!) },
+  handler: lambda { |args|
+    PWN::Memory.lean!(dry_run: args[:dry_run] ? true : false)
+  }
+)

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

@@ -104,6 +104,28 @@ PWN::AI::Agent::Registry.register(
   }
 )
 
+PWN::AI::Agent::Registry.register(
+  name: 'mistakes_lean',
+  toolset: 'learning',
+  schema: {
+    name: 'mistakes_lean',
+    description: 'Compact mistakes.json fields and age-out resolved-once signatures ' \
+                 'after fixes live in Memory. Never drops unresolved or regressed. ' \
+                 'dry_run:true plans only.',
+    parameters: {
+      type: 'object',
+      properties: {
+        dry_run: { type: 'boolean', default: false }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Mistakes) && PWN::AI::Agent::Mistakes.respond_to?(:lean!) },
+  handler: lambda { |args|
+    PWN::AI::Agent::Mistakes.lean!(dry_run: args[:dry_run] ? true : false)
+  }
+)
+
 PWN::AI::Agent::Registry.register(
   name: 'mistakes_reset',
   toolset: 'learning',

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

@@ -80,7 +80,11 @@ PWN::AI::Agent::Registry.register(
     parameters: {
       type: 'object',
       properties: {
-        session_id: { type: 'string' }
+        session_id: { type: 'string' },
+        force: {
+          type: 'boolean',
+          description: 'Bypass pin policy for hot/gold/mistake sessions (default false).'
+        }
       },
       required: %w[session_id]
     }
@@ -90,7 +94,10 @@ PWN::AI::Agent::Registry.register(
     sid = args[:session_id].to_s
     raise ArgumentError, 'session_id is required' if sid.empty?
 
-    { session_id: sid, deleted: PWN::Sessions.delete(session_id: sid) }
+    {
+      session_id: sid,
+      deleted: PWN::Sessions.delete(session_id: sid, force: args[:force] == true)
+    }
   }
 )
 
@@ -137,3 +144,31 @@ PWN::AI::Agent::Registry.register(
     }
   }
 )
+
+PWN::AI::Agent::Registry.register(
+  name: 'sessions_lean',
+  toolset: 'sessions',
+  schema: {
+    name: 'sessions_lean',
+    description: 'Prune/compact ~/.pwn/sessions: delete stubs and unreferenced aged ' \
+                 'transcripts; compact oversized tool/assistant content. Pins gold ' \
+                 'learning outcomes and open-mistake session refs. dry_run:true plans only.',
+    parameters: {
+      type: 'object',
+      properties: {
+        dry_run: { type: 'boolean', default: false },
+        retain_days: { type: 'integer', default: 30 },
+        max_files: { type: 'integer', default: 400 }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::Sessions) && PWN::Sessions.respond_to?(:lean!) },
+  handler: lambda { |args|
+    PWN::Sessions.lean!(
+      dry_run: args[:dry_run] ? true : false,
+      retain_days: args[:retain_days],
+      max_files: args[:max_files]
+    )
+  }
+)

data/lib/pwn/memory.rb

@@ -15,6 +15,12 @@ module PWN
   # via ruby code blocks during execution loops.
   module Memory
     MEMORY_FILE = File.join(Dir.home, '.pwn', 'memory.json')
+    # Lean retention — keep RL-quality signal, drop ephemeral bulk.
+    VALUE_MAX_CHARS = 2_000
+    PROTECT_KEY_PREFIXES = %w[operator_pref_ process_sop_ mistake_fix_ memory_].freeze
+    PROTECT_CATEGORIES = %i[preference].freeze
+    EPHEMERAL_KEY_PREFIXES = %w[session_].freeze
+    EPHEMERAL_TTL_SECS = 7 * 86_400
 
     # Supported Method Parameters::
     #   memory = PWN::Memory.load
@@ -51,7 +57,7 @@ module PWN
         warn "[pwn-ai/memory] refusing empty overwrite of #{File.size(path)}B #{path} (pass force:true to clear)"
         return load_raw_or_empty(path: path)
       end
-      tmp  = File.join(File.dirname(path), ".#{File.basename(path)}.#{Process.pid}.tmp")
+      tmp = File.join(File.dirname(path), ".#{File.basename(path)}.#{Process.pid}.tmp")
       body = JSON.pretty_generate(mem)
       File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o644) do |f|
         f.flock(File::LOCK_EX)
@@ -93,8 +99,10 @@ module PWN
       raise 'ERROR: key and value are required' if key.nil? || value.nil?
 
       mem = load
+      val = value.is_a?(String) ? value.to_s : value
+      val = "#{val.to_s[0, VALUE_MAX_CHARS]}…[compacted]" if val.is_a?(String) && val.bytesize > VALUE_MAX_CHARS
       entry = {
-        value: value,
+        value: val,
         category: category.to_sym,
         timestamp: Time.now.utc.iso8601,
         # M3 — provenance & scoring so Learning.consolidate evicts by
@@ -147,10 +155,20 @@ module PWN
     end
 
     # Supported Method Parameters::
-    #   PWN::Memory.forget(key: :some_key)
+    #   PWN::Memory.forget(
+    #     key: :some_key,
+    #     force: 'optional - Boolean bypass protect policy (default false)'
+    #   )
+    # Refuses PROTECT_KEY_PREFIXES / PROTECT_CATEGORIES unless force:true.
     public_class_method def self.forget(opts = {}) # rubocop:disable Naming/PredicateMethod
       key = opts[:key]
+      raise 'ERROR: key is required' if key.nil?
+
+      force = opts[:force] ? true : false
       mem = load
+      entry = mem[key.to_sym]
+      raise "ERROR: refusing to forget protected memory key #{key.inspect} (matches PROTECT_KEY_PREFIXES/PROTECT_CATEGORIES; pass force:true)" if entry && protected_entry?(key: key, entry: entry) && !force
+
       mem.delete(key.to_sym)
       # Last-key delete legitimately yields {}; force so empty-guard does not revive it.
       save(mem: mem, force: mem.empty?)
@@ -158,8 +176,16 @@ module PWN
     end
 
     # Supported Method Parameters::
-    #   PWN::Memory.clear
-    public_class_method def self.clear
+    #   PWN::Memory.clear(force: true)
+    # Requires force:true — protected prefs/SOPs must not vanish via bare clear.
+    public_class_method def self.clear(opts = {})
+      force = if opts.is_a?(Hash)
+                opts[:force] ? true : false
+              else
+                false
+              end
+      raise 'ERROR: refusing Memory.clear without force:true (would drop PROTECT_KEY_PREFIXES/PROTECT_CATEGORIES)' unless force
+
       FileUtils.rm_f(MEMORY_FILE)
       save(mem: {}, force: true) # recreate empty file atomically
       {}
@@ -180,6 +206,77 @@ module PWN
       ctx
     end
 
+    # True when a memory key must survive cap eviction / age GC.
+    public_class_method def self.protected_entry?(opts = {})
+      key = opts[:key].to_s
+      entry = opts[:entry] || {}
+      return true if PROTECT_KEY_PREFIXES.any? { |p| key.start_with?(p) }
+      return true if PROTECT_CATEGORIES.map(&:to_s).include?(entry[:category].to_s)
+
+      false
+    end
+
+    # Supported Method Parameters::
+    #   result = PWN::Memory.lean!(
+    #     dry_run: 'optional - Boolean plan only (default false)',
+    #     value_max_chars: 'optional - truncate values (default VALUE_MAX_CHARS)',
+    #     ephemeral_ttl_secs: 'optional - drop expired session_* keys'
+    #   )
+    #
+    # Compact overlong values and drop expired ephemeral session_* keys.
+    # Never removes protected prefs/SOPs/fix lessons. Safe with empty-save guard.
+    public_class_method def self.lean!(opts = {})
+      dry = opts[:dry_run] ? true : false
+      vmax = (opts[:value_max_chars] || VALUE_MAX_CHARS).to_i
+      ttl_secs = (opts[:ephemeral_ttl_secs] || EPHEMERAL_TTL_SECS).to_i
+      mem = load
+      before_bytes = File.exist?(MEMORY_FILE) ? File.size(MEMORY_FILE) : 0
+      removed = []
+      truncated = []
+      now = Time.now.utc
+
+      mem.each do |k, v|
+        key = k.to_s
+        next if protected_entry?(key: key, entry: v)
+
+        if EPHEMERAL_KEY_PREFIXES.any? { |p| key.start_with?(p) }
+          age = begin
+            now - Time.parse(v[:timestamp].to_s)
+          rescue StandardError
+            ttl_secs + 1
+          end
+          exp = v[:ttl].to_i.positive? ? v[:ttl].to_i : ttl_secs
+          if age > exp
+            removed << key
+            next
+          end
+        end
+
+        next unless v[:value].is_a?(String) && v[:value].to_s.bytesize > vmax
+
+        truncated << key
+        v[:value] = "#{v[:value].to_s[0, vmax]}…[compacted]" unless dry
+      end
+
+      removed.each { |k| mem.delete(k.to_sym) } unless dry
+      save(mem: mem, force: mem.empty?) unless dry || (removed.empty? && truncated.empty?)
+
+      {
+        removed: removed.length,
+        truncated: truncated.length,
+        remaining: mem.size,
+        removed_keys: removed.first(20),
+        truncated_keys: truncated.first(20),
+        bytes_before: before_bytes,
+        bytes_after: if dry
+                       before_bytes
+                     else
+                       (File.exist?(MEMORY_FILE) ? File.size(MEMORY_FILE) : 0)
+                     end,
+        dry_run: dry
+      }
+    end
+
     # Author(s):: 0day Inc. <support@0dayinc.com>
 
     public_class_method def self.authors
@@ -195,8 +292,10 @@ module PWN
           facts = PWN::Memory.recall(query: 'recon', category: :fact, limit: 10)
           hits  = PWN::Memory.recall_semantic(query: 'recon', limit: 6)  # embedding-ranked
           PWN::Memory.forget(key: :some_key)
-          PWN::Memory.clear
+          PWN::Memory.forget(key: :operator_pref_x) rescue puts('protected')
+          PWN::Memory.clear(force: true)
           context_str = PWN::Memory.to_context
+          PWN::Memory.lean!(dry_run: true)  # drop expired session_* + truncate values
 
           #{self}.authors
       USAGE

data/lib/pwn/plugins/repl.rb

@@ -472,7 +472,7 @@ module PWN
               PWN::Memory.forget(key: args[1])
               puts "Forgot #{args[1]}"
             when 'clear'
-              PWN::Memory.clear
+              PWN::Memory.clear(force: true)
               puts 'Memory cleared'
             else
               puts PWN::Memory.help
@@ -493,7 +493,7 @@ module PWN
               hist = PWN::Sessions.to_response_history(session_id: sid)
               puts "Loaded session #{sid} with #{hist[:choices].size} entries (set manually into response_history if needed)"
             when 'delete'
-              PWN::Sessions.delete(session_id: args[1])
+              PWN::Sessions.delete(session_id: args[1], force: true)
               puts "Deleted #{args[1]}"
             when 'stats'
               puts PWN::Sessions.stats