lex-agentic-memory 0.1.34 → 0.1.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 606b711547732f1f697b57ce2392509c2774397c725b51f87baeaee591cf2ae2
-  data.tar.gz: f9f704beca9f4f33c8d71ad54627ef400561819898aeebf06c0097a0c0a535b1
+  metadata.gz: f135722a81c15e36374e61e6348db1f421db9b4fc5257bc2915d8526a9b7a145
+  data.tar.gz: 86dfb884036c9d7d8617a3a785b6b35c6cc0db413b60a9866aad04ad3e899d59
 SHA512:
-  metadata.gz: 35f855a01efbfb5b29f23fe12f92e89082a3a4c8001b149dd16f6ccd648bc9d67a699755230e5b08c4a86f1147522f86b71d5fea3e31f3842448c20e4af3d094
-  data.tar.gz: 8e9afdf79c62437fefe856a61a0432d1574a7fba7dadab51c4a6b19a0e8a6d6a3658a19fbfa725d5cdb5c4c8de300169818aeee15c1e204e9cf7ff15a9cf12d3
+  metadata.gz: bd080984039d516a8980ed88723a34f6f8738439f55a921e572cbba852f73af3c48010cffc9fec5b134305f2e7d0f7d774d032bf8a41e88003b9f7cef8cba34a
+  data.tar.gz: 5e2fbe8775082a3e64533acce43937923b0e5f6c97cc7bcb623fc4a42f9bc21be513f824fef9ea80f13afb392da5e30648b68fd6e9a9fbadd1e1eeed985259b5

data/CHANGELOG.md

@@ -1,10 +1,20 @@
 # Changelog
 
+## [0.1.36] - 2026-05-17
+### Fixed
+- `PostgresStore#db_ready?` now checks `Legion::Data.can_write?(:memory_traces)` before attempting writes, preventing `PG::InsufficientPrivilege` errors when connected with a read-only role.
+- `Trace.postgres_available?` also checks INSERT privilege so `create_store` correctly falls back to a local store instead of selecting PostgresStore and failing at runtime.
+
 ## [0.1.34] - 2026-05-08
 ### Fixed
 - Deferred GAIA heartbeat maintenance no longer initializes the shared trace store just to return a deferred summary, avoiding idle local trace table scans.
 - `Store#parse_db_content` now returns bracket-prefixed raw trace/log text without JSON parse attempts or malformed JSON debug noise while still parsing real JSON objects and arrays.
 
+## [0.1.35] - 2026-05-15
+### Fixed
+- Normalize trace affect fields before persisting through in-memory, cache, local SQLite, and Postgres stores so string-backed values do not crash or silently collapse to `0.0`.
+- Preserve numeric `emotional_valence` across local trace persistence and normalize legacy structured payloads when they are reloaded.
+
 ## [0.1.33] - 2026-05-07
 ### Fixed
 - `PostgresStore#parse_json_or_raw` no longer attempts JSON parse on plain-text content — checks for `{`/`[` prefix before parsing, eliminating ERROR log spam during bulk reads with mixed content types

data/lib/legion/extensions/agentic/memory/archaeology/helpers/archaeology_engine.rb

@@ -164,9 +164,9 @@ module Legion
                 site.survey.merge(
                   depth_progress: depth_progress(site),
                   artifact_types: site.artifacts_found
-                                  .each_with_object(Hash.new(0)) do |a, h|
-                                    h[a.artifact_type] += 1
-                                  end
+                                      .each_with_object(Hash.new(0)) do |a, h|
+                                        h[a.artifact_type] += 1
+                                      end
                 )
               end
 

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

@@ -38,11 +38,12 @@ module Legion
               end
 
               def store(trace)
+                normalized_trace = Helpers::Trace.normalize_trace_affect(trace)
                 @mutex.synchronize do
-                  @traces[trace[:trace_id]] = trace
-                  @dirty_ids << trace[:trace_id]
+                  @traces[normalized_trace[:trace_id]] = normalized_trace
+                  @dirty_ids << normalized_trace[:trace_id]
                 end
