lex-agentic-memory 0.1.8 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9df4d40acddf847a91c9b778461c54d9ce0353a071f54d232e12a249df899b01
-  data.tar.gz: a41a803969657a0029fae7262f8889ecd2641483aed0dc628d3482990aa3c067
+  metadata.gz: 44a4999991835bdd28a7189717f6a53f38928644a86c7f653517331687659901
+  data.tar.gz: b3aeb50fddc4b82580430829ec924549690b8dd6171be74ff9213db40b135888
 SHA512:
-  metadata.gz: c8e84baa2ab49fa7b8c79e6c0b572c5ab1f051b69ead4220435492e46a851b4052f67dd19b40ed3a0097c18895d9349212b34e9b50e3e66be00e6980d243b20a
-  data.tar.gz: 66c47eb11ed41a51e284681d82c6f5936a88771fd218cc74ffeec913605ff9b07507af8522d490fa6eeeb4edb316d97c9f1bb157019bcca1801632e4f575c227
+  metadata.gz: 32930b8b8092925f0793eef8ae8b1a6764d50cbc9692bb2952c46fb969137b41609eed96ecb455fdc7d0518373ebd912075eff8ac47c4deb8e97e1fc9176962b
+  data.tar.gz: a142cbf70545c4f80717ddda3d81abab26a1cc2cf5d8e40584625a416629d1551991d716fc6a9592fff194b523b0ebed2963be24fa414039cf11bdb3c934e60a

data/CHANGELOG.md

@@ -1,6 +1,29 @@
 # Changelog
 
