lex-agentic-memory 0.1.39 → 0.1.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89cf392450f3ff2b43d9ff1430c9cb4e8b108d0221b46aa4c2e3e064514c6200
-  data.tar.gz: 0343f1b89ae601f477939c5890fca5bcb2e8e4961f411049612731edf16ae43e
+  metadata.gz: 7031061b84f2f2923ab2c4d43d472fe67bb8814f32a9b85d4dbd4444d734370a
+  data.tar.gz: dff1be7d4e8abf1757fb98934942b3ec7996dac01ce82bcf608d6b01a5a0adfd
 SHA512:
-  metadata.gz: ca0b83053d099fd5e445427105023210371b4e4048961bfa4d3446b8ca1412902c8c6dbbcfaa0881d787d55ba5ec70fc5321023374c3a9c35b6718d99e9af8b8
-  data.tar.gz: 5c6e4acf09c5cafae4694253381e963316fe898e9c738bb9ae0143e9788e242e01b5dd442f3187ebb8f997b1a3ef095fdb1c1fd9a77c0ac2072c0e255247b860
+  metadata.gz: b7c7d56ceca01dd24ec41483d78c325ae46641efbba2a1e2d25a34ca79361c5ccd983691436d705e2ae5ce6dceacdd56e5d02ee82579424126b3594cfbfdd467
+  data.tar.gz: 11dc7a02ab36704d3d67ffde18045dda343e7bbb7308e357cfb0d6b60092432be51568f156ae614c5daa2be0da479d889689db76bbd5b486d786b1d9ee11d34b

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.1.41] - 2026-07-22
+### Added
+- `Runners::Traces#erase_partner!(identity:)` — deletes all traces tagged `partner:<identity>` and `owner:<identity>`; returns `{ erased: true, identity:, count: }`. Prep for H8 death protocol cascade (Phase 4.5 contract gate gap).
+
+## [0.1.40] - 2026-06-17
+### Fixed
+- **Critical performance fix:** Trace store `snapshot_dirty_state` no longer serializes ALL traces to JSON on every flush — replaced boolean `@traces_dirty` flag with per-trace `@dirty_trace_ids` Set so only modified traces are serialized (O(changed) instead of O(total))
+- `load_from_local` no longer re-serializes every trace on boot — stores raw DB rows directly in `@persisted_trace_rows`
+- `persist_dirty_traces` now handles explicit deletion tracking via `@deleted_trace_ids` Set
+- Eliminates 97%+ single-core CPU usage caused by `decay_cycle` triggering full-store JSON serialization every 60 seconds
+
 ## [0.1.39] - 2026-06-01
 ### Fixed
 - `ErrorTracer` now guards against infinite recursion — if downstream trace storage triggers error/fatal logging, the `tracing?` thread-local flag prevents re-entry

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

@@ -22,7 +22,8 @@ module Legion
                 @traces = {}
                 @associations = Hash.new { |h, k| h[k] = Hash.new(0) }
                 @partition_id = partition_id || resolve_partition_id
-                @traces_dirty = false
+                @dirty_trace_ids = Set.new
+                @deleted_trace_ids = Set.new
                 @associations_dirty = false
                 @persisted_trace_rows = {}
                 load_from_local
@@ -32,7 +33,7 @@ module Legion
                 persisted_trace = Helpers::Trace.normalize_trace_affect(trace)
                 persisted_trace[:partition_id] ||= @partition_id
                 @mutex.synchronize do
-                  @traces_dirty = true if @traces[persisted_trace[:trace_id]] != persisted_trace
+                  @dirty_trace_ids << persisted_trace[:trace_id]
                   @traces[persisted_trace[:trace_id]] = persisted_trace
                 end
                 persisted_trace[:trace_id]
@@ -50,7 +51,10 @@ module Legion
                   removed_links = @associations.delete(trace_id)
                   @associations.each_value { |links| links.delete(trace_id) }
 
-                  @traces_dirty = true if removed_trace
+                  if removed_trace
+                    @dirty_trace_ids.delete(trace_id)
+                    @deleted_trace_ids << trace_id
+                  end
                   @associations_dirty = true if removed_trace || removed_links
                 end
               end
@@ -92,8 +96,10 @@ module Legion
                   @associations_dirty = true
 
                   threshold = Helpers::Trace::COACTIVATION_THRESHOLD