-                trace[:trace_id]
+                normalized_trace[:trace_id]
               end
 
               def get(trace_id)

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

@@ -27,15 +27,16 @@ module Legion
               def store(trace)
                 return nil unless db_ready?
 
-                row = serialize_trace(trace)
+                normalized_trace = Helpers::Trace.normalize_trace_affect(trace)
+                row = serialize_trace(normalized_trace)
                 ds  = db[TRACES_TABLE]
                 if db.adapter_scheme == :mysql2
                   ds.insert_conflict(update: row.except(:trace_id)).insert(row)
                 else
                   ds.insert_conflict(target: :trace_id, update: row.except(:trace_id)).insert(row)
                 end
-                HotTier.cache_trace(trace, tenant_id: @tenant_id, agent_id: @agent_id) if HotTier.available?
-                trace[:trace_id]
+                HotTier.cache_trace(normalized_trace, tenant_id: @tenant_id, agent_id: @agent_id) if HotTier.available?
+                normalized_trace[:trace_id]
               rescue StandardError => e
                 log_warn("store failed: #{e.message}")
                 nil
@@ -263,12 +264,14 @@ module Legion
               # No-op — this store is write-through; nothing to flush.
               def flush; end
 
-              # Returns true when both required tables exist in the connected DB.
+              # Returns true when both required tables exist and the user has INSERT privilege on both.
               def db_ready?
                 defined?(Legion::Data) &&
                   Legion::Data.respond_to?(:connection) &&
                   Legion::Data.connection&.table_exists?(TRACES_TABLE) &&
-                  Legion::Data.connection.table_exists?(ASSOCIATIONS_TABLE)
+                  Legion::Data.connection.table_exists?(ASSOCIATIONS_TABLE) &&
+                  Legion::Data.can_write?(TRACES_TABLE) &&
+                  Legion::Data.can_write?(ASSOCIATIONS_TABLE)
               rescue StandardError => e
                 log.error "[trace_persistence] db_ready?: #{e.message}"
                 false
@@ -299,7 +302,7 @@ module Legion
                 tags    = trace[:domain_tags]
                 assocs  = trace[:associated_traces]
                 conf    = trace[:confidence]
