lex-agentic-memory 0.1.41 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7031061b84f2f2923ab2c4d43d472fe67bb8814f32a9b85d4dbd4444d734370a
-  data.tar.gz: dff1be7d4e8abf1757fb98934942b3ec7996dac01ce82bcf608d6b01a5a0adfd
+  metadata.gz: a82760274cd082ae6c5b20be2506a95b6a83428ec6e2a7c03340108d8b01a3b5
+  data.tar.gz: 1c95b9324954ea83899f27bc49d989405d22c21dd3a83f26248c87c8e01aba0a
 SHA512:
-  metadata.gz: b7c7d56ceca01dd24ec41483d78c325ae46641efbba2a1e2d25a34ca79361c5ccd983691436d705e2ae5ce6dceacdd56e5d02ee82579424126b3594cfbfdd467
-  data.tar.gz: 11dc7a02ab36704d3d67ffde18045dda343e7bbb7308e357cfb0d6b60092432be51568f156ae614c5daa2be0da479d889689db76bbd5b486d786b1d9ee11d34b
+  metadata.gz: 5ed2b7b49558c903d03400562dd3bef0cd90aec5e65f19e520f2b82810f74498fcda622445ec632778f36b9275f019a462faa4ee476dd6e6b32e2848d0fd453c
+  data.tar.gz: 9923a37c18191b9b6e6bcccbd9765e800d50fb74f13d053c3262599141cbe88060bb494b69f30e6c592d604da1694902fefc75c1c9a584e6786bdee7ccf23a18

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.2.0] - 2026-10-29
+### Changed
+- Partition fallback-cache traces, indexes, and associations by agent. Ambiguous legacy global cache history is not hydrated; existing global keys are left untouched and a warning explains the cold start.
+- Do not roll cache-backed deployments back to unpartitioned readers without controlled cache recovery: old readers cannot see new partitioned writes and can expose surviving global history.
+### Fixed
+- Apply trace, domain, and identity selectors before ranking, limiting, or reinforcement; explicit empty candidates select nothing and duplicate candidates reinforce only once.
+- Preserve ranked `{ trace:, score: }` results and legacy omitted-identity behavior. Explicit anonymous identity excludes partner/owner-scoped traces.
+- Derive default decay age from persisted last reinforcement time using the existing 60-second interval, preserving explicit age overrides and preventing maintenance from increasing strength.
+- Persist deletion of surviving association references and restore scoped coactivation progress across cache restarts.
+
 ## [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).

data/README.md

@@ -5,7 +5,7 @@ Domain consolidation gem for memory storage, retrieval, and consolidation. Bundl
 ## Overview
 
 **Gem**: `lex-agentic-memory`
-**Version**: 0.1.28
+**Version**: 0.2.0
 **Namespace**: `Legion::Extensions::Agentic::Memory`
 
 ## Sub-Modules
