lex-agentic-memory 0.1.6 → 0.1.9

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

@@ -21,6 +21,7 @@ module Legion
 
               def initialize
                 Legion::Logging.info '[memory] CacheStore initialized (memcached-backed, per-key)'
+                @mutex        = Mutex.new
                 @traces       = {}
                 @associations = {}
                 @dirty_ids    = Set.new
@@ -31,8 +32,10 @@ module Legion
               end
 
               def store(trace)
-                @traces[trace[:trace_id]] = trace
-                @dirty_ids << trace[:trace_id]
+                @mutex.synchronize do
+                  @traces[trace[:trace_id]] = trace
+                  @dirty_ids << trace[:trace_id]
+                end
                 trace[:trace_id]
               end
 
@@ -41,26 +44,28 @@ module Legion
               end
 
               def delete(trace_id)
-                @traces.delete(trace_id)
-                @associations.delete(trace_id)
-                @associations.each_value { |links| links.delete(trace_id) }
-                @dirty_ids.delete(trace_id)
-                @deleted_ids << trace_id
-                @assoc_dirty = true
+                @mutex.synchronize do
+                  @traces.delete(trace_id)
+                  @associations.delete(trace_id)
+                  @associations.each_value { |links| links.delete(trace_id) }
+                  @dirty_ids.delete(trace_id)
+                  @deleted_ids << trace_id
+                  @assoc_dirty = true
+                end
               end
 
               def retrieve_by_type(type, min_strength: 0.0, limit: 100)
-                @traces.values
-                       .select { |t| t[:trace_type] == type && t[:strength] >= min_strength }
-                       .sort_by { |t| -t[:strength] }
-                       .first(limit)
+                snapshot = @mutex.synchronize { @traces.values }
+                snapshot.select { |t| t[:trace_type] == type && t[:strength] >= min_strength }
+                        .sort_by { |t| -t[:strength] }
+                        .first(limit)
               end
 
               def retrieve_by_domain(domain_tag, min_strength: 0.0, limit: 100)
-                @traces.values
-                       .select { |t| t[:domain_tags].include?(domain_tag) && t[:strength] >= min_strength }
-                       .sort_by { |t| -t[:strength] }
-                       .first(limit)
+                snapshot = @mutex.synchronize { @traces.values }
+                snapshot.select { |t| t[:domain_tags].include?(domain_tag) && t[:strength] >= min_strength }
+                        .sort_by { |t| -t[:strength] }
+                        .first(limit)
               end
 
               def retrieve_associated(trace_id, min_strength: 0.0, limit: 20)
@@ -77,30 +82,36 @@ module Legion
               def record_coactivation(trace_id_a, trace_id_b)
                 return if trace_id_a == trace_id_b
 
-                @associations[trace_id_a] ||= {}
-                @associations[trace_id_b] ||= {}
-                @associations[trace_id_a][trace_id_b] = (@associations[trace_id_a][trace_id_b] || 0) + 1
-                @associations[trace_id_b][trace_id_a] = (@associations[trace_id_b][trace_id_a] || 0) + 1
+                @mutex.synchronize do
+                  @associations[trace_id_a] ||= {}
+                  @associations[trace_id_b] ||= {}
+                  @associations[trace_id_a][trace_id_b] = (@associations[trace_id_a][trace_id_b] || 0) + 1
+                  @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
-                @assoc_dirty = true
+                  threshold = Helpers::Trace::COACTIVATION_THRESHOLD
+                  link_traces(trace_id_a, trace_id_b) if @associations[trace_id_a][trace_id_b] >= threshold
+                  @assoc_dirty = true
+                end
               end
 
               def all_traces(min_strength: 0.0)
-                @traces.values.select { |t| t[:strength] >= min_strength }
+                snapshot = @mutex.synchronize { @traces.values }
+                snapshot.select { |t| t[:strength] >= min_strength }
               end
 
               def count
                 @traces.size
               end
 
+              def synchronize(&) = @mutex.synchronize(&)
+
               def firmware_traces
                 retrieve_by_type(:firmware)
               end
 
               def walk_associations(start_id:, max_hops: 12, min_strength: 0.1)
-                return [] unless @traces.key?(start_id)
+                snapshot = @mutex.synchronize { @traces.dup }
+                return [] unless snapshot.key?(start_id)
 
                 results = []
                 visited = Set.new([start_id])
@@ -108,13 +119,13 @@ module Legion
 
                 until queue.empty?
                   current_id, depth, path = queue.shift
-                  current = @traces[current_id]
+                  current = snapshot[current_id]
                   next unless current
 
                   current[:associated_traces].each do |neighbor_id|
                     next if visited.include?(neighbor_id)
 
-                    neighbor = @traces[neighbor_id]
+                    neighbor = snapshot[neighbor_id]
                     next unless neighbor
                     next unless neighbor[:strength] >= min_strength
 