-                  @traces_dirty = true if @associations[trace_id_a][trace_id_b] >= threshold &&
-                                          link_traces(trace_id_a, trace_id_b)
+                  if @associations[trace_id_a][trace_id_b] >= threshold && link_traces(trace_id_a, trace_id_b)
+                    @dirty_trace_ids << trace_id_a
+                    @dirty_trace_ids << trace_id_b
+                  end
                 end
               end
 
@@ -128,7 +134,8 @@ module Legion
                 @mutex.synchronize do
                   @traces = snapshot
                   @associations = Hash.new { |h, k| h[k] = Hash.new(0) }
-                  @traces_dirty = true
+                  @dirty_trace_ids = Set.new(@traces.keys)
+                  @deleted_trace_ids = Set.new
                   @associations_dirty = true
                 end
                 flush
@@ -183,27 +190,41 @@ module Legion
               end
 
               def snapshot_dirty_state
-                traces_snapshot, associations_snapshot, trace_rows_snapshot, trace_changes, associations_dirty = @mutex.synchronize do
-                  ts = @traces.transform_values(&:dup)
+                @mutex.synchronize do
+                  dirty_ids = @dirty_trace_ids.to_a
+                  deleted_ids = @deleted_trace_ids.to_a
+                  associations_dirty = @associations_dirty
+
+                  return nil if dirty_ids.empty? && deleted_ids.empty? && !associations_dirty
+
+                  dirty_rows = dirty_ids.each_with_object({}) do |trace_id, h|
+                    trace = @traces[trace_id]
+                    h[trace_id] = serialize_trace_for_db(trace) if trace
+                  end
+
+                  trace_rows_snapshot = @persisted_trace_rows.merge(dirty_rows)
+                  deleted_ids.each { |id| trace_rows_snapshot.delete(id) }
+
+                  traces_snapshot = @traces.transform_values(&:dup)
                   as = @associations.each_with_object({}) { |(tid, targets), memo| memo[tid] = targets.dup }
-                  trs = ts.transform_values { |trace| serialize_trace_for_db(trace) }
-                  changed_trace_ids = trs.each_key.reject { |trace_id| trs[trace_id] == @persisted_trace_rows[trace_id] }
-                  trace_changes = { dirty: @traces_dirty || changed_trace_ids.any?, changed_ids: changed_trace_ids }
-                  [ts, as, trs, trace_changes, @associations_dirty]
-                end
-                return nil unless trace_changes[:dirty] || associations_dirty
+                  trace_changes = { dirty: true, changed_ids: dirty_ids, deleted_ids: deleted_ids }
 
-                [traces_snapshot, associations_snapshot, trace_rows_snapshot, trace_changes, associations_dirty]
+                  [traces_snapshot, as, trace_rows_snapshot, trace_changes, associations_dirty]
+                end
               end
 
               def persist_dirty_traces(db, trace_rows_snapshot, trace_changes, stale_ids)
-                return unless trace_changes[:dirty] || !stale_ids.empty?
+                changed_ids = trace_changes[:changed_ids] || []
+                deleted_ids = trace_changes[:deleted_ids] || []
+                all_removals = (stale_ids + deleted_ids).uniq
+                return if changed_ids.empty? && all_removals.empty?
 
                 ds = db[:memory_traces]
-                trace_changes[:changed_ids].each do |trace_id|
-                  ds.insert_conflict(:replace).insert(trace_rows_snapshot.fetch(trace_id))
+                changed_ids.each do |trace_id|
+                  row = trace_rows_snapshot[trace_id]
+                  ds.insert_conflict(:replace).insert(row) if row
                 end
-                db[:memory_traces].where(trace_id: stale_ids).delete unless stale_ids.empty?
+                db[:memory_traces].where(trace_id: all_removals).delete unless all_removals.empty?
               end
 
               def persist_dirty_associations(db, associations_snapshot, scoped_trace_ids, memory_trace_ids, stale_ids, dirty)
@@ -232,7 +253,8 @@ module Legion
 
               def clear_dirty_flags(trace_rows_snapshot)
                 @mutex.synchronize do