@@ -59,6 +59,41 @@ Domain consolidation gem for memory storage, retrieval, and consolidation. Bundl
 gem 'lex-agentic-memory'
 ```
 
+## Scoped retrieval
+
+`Trace::Client#retrieve_ranked(trace_ids:, domain_tag:, identity:)` filters
+explicit candidates before ranking and returns the existing
+`{ trace:, score: }` entries without reinforcing them.
+`retrieve_and_reinforce` accepts optional `trace_ids:`, `domain_tag:`, and
+`identity:` selectors before its limit is applied. An explicit empty ID list
+selects nothing; duplicate IDs cannot reinforce twice.
+
+Omitting `identity:` retains legacy unscoped retrieval. Explicit `identity: nil`
+or a blank identity selects only traces without partner/owner tags. A supplied
+identity excludes other or conflicting `partner:`/`owner:` tags. Callers must
+derive identity and candidates from authorized input; retrieval is not proof
+of usefulness or consent.
+
+Default decay derives cumulative age from persisted `last_reinforced` at the
+existing 60-second tick interval. Explicit `tick_count:` remains an absolute
+age override. Maintenance never raises strength; reinforcement remains explicit.
+
+## Cache upgrade and rollback
+
+Version 0.2.0 partitions fallback-cache keys by the agent's existing
+`partition_id`. Old global cache keys cannot establish safe ownership and are
+not automatically imported, read as a fallback, overwritten, or deleted.
+Cache-only upgrades therefore start with an empty scoped cache and log a
+warning when legacy global history is present. Preserve any required history
+through controlled, ownership-verified recovery before adopting this release.
+Agent-local database storage and its schema are unchanged.
+
+Rollback to an unpartitioned cache reader is not safe: it cannot read new
+scoped writes and can resurrect old global history. Use a forward fix or a
+controlled cache purge/recovery with verified ownership; do not restore stale
+shared cache data after selective erasure. No dual-write compatibility mode
+or automatic migration is provided.
+
 ## Development
 
 ```bash

data/lib/legion/extensions/agentic/memory/trace/actors/decay.rb

@@ -22,7 +22,7 @@ module Legion
               end
 
               def time
-                60
+                Legion::Extensions::Agentic::Memory::Trace::Helpers::Decay::TICK_INTERVAL
               end
 
               def run_now?

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

@@ -17,15 +17,12 @@ module Legion
               include Legion::Logging::Helper if defined?(Legion::Logging::Helper)
               include Legion::Cache::Helper if defined?(Legion::Cache::Helper)
 
-              TRACE_PREFIX = 'legion:memory:trace:'
-              INDEX_KEY    = 'legion:memory:trace_index'
-              ASSOC_KEY    = 'legion:memory:associations'
               TTL          = 86_400 # 24 hours
               FLUSH_BATCH  = 500    # traces per flush batch
 
               attr_reader :traces, :associations
 
-              def initialize
+              def initialize(partition_id: nil)
                 log.info('[memory] CacheStore initialized (memcached-backed, per-key)')
                 @mutex        = Mutex.new
                 @traces       = {}
@@ -33,12 +30,16 @@ module Legion
                 @dirty_ids    = Set.new
                 @deleted_ids  = Set.new
                 @assoc_dirty  = false
+                @partition_id = partition_id || Helpers::Trace.default_partition_id
+                # Global legacy cache keys cannot establish agent ownership and must not be hydrated.
+                @cache_prefix = "legion:memory:partition:#{@partition_id}:"
                 load_index
                 log.info("[memory] CacheStore loaded #{@traces.size} traces from cache")
               end
 
               def store(trace)
                 normalized_trace = Helpers::Trace.normalize_trace_affect(trace)
+                normalized_trace[:partition_id] ||= @partition_id
                 @mutex.synchronize do
                   @traces[normalized_trace[:trace_id]] = normalized_trace
                   @dirty_ids << normalized_trace[:trace_id]
@@ -53,6 +54,9 @@ module Legion
               def delete(trace_id)
                 @mutex.synchronize do
                   @traces.delete(trace_id)
+                  @traces.each_value do |trace|
+                    @dirty_ids << trace[:trace_id] if trace[:associated_traces]&.delete(trace_id)
+                  end
                   @associations.delete(trace_id)
                   @associations.each_value { |links| links.delete(trace_id) }
                   @dirty_ids.delete(trace_id)
@@ -96,7 +100,10 @@ module Legion
                   @associations[trace_id_b][trace_id_a] = (@associations[trace_id_b][trace_id_a] || 0) + 1
 
                   threshold = Helpers::Trace::COACTIVATION_THRESHOLD
-                  link_traces(trace_id_a, trace_id_b) if @associations[trace_id_a][trace_id_b] >= threshold
+                  if @associations[trace_id_a][trace_id_b] >= threshold && link_traces(trace_id_a, trace_id_b)
+                    @dirty_ids << trace_id_a
+                    @dirty_ids << trace_id_b
+                  end
                   @assoc_dirty = true
                 end
               end
@@ -173,11 +180,16 @@ module Legion
               private
 
               def trace_key(trace_id)
-                "#{TRACE_PREFIX}#{trace_id}"
+                "#{@cache_prefix}trace:#{trace_id}"
               end
 
               def load_index
-                index = cache_get(INDEX_KEY)
+                legacy_index = cache_get('legion:memory:trace_index')
+                if legacy_index.is_a?(Array) && !legacy_index.empty?
+                  log.warn('[memory] Ignoring legacy global cache history: agent ownership is ambiguous; legacy keys remain untouched')
+                end
+
+                index = cache_get("#{@cache_prefix}index")
                 return unless index.is_a?(Array)
 
                 loaded = 0
@@ -188,6 +200,14 @@ module Legion
                     loaded += 1
                   end
                 end
+                associations = cache_get("#{@cache_prefix}associations")
+                if associations.is_a?(Hash)
+                  @associations = associations.each_with_object({}) do |(id, links), restored|
+                    next unless @traces.key?(id)
+
+                    restored[id] = links.select { |target, _count| @traces.key?(target) }
+                  end
+                end
                 log.debug("[memory] CacheStore loaded #{loaded}/#{index.size} traces from index")
               rescue StandardError => e
                 log.warn("[memory] CacheStore load_index failed: #{e.message}")
@@ -213,7 +233,7 @@ module Legion
               def flush_associations
                 return unless @assoc_dirty
 
-                cache_set(ASSOC_KEY, strip_default_procs(@associations), ttl: TTL)
+                cache_set("#{@cache_prefix}associations", strip_default_procs(@associations), ttl: TTL)
                 @assoc_dirty = false
               rescue StandardError => e
                 log.warn("[memory] CacheStore flush_associations failed (#{@associations.size} entries): #{e.message}")
@@ -222,7 +242,7 @@ module Legion
               def flush_index
                 return if @dirty_ids.empty? && @deleted_ids.empty?
 
-                cache_set(INDEX_KEY, @traces.keys, ttl: TTL)
+                cache_set("#{@cache_prefix}index", @traces.keys, ttl: TTL)
               rescue StandardError => e
                 log.warn("[memory] CacheStore flush_index failed (#{@traces.size} traces): #{e.message}")
               end
@@ -239,10 +259,16 @@ module Legion
                 return unless trace_a && trace_b
 
                 max = Helpers::Trace::MAX_ASSOCIATIONS
-                trace_a[:associated_traces] << id_b unless trace_a[:associated_traces].include?(id_b) || trace_a[:associated_traces].size >= max
-                return if trace_b[:associated_traces].include?(id_a) || trace_b[:associated_traces].size >= max
-
-                trace_b[:associated_traces] << id_a
+                changed = false
+                unless trace_a[:associated_traces].include?(id_b) || trace_a[:associated_traces].size >= max
+                  trace_a[:associated_traces] << id_b
+                  changed = true
+                end
+                unless trace_b[:associated_traces].include?(id_a) || trace_b[:associated_traces].size >= max
+                  trace_b[:associated_traces] << id_a
+                  changed = true
+                end
+                changed
               end
             end
           end

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

@@ -7,6 +7,8 @@ module Legion
         module Trace
           module Helpers
             module Decay
+              TICK_INTERVAL = 60
+
               module_function
 
               # Power-law decay formula from spec:

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

@@ -46,7 +46,9 @@ module Legion
               def delete(trace_id)
                 @mutex.synchronize do
                   removed_trace = @traces.delete(trace_id)
-                  @traces.each_value { |trace| trace[:associated_traces]&.delete(trace_id) }
+                  @traces.each_value do |trace|
+                    @dirty_trace_ids << trace[:trace_id] if trace[:associated_traces]&.delete(trace_id)
+                  end
 
                   removed_links = @associations.delete(trace_id)
                   @associations.each_value { |links| links.delete(trace_id) }

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

@@ -30,7 +30,7 @@ module Legion
                 { found: true, reinforced: true, trace_id: trace_id, new_strength: new_strength }
               end
 
-              def decay_cycle(store: nil, tick_count: 1, maintenance: true, **)
+              def decay_cycle(store: nil, tick_count: nil, maintenance: true, **)
                 unless maintenance
                   deferred = deferred_decay_summary(store || cached_default_store)
                   return { **deferred }
@@ -40,23 +40,29 @@ module Legion
                 decayed = 0
                 pruned = 0
                 total = trace_count(store)
+                now = Time.now.utc
 
                 store.all_traces.each do |trace|
                   next if trace[:base_decay_rate].zero?
 
+                  # Explicit tick_count is an age override; actor maintenance derives age from persisted access time.
+                  ticks_since_access = tick_count || [(now - Helpers::Decay.ensure_time(trace[:last_reinforced])) /
+                    Helpers::Decay::TICK_INTERVAL, 0].max
+
                   new_strength = Helpers::Decay.compute_decay(
                     peak_strength:       trace[:peak_strength],
                     base_decay_rate:     trace[:base_decay_rate],
-                    ticks_since_access:  tick_count,
+                    ticks_since_access:  ticks_since_access,
                     emotional_intensity: trace[:emotional_intensity]
                   )
+                  new_strength = [trace[:strength], new_strength].min
 
                   if new_strength <= Helpers::Trace::PRUNE_THRESHOLD
                     store.delete(trace[:trace_id])
                     pruned += 1
                   else
                     trace[:strength] = new_strength
-                    trace[:last_decayed] = Time.now.utc
+                    trace[:last_decayed] = now
                     store.store(trace)
                     decayed += 1
                   end
@@ -70,7 +76,7 @@ module Legion
                   pruned:        pruned,
                   total:         total,
                   remaining:     remaining,
-                  maintained_at: Time.now.utc
+                  maintained_at: now
                 }
                 Legion::Extensions::Agentic::Memory::Trace.record_maintenance_summary(summary.dup)
 

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

@@ -46,12 +46,13 @@ module Legion
                 { count: traces.size, traces: traces }
               end
 
-              def retrieve_ranked(trace_ids: [], store: nil, query_time: nil, **)
+              def retrieve_ranked(trace_ids: [], store: nil, query_time: nil, domain_tag: nil, **scope)
                 store ||= default_store
                 query_time ||= Time.now.utc
                 associated_set = Set.new
 
-                traces = trace_ids.filter_map { |id| store.get(id) }
+                traces = trace_ids.uniq.filter_map { |id| store.get(id) }
+                traces = filter_trace_candidates(traces: traces, domain_tag: domain_tag, **scope)
                 traces.each { |t| associated_set.merge(t[:associated_traces]) }
 
                 scored = traces.map do |t|
@@ -88,10 +89,15 @@ module Legion
                 { erased: true, identity: identity, count: count }
               end
 
-              def retrieve_and_reinforce(limit: 10, store: nil, **)
+              def retrieve_and_reinforce(limit: 10, store: nil, trace_ids: nil, domain_tag: nil, **scope)
                 store ||= default_store
-                all = store.all_traces(min_strength: 0.1)
-                top = all.sort_by { |t| -t[:strength] }.first(limit)
+                candidates = if trace_ids
+                               trace_ids.uniq.filter_map { |id| store.get(id) }.select { |trace| trace[:strength] >= 0.1 }
+                             else
+                               store.all_traces(min_strength: 0.1)
+                             end
+                candidates = filter_trace_candidates(traces: candidates, domain_tag: domain_tag, **scope)
+                top = candidates.sort_by { |trace| -trace[:strength] }.first(limit)
 
                 top.each do |trace|
                   next if trace[:base_decay_rate].zero? # skip firmware
@@ -103,12 +109,30 @@ module Legion
 
                 persist_store(store) unless top.empty?
 
-                log.debug("[memory] retrieve_and_reinforce: retrieved=#{top.size} from=#{all.size} total")
+                log.debug("[memory] retrieve_and_reinforce: retrieved=#{top.size} from=#{candidates.size} candidates")
                 { count: top.size, traces: top }
               end
 
               private
 
+              def filter_trace_candidates(traces:, domain_tag:, **scope)
+                return traces unless domain_tag || scope.key?(:identity) # rubocop:disable Legion/Extension/RunnerReturnHash -- Private helper returns candidate arrays.
+
+                traces.select do |trace|
+                  tags = Array(trace[:domain_tags])
+                  next false if domain_tag && !tags.include?(domain_tag)
+                  next true unless scope.key?(:identity)
+
+                  identity = scope[:identity].to_s
+                  tags.all? do |tag|
+                    tag = tag.to_s
+                    next true unless tag.start_with?('partner:', 'owner:')
+
+                    !identity.strip.empty? && ["partner:#{identity}", "owner:#{identity}"].include?(tag)
+                  end
+                end
+              end
+
               def persist_store(store)
                 store.flush if store.respond_to?(:flush)
               rescue StandardError => e

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

@@ -50,7 +50,7 @@ module Legion
                 Helpers::PostgresStore.new(tenant_id: resolve_tenant_id, agent_id: resolve_agent_id)
               elsif defined?(Legion::Cache) && Legion::Cache.respond_to?(:connected?) && Legion::Cache.connected?
                 Legion::Logging.debug '[memory] Using shared CacheStore (memcached)'
-                Helpers::CacheStore.new
+                Helpers::CacheStore.new(partition_id: resolve_agent_id)
               else
                 Legion::Logging.debug '[memory] Using agent-local in-memory Store'
                 Helpers::Store.new(partition_id: resolve_agent_id)

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

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

data/spec/legion/extensions/agentic/memory/trace/helpers/cache_store_spec.rb

@@ -1,37 +1,84 @@
 # frozen_string_literal: true
 
 RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::CacheStore do
-  describe '#initialize' do
-    it 'has logging and cache helpers when loaded directly' do
-      allow(Legion::Cache).to receive(:get).and_return(nil)
+  let(:cache) { {} }
+  let(:trace_helper) { Legion::Extensions::Agentic::Memory::Trace::Helpers::Trace }
 
-      store = described_class.new
-
-      expect(store).to respond_to(:log)
-      expect(store).to respond_to(:cache_get)
+  before do
+    allow(Legion::Cache).to receive(:get) do |key, **|
+      Marshal.load(cache[key]) if cache.key?(key) # rubocop:disable Security/MarshalLoad -- Bytes are produced only by this isolated fixture.
+    end
+    allow(Legion::Cache).to receive(:set) do |key, value, **|
+      cache[key] = Marshal.dump(value)
+      true
     end
+    allow(Legion::Cache).to receive(:delete) { |key, **| cache.delete(key) }
+  end
+
+  it 'keeps trace contents, indexes, and deletion isolated across agent restarts' do
+    alice = described_class.new(partition_id: 'alice')
+    bob = described_class.new(partition_id: 'bob')
+    trace = trace_helper.new_trace(type: :semantic, content_payload: { fact: 'alice' }, partition_id: 'alice')
+    alice.store(trace)
+    bob.store(trace.merge(content_payload: { fact: 'bob' }, partition_id: 'bob'))
+    alice.flush
+    bob.flush
+
+    alice = described_class.new(partition_id: 'alice')
+    bob = described_class.new(partition_id: 'bob')
+    expect(alice.get(trace[:trace_id])[:content_payload]).to eq(fact: 'alice')
+    expect(bob.get(trace[:trace_id])[:content_payload]).to eq(fact: 'bob')
+
+    alice.delete(trace[:trace_id])
+    alice.flush
+    bob.reload
+    expect(described_class.new(partition_id: 'alice').all_traces).to eq([])
+    expect(bob.get(trace[:trace_id])[:content_payload]).to eq(fact: 'bob')
+  end
+
+  it 'does not hydrate ambiguous legacy global cache records' do
+    private_trace = trace_helper.new_trace(type: :semantic, content_payload: { fact: 'private' }, partition_id: 'bob')
+    legacy_writer = described_class.new(partition_id: 'legacy-fixture')
+    legacy_writer.cache_set('legion:memory:trace_index', [private_trace[:trace_id]])
+    legacy_writer.cache_set("legion:memory:trace:#{private_trace[:trace_id]}", private_trace)
+    legacy_records = cache.dup
+
+    expect(described_class.new(partition_id: 'alice').all_traces).to eq([])
+    expect(described_class.new(partition_id: 'bob').all_traces).to eq([])
+
+    store = described_class.new(partition_id: 'alice')
+    store.store(private_trace.merge(content_payload: { fact: 'new scoped trace' }, partition_id: 'alice'))
+    store.flush
+    store.delete(private_trace[:trace_id])
+    store.flush
+
+    expect(cache.slice(*legacy_records.keys)).to eq(legacy_records)
   end
 
-  describe '#flush' do
-    it 'passes cache TTL as a keyword argument' do
-      allow(Legion::Cache).to receive(:get).and_return(nil)
-      allow(Legion::Cache).to receive(:set).and_return(true)
-      store = described_class.new
-      trace = Legion::Extensions::Agentic::Memory::Trace::Helpers::Trace.new_trace(
-        type:            :semantic,
-        content_payload: { fact: 'cache flush' }
-      )
-
-      store.store(trace)
-      store.flush
-
-      expect(Legion::Cache).to have_received(:set).with(
-        a_string_including(trace[:trace_id]),
-        trace,
-        ttl:   described_class::TTL,
-        async: false,
-        phi:   false
-      )
+  it 'preserves scoped coactivation progress and persisted links without resurrecting deleted links' do
+    store = described_class.new(partition_id: 'alice')
+    first = trace_helper.new_trace(type: :semantic, content_payload: { fact: 'first' }, partition_id: 'alice')
+    second = trace_helper.new_trace(type: :semantic, content_payload: { fact: 'second' }, partition_id: 'alice')
+    store.store(first)
+    store.store(second)
+    store.record_coactivation(first[:trace_id], second[:trace_id])
+    store.flush
+
+    restarted = described_class.new(partition_id: 'alice')
+    (trace_helper::COACTIVATION_THRESHOLD - 1).times do
+      restarted.record_coactivation(first[:trace_id], second[:trace_id])
     end
+    restarted.flush
+    restarted.reload
+
+    expect(restarted.retrieve_associated(first[:trace_id]).map { |trace| trace[:trace_id] }).to eq([second[:trace_id]])
+    expect(described_class.new(partition_id: 'bob').associations).to eq({})
+
+    restarted.delete(second[:trace_id])
+    restarted.flush
+    restarted.reload
+    expect(restarted.get(second[:trace_id])).to be_nil
+    expect(restarted.get(first[:trace_id])[:associated_traces]).to eq([])
+    expect(restarted.associations.fetch(first[:trace_id], {})).to eq({})
   end
 end

data/spec/legion/extensions/agentic/memory/trace/helpers/error_tracer_spec.rb

@@ -123,7 +123,7 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::ErrorTracer
       described_class.instance_variable_set(:@write_queue, worker_queue)
       allow(runner_double).to receive(:store_trace).and_raise(StandardError, 'db down')
 
-      # rubocop:disable ThreadSafety/NewThread
+      # rubocop:disable-next ThreadSafety/NewThread
       worker = Thread.new do
         payload = worker_queue.pop
         break if payload == :stop
@@ -132,7 +132,6 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::ErrorTracer
       rescue StandardError
         nil
       end
-      # rubocop:enable ThreadSafety/NewThread
 
       described_class.send(:record_trace, 'store failure', :error)
       expect { worker.join(2) }.not_to raise_error
@@ -142,7 +141,7 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::ErrorTracer
       dedicated_queue = Queue.new
       described_class.instance_variable_set(:@write_queue, dedicated_queue)
 
-      # rubocop:disable ThreadSafety/NewThread
+      # rubocop:disable-next ThreadSafety/NewThread
       worker = Thread.new do
         loop do
           payload = dedicated_queue.pop
@@ -155,7 +154,6 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::ErrorTracer
           nil
         end
       end
-      # rubocop:enable ThreadSafety/NewThread
 
       described_class.send(:record_trace, '[mycomponent] disk full', :error)
       dedicated_queue.push(:stop)

data/spec/legion/extensions/agentic/memory/trace/helpers/store_spec.rb

@@ -261,7 +261,7 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::Store do
     end
   end
 
-  describe 'parse_db_json nil/empty guard (log spam regression)' do
+  describe 'local persistence' do
     let(:local_db) do
       d = Sequel.sqlite
       d.create_table(:memory_traces) do
@@ -331,6 +331,23 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::Store do
       expect(trace[:associated_traces]).to eq([])
       expect(trace[:child_trace_ids]).to eq([])
     end
+
+    it 'does not resurrect deleted association references after a restart' do
+      store.store(semantic_trace)
+      store.store(episodic_trace)
+      trace_helper::COACTIVATION_THRESHOLD.times do
+        store.record_coactivation(semantic_trace[:trace_id], episodic_trace[:trace_id])
+      end
+      store.flush
+
+      store.delete(episodic_trace[:trace_id])
+      store.flush
+      restarted = described_class.new
+
+      expect(restarted.get(episodic_trace[:trace_id])).to be_nil
+      expect(restarted.get(semantic_trace[:trace_id])[:associated_traces]).to eq([])
+      expect(restarted.retrieve_associated(semantic_trace[:trace_id])).to eq([])
+    end
   end
 
   describe '#restore_traces' do

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

@@ -102,6 +102,48 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Runners::Consolidatio
       expect(result[:decayed]).to be >= 1
     end
 
+    it 'continues the same power-law aging across repeated maintenance and snapshot restore' do
+      started_at = Time.utc(2026, 10, 29)
+      allow(Time).to receive(:now).and_return(started_at)
+      store = Legion::Extensions::Agentic::Memory::Trace::Helpers::Store.new
+      stored = client.store_trace(type: :semantic, content_payload: {}, store: store)
+      id = stored[:trace_id]
+
+      allow(Time).to receive(:now).and_return(started_at + 60)
+      client.decay_cycle(store: store)
+      first_strength = store.get(id)[:strength]
+      expect(first_strength).to be_within(1e-12).of(0.5 * (2.0**-0.01))
+
+      restored = Legion::Extensions::Agentic::Memory::Trace::Helpers::Store.new
+      restored.restore_traces(Marshal.load(Marshal.dump(store.all_traces)))
+      allow(Time).to receive(:now).and_return(started_at + 120)
+      client.decay_cycle(store: restored)
+
+      expect(restored.get(id)[:strength]).to be_within(1e-12).of(0.5 * (3.0**-0.01))
+      expect(restored.get(id)[:strength]).to be < first_strength
+      second_strength = restored.get(id)[:strength]
+      client.decay_cycle(store: restored)
+      expect(restored.get(id)[:strength]).to eq(second_strength)
+    end
+
+    it 'restarts aging from explicit reinforcement without restoring historical peak strength during maintenance' do
+      started_at = Time.utc(2026, 10, 29)
+      allow(Time).to receive(:now).and_return(started_at)
+      id = client.store_trace(type: :semantic, content_payload: {})[:trace_id]
+
+      client.decay_cycle(tick_count: 100)
+      aged_strength = client.get_trace(trace_id: id)[:trace][:strength]
+      client.decay_cycle
+      expect(client.get_trace(trace_id: id)[:trace][:strength]).to eq(aged_strength)
+
+      allow(Time).to receive(:now).and_return(started_at + 120)
+      reinforced = client.reinforce(trace_id: id)[:new_strength]
+      allow(Time).to receive(:now).and_return(started_at + 180)
+      client.decay_cycle
+
+      expect(client.get_trace(trace_id: id)[:trace][:strength]).to be_within(1e-12).of(reinforced * (2.0**-0.01))
+    end
+
     it 'prunes traces below threshold' do
       stored = client.store_trace(type: :sensory, content_payload: {})
       trace = client.get_trace(trace_id: stored[:trace_id])
@@ -109,7 +151,8 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Runners::Consolidatio
       trace[:trace][:peak_strength] = 0.005
 
       result = client.decay_cycle(tick_count: 100_000)
-      expect(result[:pruned]).to be >= 0
+      expect(result[:pruned]).to eq(1)
+      expect(client.get_trace(trace_id: stored[:trace_id])[:found]).to be false
     end
   end
 

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

@@ -58,6 +58,74 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Runners::Traces do
     end
   end
 
+  describe 'scoped retrieval' do
+    let(:alice) do
+      client.store_trace(type: :semantic, content_payload: { fact: 'alice work' }, domain_tags: ['work', 'partner:alice'])
+    end
+    let(:bob) do
+      client.store_trace(type: :identity, content_payload: { fact: 'bob work' }, domain_tags: ['work', 'owner:bob'])
+    end
+    let(:unrelated) do
+      client.store_trace(type: :identity, content_payload: { fact: 'alice home' }, domain_tags: ['home', 'partner:alice'])
+    end
+    let(:ids) { [alice, bob, unrelated].map { |trace| trace[:trace_id] } }
+
+    it 'filters ranked candidates by principal and domain without reinforcing them' do
+      before = client.get_trace(trace_id: alice[:trace_id])[:trace].dup
+
+      result = client.retrieve_ranked(trace_ids: ids, domain_tag: 'work', identity: 'alice')
+
+      expect(result[:traces].map { |entry| entry[:trace][:trace_id] }).to eq([alice[:trace_id]])
+      expect(result[:traces].first[:score]).to be > 0
+      expect(client.get_trace(trace_id: alice[:trace_id])[:trace]).to eq(before)
+    end
+
+    it 'does not return private or conflicting-owner traces to an anonymous or different principal' do
+      shared = client.store_trace(type: :semantic, content_payload: { fact: 'public' }, domain_tags: ['work'])
+      mixed = client.store_trace(type: :semantic, content_payload: {},
+                                 domain_tags: ['work', 'partner:alice', 'owner:bob'])
+      candidates = ids + [shared[:trace_id], mixed[:trace_id]]
+
+      anonymous = client.retrieve_ranked(trace_ids: candidates, identity: nil)
+      scoped = client.retrieve_ranked(trace_ids: candidates, domain_tag: 'work', identity: 'alice')
+
+      expect(anonymous[:traces].map { |entry| entry[:trace][:trace_id] }).to eq([shared[:trace_id]])
+      expect(scoped[:traces].map { |entry| entry[:trace][:trace_id] }).to contain_exactly(alice[:trace_id], shared[:trace_id])
+    end
+
+    it 'keeps unscoped explicit candidate ranking available to standalone callers' do
+      result = client.retrieve_ranked(trace_ids: ids)
+
+      expect(result[:traces].map { |entry| entry[:trace][:trace_id] }).to contain_exactly(*ids)
+      expect(client.retrieve_ranked[:traces]).to eq([])
+    end
+
+    it 'reinforces only authorized relevant candidates before applying the limit' do
+      result = client.retrieve_and_reinforce(trace_ids: ids + [alice[:trace_id]], domain_tag: 'work', identity: 'alice', limit: 1)
+
+      expect(result[:traces].map { |trace| trace[:trace_id] }).to eq([alice[:trace_id]])
+      expect(client.get_trace(trace_id: alice[:trace_id])[:trace][:reinforcement_count]).to eq(1)
+      expect(client.get_trace(trace_id: bob[:trace_id])[:trace][:reinforcement_count]).to eq(0)
+      expect(client.get_trace(trace_id: unrelated[:trace_id])[:trace][:reinforcement_count]).to eq(0)
+    end
+
+    it 'does not fall back to global traces when an explicit candidate list is empty' do
+      alice
+
+      expect(client.retrieve_and_reinforce(trace_ids: [])).to eq(count: 0, traces: [])
+      expect(client.get_trace(trace_id: alice[:trace_id])[:trace][:reinforcement_count]).to eq(0)
+    end
+
+    it 'selects domain candidates from the store when no ids are supplied' do
+      ids
+
+      result = client.retrieve_and_reinforce(domain_tag: 'work', identity: 'alice', limit: 1)
+
+      expect(result[:traces].map { |trace| trace[:trace_id] }).to eq([alice[:trace_id]])
+      expect(client.get_trace(trace_id: bob[:trace_id])[:trace][:reinforcement_count]).to eq(0)
+    end
+  end
+
   describe '#delete_trace' do
     it 'removes a trace' do
       stored = client.store_trace(type: :semantic, content_payload: {})

metadata

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