-## [Unreleased]
+## [0.1.11] - 2026-03-25
+
+### Added
+- `Helpers::HotTier` module: Redis hot-tier cache in front of PostgresStore using `Legion::Cache::RedisHash`. Stores traces as Redis hashes with 24-hour TTL, maintains a sorted-set index per tenant, and provides `cache_trace`, `fetch_trace`, and `evict_trace` operations
+- `PostgresStore#retrieve` checks hot tier first; falls through to DB on miss and populates hot tier on DB hit
+- `PostgresStore#store` writes through to hot tier after successful DB write
+- `PostgresStore#delete` evicts from hot tier before DB delete
+- `PostgresStore#update` evicts stale hot-tier entry after DB update
+- 32 new specs covering HotTier interface, serialize/deserialize round-trip, availability guard, and all four PostgresStore integration points
+
+## [0.1.10] - 2026-03-25
+
+### Added
+- `Helpers::PostgresStore`: write-through durable store backed by Legion::Data (PostgreSQL or MySQL), scoped by tenant_id. Implements full store interface: store, retrieve, retrieve_by_type, retrieve_by_domain, all_traces, delete, update, record_coactivation, associations_for, walk_associations, delete_lowest_confidence, delete_least_recently_used, firmware_traces, flush (no-op), db_ready?
+- `create_store` in `Trace` module now selects PostgresStore when a PostgreSQL or MySQL connection is available with both required tables; falls back to CacheStore or in-memory Store
+- `postgres_available?` and `resolve_tenant_id` private helpers on `Trace` module
+- 46 new specs covering all PostgresStore methods using an in-memory SQLite DB
+
+## [0.1.9] - 2026-03-25
+
+### Added
+- Periodic actors for 10 sub-modules: Archaeology (decay), Compression (maintenance), Echo (decay), EchoChamber (decay), ImmuneMemory (decay), Nostalgia (maintenance), Palimpsest (decay), Reserve (maintenance), SemanticPriming (decay), SemanticSatiation (recovery) (closes #1)
+- Quota enforcement actor for Trace (runs every 300s, calls enforce_quota) (closes #2)
+- Runner methods: `decay_all` for Archaeology and EchoChamber, `enforce_quota` for Trace::Consolidation
 
 ### Fixed
 - Add Mutex synchronization to trace Store and CacheStore for thread safety during concurrent tick cycles

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Archaeology
+          module Actors
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class = Runners::CognitiveArchaeology
+              def runner_function = 'decay_all'
+              def time = 120
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/archaeology/runners/cognitive_archaeology.rb

@@ -53,6 +53,12 @@ module Legion
                   count: results.size }
               end
 
+              def decay_all(rate: Helpers::Constants::PRESERVATION_DECAY, engine: nil, **)
+                eng = resolve_engine(engine)
+                eng.decay_all!(rate: rate)
+                { success: true, remaining: eng.all_artifacts.size }
+              end
+
               def archaeology_status(engine: nil, **)
                 eng = resolve_engine(engine)
                 { success: true, report: eng.archaeology_report }

data/lib/legion/extensions/agentic/memory/compression/actors/maintenance.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Compression
+          module Actors
+            class Maintenance < Legion::Extensions::Actors::Every
+              def runner_class = Runners::CognitiveCompression
+              def runner_function = 'compress_all'
+              def time = 300
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Echo
+          module Actors
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class = Runners::CognitiveEcho
+              def runner_function = 'decay_all'
+              def time = 60
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module EchoChamber
+          module Actors
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class = Runners::CognitiveEchoChamber
+              def runner_function = 'decay_all'
+              def time = 60
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/echo_chamber/runners/cognitive_echo_chamber.rb

@@ -65,6 +65,12 @@ module Legion
                 { success: true, echoes: echoes.map(&:to_h), count: echoes.size }
               end
 
+              def decay_all(engine: nil, **)
+                eng = engine || default_engine
+                eng.decay_all!
+                { success: true, **eng.echo_report }
+              end
+
               def chamber_status(engine: nil, **)
                 eng = engine || default_engine
                 { success: true, **eng.echo_report }

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module ImmuneMemory
+          module Actors
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class = Runners::CognitiveImmuneMemory
+              def runner_function = 'decay_all'
+              def time = 60
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/nostalgia/actors/maintenance.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Nostalgia
+          module Actors
+            class Maintenance < Legion::Extensions::Actors::Every
+              def runner_class = Runners::Recall
+              def runner_function = 'age_memories'
+              def time = 120
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Palimpsest
+          module Actors
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class = Runners::CognitivePalimpsest
+              def runner_function = 'decay_all_ghosts'
+              def time = 60
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/reserve/actors/maintenance.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Reserve
+          module Actors
+            class Maintenance < Legion::Extensions::Actors::Every
+              def runner_class = Runners::CognitiveReserve
+              def runner_function = 'update_cognitive_reserve'
+              def time = 60
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module SemanticPriming
+          module Actors
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class = Runners::SemanticPriming
+              def runner_function = 'decay'
+              def time = 30
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/semantic_satiation/actors/recovery.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module SemanticSatiation
+          module Actors
+            class Recovery < Legion::Extensions::Actors::Every
+              def runner_class = Runners::SemanticSatiation
+              def runner_function = 'recover'
+              def time = 60
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Trace
+          module Actor
+            class Quota < Legion::Extensions::Actors::Every
+              def runner_class = Runners::Consolidation
+              def runner_function = 'enforce_quota'
+              def time = 300
+              def use_runner? = false
+              def check_subtask? = false
+              def generate_task? = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Trace
+          module Helpers
+            module HotTier
+              HOT_TTL = 86_400 # 24 hours
+
+              module_function
+
+              # Cache a trace in the Redis hot tier.
+              def cache_trace(trace, tenant_id: nil)
+                return unless available?
+
+                tid = tenant_id || trace[:partition_id]
+                key = trace_key(tid, trace[:trace_id])
+                data = serialize_trace(trace)
+                Legion::Cache::RedisHash.hset(key, data)
+                Legion::Cache::RedisHash.expire(key, HOT_TTL)
+
+                index_key = "legion:tier:hot:#{tid}"
+                Legion::Cache::RedisHash.zadd(index_key, Time.now.to_f, trace[:trace_id])
+              end
+
+              # Fetch a trace from the hot tier. Returns a deserialized trace hash or nil on miss.
+              def fetch_trace(trace_id, tenant_id: nil)
+                return nil unless available?
+
+                key = trace_key(tenant_id, trace_id)
+                data = Legion::Cache::RedisHash.hgetall(key)
+                return nil if data.nil? || data.empty?
+
+                deserialize_trace(data)
+              end
+
+              # Evict a trace from the hot tier and remove it from the sorted-set index.
+              def evict_trace(trace_id, tenant_id: nil)
+                return unless available?
+
+                key = trace_key(tenant_id, trace_id)
+                Legion::Cache.delete(key)
+
+                index_key = "legion:tier:hot:#{tenant_id}"
+                Legion::Cache::RedisHash.zrem(index_key, trace_id)
+              end
+
+              # Returns true when the RedisHash module is loaded and Redis is reachable.
+              def available?
+                defined?(Legion::Cache::RedisHash) &&
+                  Legion::Cache::RedisHash.redis_available?
+              rescue StandardError
+                false
+              end
+
+              # Build the namespaced Redis key for a trace.
+              def trace_key(tenant_id, trace_id)
+                "legion:trace:#{tenant_id}:#{trace_id}"
+              end
+
+              # Serialize a trace hash to a string-only flat hash suitable for Redis HSET.
+              def serialize_trace(trace)
+                {
+                  'trace_id'        => trace[:trace_id].to_s,
+                  'trace_type'      => trace[:trace_type].to_s,
+                  'content_payload' => trace[:content_payload].to_s,
+                  'strength'        => trace[:strength].to_s,
+                  'peak_strength'   => trace[:peak_strength].to_s,
+                  'confidence'      => trace[:confidence].to_s,
+                  'storage_tier'    => 'hot',
+                  'partition_id'    => trace[:partition_id].to_s,
+                  'last_reinforced' => (trace[:last_reinforced] || Time.now).to_s
+                }
+              end
+
+              # Deserialize a Redis string-hash back to a typed trace hash.
+              def deserialize_trace(data)
+                {
+                  trace_id:        data['trace_id'],
+                  trace_type:      data['trace_type']&.to_sym,
+                  content_payload: data['content_payload'],
+                  strength:        data['strength']&.to_f,
+                  peak_strength:   data['peak_strength']&.to_f,
+                  confidence:      data['confidence']&.to_f,
+                  storage_tier:    :hot,
+                  partition_id:    data['partition_id'],
+                  last_reinforced: data['last_reinforced']
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end