@@ -130,13 +141,15 @@ module Legion
 
               # Write dirty traces to cache as individual keys
               def flush
-                flush_deleted
-                flush_traces
-                flush_associations
-                flush_index
-                Legion::Logging.debug "[memory] CacheStore flushed #{@dirty_ids.size} dirty traces (#{@traces.size} total)"
-                @dirty_ids.clear
-                @deleted_ids.clear
+                @mutex.synchronize do
+                  flush_deleted
+                  flush_traces
+                  flush_associations
+                  flush_index
+                  Legion::Logging.debug "[memory] CacheStore flushed #{@dirty_ids.size} dirty traces (#{@traces.size} total)"
+                  @dirty_ids.clear
+                  @deleted_ids.clear
+                end
               end
 
               # Pull latest state from cache
@@ -195,12 +208,16 @@ module Legion
 
                 Legion::Cache.set(ASSOC_KEY, strip_default_procs(@associations), TTL)
                 @assoc_dirty = false
+              rescue StandardError => e
+                Legion::Logging.warn "[memory] CacheStore flush_associations failed (#{@associations.size} entries): #{e.message}" if defined?(Legion::Logging)
               end
 
               def flush_index
                 return if @dirty_ids.empty? && @deleted_ids.empty?
 
                 Legion::Cache.set(INDEX_KEY, @traces.keys, TTL)
+              rescue StandardError => e
+                Legion::Logging.warn "[memory] CacheStore flush_index failed (#{@traces.size} traces): #{e.message}" if defined?(Legion::Logging)
               end
 
               def strip_default_procs(hash)

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

@@ -14,13 +14,14 @@ module Legion
               attr_reader :traces, :associations
 
               def initialize
+                @mutex = Mutex.new
                 @traces = {}
                 @associations = Hash.new { |h, k| h[k] = Hash.new(0) }
                 load_from_local
               end
 
               def store(trace)
-                @traces[trace[:trace_id]] = trace
+                @mutex.synchronize { @traces[trace[:trace_id]] = trace }
                 trace[:trace_id]
               end
 
@@ -29,23 +30,25 @@ module Legion
               end
 
               def delete(trace_id)
-                @traces.delete(trace_id)
-                @associations.delete(trace_id)
-                @associations.each_value { |links| links.delete(trace_id) }
+                @mutex.synchronize do
+                  @traces.delete(trace_id)
+                  @associations.delete(trace_id)
+                  @associations.each_value { |links| links.delete(trace_id) }
+                end
               end
 
               def retrieve_by_type(type, min_strength: 0.0, limit: 100)
-                @traces.values
-                       .select { |t| t[:trace_type] == type && t[:strength] >= min_strength }
-                       .sort_by { |t| -t[:strength] }
-                       .first(limit)
+                snapshot = @mutex.synchronize { @traces.values }
+                snapshot.select { |t| t[:trace_type] == type && t[:strength] >= min_strength }
+                        .sort_by { |t| -t[:strength] }
+                        .first(limit)
               end
 
               def retrieve_by_domain(domain_tag, min_strength: 0.0, limit: 100)
-                @traces.values
-                       .select { |t| t[:domain_tags].include?(domain_tag) && t[:strength] >= min_strength }
-                       .sort_by { |t| -t[:strength] }
-                       .first(limit)
+                snapshot = @mutex.synchronize { @traces.values }
+                snapshot.select { |t| t[:domain_tags].include?(domain_tag) && t[:strength] >= min_strength }
+                        .sort_by { |t| -t[:strength] }
+                        .first(limit)
               end
 
               def retrieve_associated(trace_id, min_strength: 0.0, limit: 20)
@@ -62,30 +65,33 @@ module Legion
               def record_coactivation(trace_id_a, trace_id_b)
                 return if trace_id_a == trace_id_b
 
-                @associations[trace_id_a][trace_id_b] += 1
-                @associations[trace_id_b][trace_id_a] += 1
-
-                threshold = Helpers::Trace::COACTIVATION_THRESHOLD
-
-                return unless @associations[trace_id_a][trace_id_b] >= threshold
+                @mutex.synchronize do
+                  @associations[trace_id_a][trace_id_b] += 1
+                  @associations[trace_id_b][trace_id_a] += 1
 
-                link_traces(trace_id_a, trace_id_b)
+                  threshold = Helpers::Trace::COACTIVATION_THRESHOLD
+                  link_traces(trace_id_a, trace_id_b) if @associations[trace_id_a][trace_id_b] >= threshold
+                end
               end
 
               def all_traces(min_strength: 0.0)
-                @traces.values.select { |t| t[:strength] >= min_strength }
+                snapshot = @mutex.synchronize { @traces.values }
+                snapshot.select { |t| t[:strength] >= min_strength }
               end
 
               def count
                 @traces.size
               end
 
