lex-agentic-memory 0.1.23 → 0.1.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a795b1799756184a81da06e46f2958513f404882292040cb7ebd7d35005d93be
-  data.tar.gz: 709c8605a2e70964e91a1a143a89d5469d243a92bd54ad6a47d48b500f4d3a09
+  metadata.gz: 2c09e54494e00502435e318cabbdfda9c2f8bf8579a174caf9197d254ae05b3d
+  data.tar.gz: 113d1291eaade383a408a053b22bf0c872341e43b177cc2811b36b67029fde5e
 SHA512:
-  metadata.gz: 00c7573a851ec910a6380c7c0723a3aaa684710d5b7fdda2e2d7123c8439ef634d356030b0a11a8e3827b00b6fdc6c622fbc215206bbf35c3671e6f74f8a6f92
-  data.tar.gz: 8299132b32423db960b554fadaf63439050de19c76f86767b6555cba014b3e92339e8aebab70abccbfb937c749838a147dcf9df49ba30f7d94b3d19293709be7
+  metadata.gz: ba8dd2da72d04f871bfe0bf403563226a29b2f920bbeee6423b1ef49da4b1db18f7283e579f57bbbe0846c08130a9981bd110eae202f2c67433b234ebed5788f
+  data.tar.gz: 7923d43a3447710da47c43f82a2d660b94138d43b0074299d438e7a9ebbc39c5f4b23bab1dc219c923a64519dbb37f8581d083105a1b9a6ddc7970db14089fad

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [Unreleased]
+
+### Fixed
+- fix retrieve_ranked to return Hash with traces key instead of bare Array for GAIA phase wiring
+- add respond_to? guards in Quota#enforce! for store methods not present on all backends
+- add lazy default_engine initialization in CognitiveImmuneMemory runner
+
+## [0.1.24] - 2026-04-03
+
+### Fixed
+- Wrap `save_to_local` persist in a single SQLite transaction — 32K individual lock acquisitions become 1
+- Use `insert_conflict(:replace)` instead of SELECT-then-INSERT/UPDATE per trace
+
 ## [0.1.23] - 2026-04-03
 
 ### Fixed

data/lib/legion/extensions/agentic/memory/immune_memory/runners/cognitive_immune_memory.rb

@@ -10,7 +10,7 @@ module Legion
               include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
 
               def create_memory_cell(threat_type:, signature:, cell_type: :b_memory, strength: nil, engine: nil, **)
-                eng = engine || @default_engine
+                eng = engine || default_engine
                 cell = eng.create_memory_cell(threat_type: threat_type, signature: signature,
                                               cell_type: cell_type,
                                               strength: strength || Helpers::Constants::VACCINATION_STRENGTH)
@@ -18,55 +18,61 @@ module Legion
               end
 
               def vaccinate(threat_type:, signature:, strength: nil, engine: nil, **)
-                eng = engine || @default_engine
+                eng = engine || default_engine
                 cell = eng.vaccinate(threat_type: threat_type, signature: signature,
                                      strength: strength || Helpers::Constants::VACCINATION_STRENGTH)
                 { success: true, cell: cell.to_h }
               end
 
               def encounter_threat(threat_type:, threat_signature:, severity: 0.5, engine: nil, **)
-                eng = engine || @default_engine
+                eng = engine || default_engine
                 record = eng.encounter_threat(threat_type: threat_type, threat_signature: threat_signature,
                                               severity: severity)
                 { success: true, encounter: record.to_h }
               end
 
               def decay_all(engine: nil, **)
-                eng = engine || @default_engine
+                eng = engine || default_engine
                 result = eng.decay_all!
                 { success: true, **result }
               end
 
               def immunity_for(threat_type:, engine: nil, **)
-                eng = engine || @default_engine
+                eng = engine || default_engine
                 immunity = eng.immunity_for(threat_type: threat_type)
                 label = Helpers::Constants.label_for(Helpers::Constants::IMMUNITY_LABELS, immunity)
                 { success: true, threat_type: threat_type, immunity: immunity, label: label }
               end
 
               def active_cells(engine: nil, **)
-                eng = engine || @default_engine
+                eng = engine || default_engine
                 cells = eng.active_cells
                 { success: true, count: cells.size, cells: cells.map(&:to_h) }
               end
 
               def veteran_cells(engine: nil, **)
-                eng = engine || @default_engine
+                eng = engine || default_engine
                 cells = eng.veteran_cells
                 { success: true, count: cells.size, cells: cells.map(&:to_h) }
               end
 
               def threat_coverage(engine: nil, **)