-                ev      = trace[:emotional_valence]
+                ev      = Helpers::Trace.normalize_emotional_valence(trace[:emotional_valence])
 
                 {
                   trace_id:                trace[:trace_id],
@@ -314,8 +317,8 @@ module Legion
                   strength:                trace[:strength],
                   peak_strength:           trace[:peak_strength],
                   base_decay_rate:         trace[:base_decay_rate],
-                  emotional_valence:       ev.is_a?(Numeric) ? ev.to_f : 0.0,
-                  emotional_intensity:     trace[:emotional_intensity],
+                  emotional_valence:       ev,
+                  emotional_intensity:     Helpers::Trace.normalize_emotional_intensity(trace[:emotional_intensity]),
                   origin:                  sanitize_pg_string(trace[:origin].to_s),
                   source_agent_id:         sanitize_pg_string(trace[:source_agent_id]),
                   storage_tier:            sanitize_pg_string(trace[:storage_tier].to_s),

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

@@ -29,7 +29,7 @@ module Legion
               end
 
               def store(trace)
-                persisted_trace = trace.dup
+                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
@@ -120,7 +120,7 @@ module Legion
                 snapshot = Array(traces).each_with_object({}) do |trace, memo|
                   next unless trace.is_a?(Hash) && trace[:trace_id]
 
-                  restored = trace.dup
+                  restored = Helpers::Trace.normalize_trace_affect(trace)
                   restored[:partition_id] ||= @partition_id
                   memo[restored[:trace_id]] = restored
                 end
@@ -294,7 +294,7 @@ module Legion
                   strength:                trace[:strength],
                   peak_strength:           trace[:peak_strength],
                   base_decay_rate:         trace[:base_decay_rate],
-                  emotional_valence:       trace[:emotional_valence].is_a?(Hash) ? ::JSON.generate(trace[:emotional_valence]) : nil,
+                  emotional_valence:       Helpers::Trace.normalize_emotional_valence(trace[:emotional_valence]).to_s,
                   emotional_intensity:     trace[:emotional_intensity],
                   domain_tags:             trace[:domain_tags].is_a?(Array) ? ::JSON.generate(trace[:domain_tags]) : nil,
                   origin:                  trace[:origin].to_s,
@@ -325,7 +325,7 @@ module Legion
                   strength:                row[:strength],
                   peak_strength:           row[:peak_strength],
                   base_decay_rate:         row[:base_decay_rate],
-                  emotional_valence:       parse_db_json(row[:emotional_valence], 'emotional_valence', symbolize: true) { 0.0 },
+                  emotional_valence:       deserialize_emotional_valence(row[:emotional_valence]),
                   emotional_intensity:     row[:emotional_intensity],
                   domain_tags:             parse_db_json(row[:domain_tags], 'domain_tags') { [] },
                   origin:                  row[:origin]&.to_sym,
@@ -364,6 +364,12 @@ module Legion
                 %w[{ [ " ]].include?(first_array_value)
               end
 
+              def deserialize_emotional_valence(raw)
+                return 0.0 if raw.nil? || raw.to_s.strip.empty?
+
+                Helpers::Trace.normalize_emotional_valence(raw)
+              end
+
               def parse_db_json(raw, field, symbolize: false, &default)
                 return default&.call if raw.nil? || raw.to_s.strip.empty?
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'securerandom'
 
 module Legion
@@ -48,6 +49,7 @@ module Legion
               ASSOCIATION_BONUS       = 0.15  # bonus for Hebbian-associated traces
               MAX_ASSOCIATIONS        = 20    # max Hebbian links per trace
               COACTIVATION_THRESHOLD  = 3     # co-activations before Hebbian link forms
+              VALENCE_SCALAR_KEYS     = %i[valence emotional_valence sentiment polarity score].freeze
 
               module_function
 
@@ -59,6 +61,10 @@ module Legion
                 raise ArgumentError, "invalid origin: #{origin}" unless ORIGINS.include?(origin)
 
                 now = Time.now.utc
+                emotional_context = normalize_trace_affect(
+                  emotional_valence:   emotional_valence,
+                  emotional_intensity: emotional_intensity
+                )
 
                 {
                   trace_id:                SecureRandom.uuid,
@@ -68,8 +74,8 @@ module Legion
                   strength:                STARTING_STRENGTHS[type],
                   peak_strength:           STARTING_STRENGTHS[type],
                   base_decay_rate:         BASE_DECAY_RATES[type],
-                  emotional_valence:       emotional_valence.clamp(-1.0, 1.0),
-                  emotional_intensity:     emotional_intensity.clamp(0.0, 1.0),
+                  emotional_valence:       emotional_context[:emotional_valence],
+                  emotional_intensity:     emotional_context[:emotional_intensity],
                   domain_tags:             Array(domain_tags),
                   origin:                  origin,
                   source_agent_id:         source_agent_id,
@@ -98,11 +104,89 @@ module Legion
                 true
               end
 
+              def normalize_trace_affect(trace)
+                normalized = trace.dup
+                normalized[:emotional_valence] = normalize_emotional_valence(normalized[:emotional_valence])
+                normalized[:emotional_intensity] = normalize_emotional_intensity(normalized[:emotional_intensity])
+                normalized
+              end
+
+              def normalize_emotional_valence(value)
+                normalize_scalar(value, min: -1.0, max: 1.0, hash_keys: VALENCE_SCALAR_KEYS)
+              end
+
+              def normalize_emotional_intensity(value)
+                normalize_scalar(value, min: 0.0, max: 1.0)
+              end
+
               def default_partition_id
                 Legion::Settings.dig(:agent, :id) || 'default'
               rescue StandardError => _e
                 'default'
               end
+
+              def normalize_scalar(value, min:, max:, hash_keys: [])
+                case value
+                when Numeric
+                  value.to_f.clamp(min, max)
+                when String
+                  normalize_string_scalar(value, min: min, max: max, hash_keys: hash_keys)
+                when Hash
+                  normalize_hash_scalar(value, min: min, max: max, hash_keys: hash_keys)
+                else
+                  0.0
+                end
+              end
+
+              def normalize_string_scalar(value, min:, max:, hash_keys:)
+                stripped = value.strip
+                return 0.0 if stripped.empty?
+
+                Float(stripped).clamp(min, max)
+              rescue ArgumentError, TypeError => e
+                Legion::Logging.debug("[memory][trace] normalize_string_scalar fallback: #{e.message}")
+                parsed = parse_structured_scalar(stripped)
+                return normalize_scalar(parsed, min: min, max: max, hash_keys: hash_keys) if parsed
+
+                0.0
+              end
+
+              def normalize_hash_scalar(value, min:, max:, hash_keys:)
+                symbolized = symbolize_keys(value)
+                scalar_value = hash_keys.lazy.map { |key| symbolized[key] }.find { |candidate| scalar_candidate?(candidate) }
+                return normalize_scalar(scalar_value, min: min, max: max, hash_keys: hash_keys) if scalar_candidate?(scalar_value)
+
+                numeric_values = symbolized.values.select { |candidate| scalar_candidate?(candidate) }
+                return normalize_scalar(numeric_values.first, min: min, max: max, hash_keys: hash_keys) if numeric_values.one?
+
+                0.0
+              end
+
+              def parse_structured_scalar(value)
+                return unless value.start_with?('{', '[')
+
+                ::JSON.parse(value)
+              rescue ::JSON::ParserError => e
+                Legion::Logging.debug("[memory][trace] parse_structured_scalar ignored: #{e.message}")
+                nil
+              end
+
+              def scalar_candidate?(value)
+                value.is_a?(Numeric) || value.is_a?(String)
+              end
+
+              def symbolize_keys(value)
+                case value
+                when Hash
+                  value.each_with_object({}) do |(key, nested), memo|
+                    memo[key.to_sym] = symbolize_keys(nested)
+                  end
+                when Array
+                  value.map { |nested| symbolize_keys(nested) }
+                else
+                  value
+                end
+              end
             end
           end
         end

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

@@ -79,7 +79,9 @@ module Legion
                 Legion::Data.connection &&
                 %i[postgres mysql2].include?(Legion::Data.connection.adapter_scheme) &&
                 Legion::Data.connection.table_exists?(:memory_traces) &&
-                Legion::Data.connection.table_exists?(:memory_associations)
+                Legion::Data.connection.table_exists?(:memory_associations) &&
+                Legion::Data.can_write?(:memory_traces) &&
+                Legion::Data.can_write?(:memory_associations)
             rescue StandardError => _e
               false
             end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.34'
+        VERSION = '0.1.36'
       end
     end
   end

data/spec/legion/extensions/agentic/memory/hologram/helpers/hologram_engine_spec.rb

@@ -65,6 +65,9 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Hologram::Helpers::HologramE
     let(:fragments) { engine.fragment_hologram(hologram_id: hologram.id, count: 4) }
 
     it 'returns success: true when sufficient fragments are used' do
+      # Enhance all fragments to guarantee they exceed the reconstruction threshold
+      # regardless of the random completeness assigned during fragmentation.
+      fragments.each { |f| f.enhance!(0.5) }
       ids = fragments.select(&:sufficient?).map(&:id)
       result = engine.reconstruct_from_fragments(hologram_id: hologram.id, fragment_ids: ids)
       expect(result[:success]).to be true

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

@@ -81,8 +81,11 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::PostgresStor
   end
 
   before do
+    allow(Legion::Data).to receive(:respond_to?).and_call_original
     allow(Legion::Data).to receive(:respond_to?).with(:connection).and_return(true)
     allow(Legion::Data).to receive(:connection).and_return(db)
+    allow(Legion::Data).to receive(:can_write?).with(:memory_traces).and_return(true)
+    allow(Legion::Data).to receive(:can_write?).with(:memory_associations).and_return(true)
     # SQLite adapter_scheme is :sqlite — postgres_available? checks for :postgres/:mysql2,
     # but PostgresStore itself only calls db_ready? which just needs the tables to exist.
     allow(db).to receive(:adapter_scheme).and_return(:sqlite)
@@ -109,6 +112,27 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::PostgresStor
       allow(Legion::Data).to receive(:connection).and_raise(StandardError, 'no db')
       expect(store.db_ready?).to be false
     end
+
+    it 'returns false when user lacks INSERT privilege on memory_traces' do
+      allow(Legion::Data).to receive(:can_write?).with(:memory_traces).and_return(false)
+      expect(store.db_ready?).to be false
+    end
+
+    it 'returns true when user has INSERT privilege on memory_traces' do
+      allow(Legion::Data).to receive(:can_write?).with(:memory_traces).and_return(true)
+      expect(store.db_ready?).to be true
+    end
+
+    it 'returns false when user lacks INSERT privilege on memory_associations' do
+      allow(Legion::Data).to receive(:can_write?).with(:memory_associations).and_return(false)
+      expect(store.db_ready?).to be false
+    end
+
+    it 'returns true when user has INSERT privilege on both tables' do
+      allow(Legion::Data).to receive(:can_write?).with(:memory_traces).and_return(true)
+      allow(Legion::Data).to receive(:can_write?).with(:memory_associations).and_return(true)
+      expect(store.db_ready?).to be true
+    end
   end
 
   # --- store insert_conflict syntax ---
@@ -238,6 +262,20 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::PostgresStor
     end
   end
 
+  describe 'emotional valence normalization' do
+    it 'normalizes string-backed affect fields before persisting' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: { event: 'partner ping' })
+      trace[:emotional_valence] = '0.7'
+      trace[:emotional_intensity] = '0.9'
+
+      store.store(trace)
+
+      row = db[:memory_traces].where(trace_id: trace[:trace_id]).first
+      expect(row[:emotional_valence]).to be_within(0.001).of(0.7)
+      expect(row[:emotional_intensity]).to be_within(0.001).of(0.9)
+    end
+  end
+
   # --- retrieve_by_type ---
 
   describe '#retrieve_by_type' do

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

@@ -36,6 +36,30 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::Trace do
       expect(trace[:emotional_intensity]).to eq(0.0)
     end
 
+    it 'normalizes string and structured emotional values safely' do
+      trace = described_class.new_trace(
+        type:                :episodic,
+        content_payload:     { event: 'partner ping' },
+        emotional_valence:   '{:urgency=>0.6, :importance=>0.8}',
+        emotional_intensity: '0.75'
+      )
+
+      expect(trace[:emotional_valence]).to eq(0.0)
+      expect(trace[:emotional_intensity]).to eq(0.75)
+    end
+
+    it 'extracts scalar valence from hash payloads when an explicit valence key exists' do
+      trace = described_class.new_trace(
+        type:                :semantic,
+        content_payload:     { fact: 'test' },
+        emotional_valence:   { valence: 0.4 },
+        emotional_intensity: '2.0'
+      )
+
+      expect(trace[:emotional_valence]).to eq(0.4)
+      expect(trace[:emotional_intensity]).to eq(1.0)
+    end
+
     it 'rejects invalid trace types' do
       expect do
         described_class.new_trace(type: :bogus, content_payload: {})

data/spec/legion/extensions/agentic/memory/trace/local_persistence_spec.rb

@@ -249,12 +249,12 @@ RSpec.describe 'lex-memory local SQLite persistence' do
       expect(fresh.get(episodic_trace[:trace_id])).not_to be_nil
     end
 
-    it 'honors symbolize parsing for JSON hash fields' do
+    it 'restores numeric emotional_valence values from local persistence' do
       trace = trace_helper.new_trace(
         type:              :semantic,
         content_payload:   { fact: 'symbolized' },
         domain_tags:       ['json'],
-        emotional_valence: { joy: 0.8 }
+        emotional_valence: 0.8
       )
       store.store(trace)
       store.save_to_local
@@ -262,8 +262,25 @@ RSpec.describe 'lex-memory local SQLite persistence' do
       fresh = Legion::Extensions::Agentic::Memory::Trace::Helpers::Store.new
       restored = fresh.get(trace[:trace_id])
 
-      expect(restored[:emotional_valence]).to include(joy: 0.8)
-      expect(restored[:emotional_valence]).not_to have_key('joy')
+      expect(restored[:emotional_valence]).to be_within(0.001).of(0.8)
+    end
+
+    it 'normalizes legacy JSON emotional_valence payloads on load' do
+      trace = trace_helper.new_trace(
+        type:            :semantic,
+        content_payload: { fact: 'legacy' },
+        domain_tags:     ['json']
+      )
+      store.store(trace)
+      store.save_to_local
+
+      db = Legion::Data::Local.connection
+      db[:memory_traces].where(trace_id: trace[:trace_id]).update(emotional_valence: '{"valence":0.8}')
+
+      fresh = Legion::Extensions::Agentic::Memory::Trace::Helpers::Store.new
+      restored = fresh.get(trace[:trace_id])
+
+      expect(restored[:emotional_valence]).to be_within(0.001).of(0.8)
     end
 
     it 'restores associations from the database into a fresh store' do

data/spec/legion/extensions/agentic/memory/trace/memory_spec.rb

@@ -34,5 +34,43 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace do
 
       expect(described_class.shared_store).to eq(:shared_store)
     end
+
+    it 'falls back from Postgres when user lacks INSERT privilege on memory_traces' do
+      allow(described_class).to receive(:local_store_available?).and_return(false)
+      allow(described_class).to receive(:configured_trace_store).and_return(nil)
+      allow(described_class).to receive(:resolve_agent_id).and_return('agent-1')
+
+      conn = double('connection', adapter_scheme: :postgres)
+      allow(conn).to receive(:table_exists?).and_return(true)
+      allow(Legion::Data).to receive(:respond_to?).and_call_original
+      allow(Legion::Data).to receive(:respond_to?).with(:connection).and_return(true)
+      allow(Legion::Data).to receive(:connection).and_return(conn)
+      allow(Legion::Data).to receive(:can_write?).with(:memory_traces).and_return(false)
+      allow(Legion::Data).to receive(:can_write?).with(:memory_associations).and_return(true)
+
+      allow(Legion::Cache).to receive(:respond_to?).with(:connected?).and_return(false)
+      allow(described_class::Helpers::Store).to receive(:new).with(partition_id: 'agent-1').and_return(:fallback_store)
+
+      expect(described_class.shared_store).to eq(:fallback_store)
+    end
+
+    it 'falls back from Postgres when user lacks INSERT privilege on memory_associations' do
+      allow(described_class).to receive(:local_store_available?).and_return(false)
+      allow(described_class).to receive(:configured_trace_store).and_return(nil)
+      allow(described_class).to receive(:resolve_agent_id).and_return('agent-1')
+
+      conn = double('connection', adapter_scheme: :postgres)
+      allow(conn).to receive(:table_exists?).and_return(true)
+      allow(Legion::Data).to receive(:respond_to?).and_call_original
+      allow(Legion::Data).to receive(:respond_to?).with(:connection).and_return(true)
+      allow(Legion::Data).to receive(:connection).and_return(conn)
+      allow(Legion::Data).to receive(:can_write?).with(:memory_traces).and_return(true)
+      allow(Legion::Data).to receive(:can_write?).with(:memory_associations).and_return(false)
+
+      allow(Legion::Cache).to receive(:respond_to?).with(:connected?).and_return(false)
+      allow(described_class::Helpers::Store).to receive(:new).with(partition_id: 'agent-1').and_return(:fallback_store)
+
+      expect(described_class.shared_store).to eq(:fallback_store)
+    end
   end
 end

metadata

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