+              def synchronize(&) = @mutex.synchronize(&)
+
               def firmware_traces
                 retrieve_by_type(:firmware)
               end
 
               def walk_associations(start_id:, max_hops: 12, min_strength: 0.1)
-                return [] unless @traces.key?(start_id)
+                snapshot = @mutex.synchronize { @traces.dup }
+                return [] unless snapshot.key?(start_id)
 
                 results  = []
                 visited  = Set.new([start_id])
@@ -93,12 +99,12 @@ module Legion
 
                 until queue.empty?
                   current_id, depth, path = queue.shift
-                  next unless (current = @traces[current_id])
+                  next unless (current = snapshot[current_id])
 
                   current[:associated_traces].each do |neighbor_id|
                     next if visited.include?(neighbor_id)
 
-                    neighbor = @traces[neighbor_id]
+                    neighbor = snapshot[neighbor_id]
                     next unless neighbor
                     next unless neighbor[:strength] >= min_strength
 
@@ -117,8 +123,9 @@ module Legion
                 return unless Legion::Data::Local.connection.table_exists?(:memory_traces)
 
                 db = Legion::Data::Local.connection
+                traces_snapshot = @mutex.synchronize { @traces.dup }
 
-                @traces.each_value do |trace|
+                traces_snapshot.each_value do |trace|
                   row = serialize_trace_for_db(trace)
                   existing = db[:memory_traces].where(trace_id: trace[:trace_id]).first
                   if existing
@@ -129,7 +136,7 @@ module Legion
                 end
 
                 db_trace_ids = db[:memory_traces].select_map(:trace_id)
-                memory_trace_ids = @traces.keys
+                memory_trace_ids = traces_snapshot.keys
                 stale_ids = db_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/runners/consolidation.rb

@@ -86,6 +86,13 @@ module Legion
                 { linked: true }
               end
 
+              def enforce_quota(store: nil, **)
+                store ||= default_store
+                quota = Quota.new
+                quota.enforce!(store)
+                { success: true, within_limits: quota.within_limits?(store) }
+              end
+
               def erase_by_type(type:, store: nil, **)
                 store ||= default_store
                 type = type.to_sym

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.6'
+        VERSION = '0.1.9'
       end
     end
   end

data/spec/legion/extensions/agentic/memory/archaeology/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/archaeology/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Archaeology::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Archaeology::Runners::CognitiveArchaeology) }
+  it { expect(actor.runner_function).to eq('decay_all') }
+  it { expect(actor.time).to eq(120) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/compression/actors/maintenance_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/compression/actors/maintenance'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Compression::Actors::Maintenance do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Compression::Runners::CognitiveCompression) }
+  it { expect(actor.runner_function).to eq('compress_all') }
+  it { expect(actor.time).to eq(300) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/echo/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/echo/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Echo::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Echo::Runners::CognitiveEcho) }
+  it { expect(actor.runner_function).to eq('decay_all') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/echo_chamber/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/echo_chamber/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::EchoChamber::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::EchoChamber::Runners::CognitiveEchoChamber) }
+  it { expect(actor.runner_function).to eq('decay_all') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/immune_memory/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/immune_memory/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::ImmuneMemory::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::ImmuneMemory::Runners::CognitiveImmuneMemory) }
+  it { expect(actor.runner_function).to eq('decay_all') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/nostalgia/actors/maintenance_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/nostalgia/actors/maintenance'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Nostalgia::Actors::Maintenance do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Nostalgia::Runners::Recall) }
+  it { expect(actor.runner_function).to eq('age_memories') }
+  it { expect(actor.time).to eq(120) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/palimpsest/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/palimpsest/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Palimpsest::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Palimpsest::Runners::CognitivePalimpsest) }
+  it { expect(actor.runner_function).to eq('decay_all_ghosts') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/reserve/actors/maintenance_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/reserve/actors/maintenance'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Reserve::Actors::Maintenance do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Reserve::Runners::CognitiveReserve) }
+  it { expect(actor.runner_function).to eq('update_cognitive_reserve') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/semantic_priming/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/semantic_priming/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::SemanticPriming::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::SemanticPriming::Runners::SemanticPriming) }
+  it { expect(actor.runner_function).to eq('decay') }
+  it { expect(actor.time).to eq(30) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/semantic_satiation/actors/recovery_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/semantic_satiation/actors/recovery'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::SemanticSatiation::Actors::Recovery do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::SemanticSatiation::Runners::SemanticSatiation) }
+  it { expect(actor.runner_function).to eq('recover') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/trace/actors/quota_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/trace/actors/quota'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Actor::Quota do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Trace::Runners::Consolidation) }
+  it { expect(actor.runner_function).to eq('enforce_quota') }
+  it { expect(actor.time).to eq(300) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end