-                eng = engine || @default_engine
+                eng = engine || default_engine
                 coverage = eng.threat_coverage
                 { success: true, coverage: coverage }
               end
 
               def immune_status(engine: nil, **)
-                eng = engine || @default_engine
+                eng = engine || default_engine
                 report = eng.immune_report
                 { success: true, **report }
               end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::ImmuneMemoryEngine.new
+              end
             end
           end
         end

data/lib/legion/extensions/agentic/memory/trace/helpers/store.rb

@@ -165,10 +165,12 @@ module Legion
                 return unless snapshots
 
                 traces_snapshot, associations_snapshot, trace_rows_snapshot, traces_dirty, associations_dirty = snapshots
-                scoped_trace_ids = db[:memory_traces].where(partition_id: @partition_id).select_map(:trace_id)
-                memory_trace_ids = traces_snapshot.keys
-                stale_ids = persist_dirty_traces(db, trace_rows_snapshot, scoped_trace_ids, memory_trace_ids, traces_dirty)
-                persist_dirty_associations(db, associations_snapshot, scoped_trace_ids, memory_trace_ids, stale_ids, associations_dirty)
+                db.transaction do
+                  scoped_trace_ids = db[:memory_traces].where(partition_id: @partition_id).select_map(:trace_id)
+                  memory_trace_ids = traces_snapshot.keys
+                  stale_ids = persist_dirty_traces(db, trace_rows_snapshot, scoped_trace_ids, memory_trace_ids, traces_dirty)
+                  persist_dirty_associations(db, associations_snapshot, scoped_trace_ids, memory_trace_ids, stale_ids, associations_dirty)
+                end
                 clear_dirty_flags(trace_rows_snapshot)
               end
 
@@ -187,12 +189,9 @@ module Legion
               def persist_dirty_traces(db, trace_rows_snapshot, scoped_trace_ids, memory_trace_ids, traces_dirty)
                 return [] unless traces_dirty
 
-                trace_rows_snapshot.each do |trace_id, row|
-                  if db[:memory_traces].where(trace_id: trace_id).first
-                    db[:memory_traces].where(trace_id: trace_id).update(row)
-                  else
-                    db[:memory_traces].insert(row)
-                  end
+                ds = db[:memory_traces]
+                trace_rows_snapshot.each_value do |row|
+                  ds.insert_conflict(:replace).insert(row)
                 end
                 stale_ids = scoped_trace_ids - memory_trace_ids
                 db[:memory_traces].where(trace_id: stale_ids).delete unless stale_ids.empty?

data/lib/legion/extensions/agentic/memory/trace/quota.rb

@@ -25,11 +25,15 @@ module Legion
               evict_count = store.count - max_traces
               evict!(store, evict_count) if evict_count.positive?
 
+              return unless store.respond_to?(:total_bytes)
+
               overage = store.total_bytes - max_bytes
               evict!(store, estimate_eviction_count(overage)) if overage.positive?
             end
 
             def within_limits?(store)
+              return store.count <= max_traces unless store.respond_to?(:total_bytes)
+
               store.count <= max_traces && store.total_bytes <= max_bytes
             end
 
@@ -39,8 +43,14 @@ module Legion
               return if count <= 0
 
               case eviction
-              when :lru then store.delete_least_recently_used(count: count)
-              when :lowest_confidence then store.delete_lowest_confidence(count: count)
+              when :lru
+                return unless store.respond_to?(:delete_least_recently_used)
+
+                store.delete_least_recently_used(count: count)
+              when :lowest_confidence
+                return unless store.respond_to?(:delete_lowest_confidence)
+
+                store.delete_lowest_confidence(count: count)
               end
             end
 

data/lib/legion/extensions/agentic/memory/trace/runners/traces.rb

@@ -63,7 +63,7 @@ module Legion
 
                 result = scored.sort_by { |s| -s[:score] }
                 log.debug("[memory] retrieve_ranked ids=#{trace_ids.size} scored=#{result.size}")
-                result
+                { success: true, traces: result }
               end
 
               def delete_trace(trace_id:, store: nil, **)

data/lib/legion/extensions/agentic/memory/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.23'
+        VERSION = '0.1.25'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-memory
 version: !ruby/object:Gem::Version
-  version: 0.1.23
+  version: 0.1.25
 platform: ruby
 authors:
 - Esity