-                  @traces_dirty = false
+                  @dirty_trace_ids.clear
+                  @deleted_trace_ids.clear
                   @associations_dirty = false
                   @persisted_trace_rows = trace_rows_snapshot
                 end
@@ -246,12 +268,13 @@ module Legion
 
                 db[:memory_traces].where(partition_id: @partition_id).each do |row|
                   @traces[row[:trace_id]] = deserialize_trace_from_db(row)
+                  @persisted_trace_rows[row[:trace_id]] = row.dup
                 end
 
                 load_local_associations(db)
 
-                @persisted_trace_rows = @traces.transform_values { |trace| serialize_trace_for_db(trace) }
-                @traces_dirty = false
+                @dirty_trace_ids = Set.new
+                @deleted_trace_ids = Set.new
                 @associations_dirty = false
               end
 

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

@@ -74,6 +74,20 @@ module Legion
                 { deleted: true, trace_id: trace_id }
               end
 
+              def erase_partner!(identity:, store: nil, **)
+                store ||= default_store
+                partner_result = store.retrieve_by_domain("partner:#{identity}", min_strength: 0.0, limit: 10_000)
+                owner_result   = store.retrieve_by_domain("owner:#{identity}",   min_strength: 0.0, limit: 10_000)
+                traces_to_erase = Array(partner_result) + Array(owner_result)
+
+                traces_to_erase.each { |t| store.delete(t[:trace_id]) }
+                persist_store(store) unless traces_to_erase.empty?
+
+                count = traces_to_erase.size
+                log.info("[memory] erase_partner! identity=#{identity} erased=#{count}")
+                { erased: true, identity: identity, count: count }
+              end
+
               def retrieve_and_reinforce(limit: 10, store: nil, **)
                 store ||= default_store
                 all = store.all_traces(min_strength: 0.1)

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.39'
+        VERSION = '0.1.41'
       end
     end
   end

data/spec/legion/extensions/agentic/memory/trace/runners/traces_spec.rb

@@ -66,4 +66,50 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Runners::Traces do
       expect(result[:found]).to be false
     end
   end
+
+  describe '#erase_partner!' do
+    it 'erases all partner-tagged traces for the given identity' do
+      3.times { client.store_trace(type: :semantic, content_payload: {}, domain_tags: ['partner:alice']) }
+      2.times { client.store_trace(type: :semantic, content_payload: {}, domain_tags: ['partner:bob']) }
+
+      result = client.erase_partner!(identity: 'alice')
+
+      expect(result[:erased]).to be true
+      expect(result[:identity]).to eq('alice')
+      expect(result[:count]).to eq(3)
+
+      expect(client.retrieve_by_domain(domain_tag: 'partner:alice')[:count]).to eq(0)
+      expect(client.retrieve_by_domain(domain_tag: 'partner:bob')[:count]).to eq(2)
+    end
+
+    it 'erases owner-tagged traces for the given identity' do
+      2.times { client.store_trace(type: :semantic, content_payload: {}, domain_tags: ['owner:alice']) }
+      client.store_trace(type: :semantic, content_payload: {}, domain_tags: ['partner:alice'])
+
+      result = client.erase_partner!(identity: 'alice')
+
+      expect(result[:count]).to eq(3)
+      expect(client.retrieve_by_domain(domain_tag: 'owner:alice')[:count]).to eq(0)
+      expect(client.retrieve_by_domain(domain_tag: 'partner:alice')[:count]).to eq(0)
+    end
+
+    it 'returns count: 0 when no traces exist for the identity' do
+      result = client.erase_partner!(identity: 'ghost')
+
+      expect(result[:erased]).to be true
+      expect(result[:identity]).to eq('ghost')
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'does not erase traces belonging to other identities' do
+      client.store_trace(type: :semantic, content_payload: {}, domain_tags: ['partner:alice'])
+      client.store_trace(type: :semantic, content_payload: {}, domain_tags: ['partner:bob'])
+      client.store_trace(type: :semantic, content_payload: {}, domain_tags: ['owner:carol'])
+
+      client.erase_partner!(identity: 'alice')
+
+      expect(client.retrieve_by_domain(domain_tag: 'partner:bob')[:count]).to eq(1)
+      expect(client.retrieve_by_domain(domain_tag: 'owner:carol')[:count]).to eq(1)
+    end
+  end
 end

metadata

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