lex-agentic-memory 0.1.33 → 0.1.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01630a8c5fd981fb85c69337d299f71dc215b79b9ce3dca7a9b0aef57545fde3
-  data.tar.gz: 6eb6bd8f8e924aacb9a805561f9f39c0ac18b5d1f559faa7f58a1af3a6d3ad8a
+  metadata.gz: bb940d62021d4a86ed5de171d6b275c9287a9ca727efadd3c60c3a87ca0f921e
+  data.tar.gz: b02842d4a5939e436d7ae4f72cca295839061f5fa4cdbf9b47736f37e462e76e
 SHA512:
-  metadata.gz: 69c12558b2cb6d7a883a9f0bd345ad0934273847b1a44f2dcaed02682a347d9a88dfddbbf6b2ab48d91a418c83f137eb585723dc3aecf19c0a2fb2e1454e7bd3
-  data.tar.gz: 8200e4e37b770d4afa344153cd6dc95b9bd047dd55d34079b1bfc6c87c7f261e0049ee2c6f77e4f2b04bf7455745f88eb06160ad006eb81dda7ee0d2053093f9
+  metadata.gz: e28e286f59952562c8c00ad37cb06f84914f2b93af864cb95a1d9904c218dc72d28bb09a4df049c418f5a66df752a199171c0e553e684c234ae888ab73be24a8
+  data.tar.gz: 12febef87343cde5c4ca8f372c62a6f7d5b053a47ad5362710ee54224be60ceb899f7f0f32eeb65cc9474ebe5b47535731e2f6a3e83a89f3d315c6780774ea77

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [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/client.rb

@@ -18,12 +18,14 @@ module Legion
             attr_reader :store
 
             def initialize(store: nil, **)
-              @default_store = store || Legion::Extensions::Agentic::Memory::Trace.shared_store
+              @default_store = store if store
             end
 
             private
 
-            attr_reader :default_store
+            def default_store
+              @default_store ||= Legion::Extensions::Agentic::Memory::Trace.shared_store
+            end
           end
         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
@@ -299,7 +300,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 +315,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,
@@ -348,15 +348,28 @@ module Legion
                 return raw unless raw.is_a?(String)
 
                 stripped = raw.strip
-                return raw unless stripped.start_with?('{', '[')
+                return raw unless parseable_content_json?(stripped)
 
                 parsed = Legion::JSON.load(stripped)
                 parsed.is_a?(Hash) || parsed.is_a?(Array) ? parsed : raw
-              rescue StandardError => e
-                log.debug "[trace_persistence] malformed JSON in content column, returning raw: #{e.message}"
+              rescue StandardError => _e
                 raw
               end
 
+              def parseable_content_json?(value)
+                return true if value.start_with?('{')
+                return false unless value.start_with?('[')
+
+                first_array_value = value[1..]&.lstrip&.[](0)
+                %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/runners/consolidation.rb

@@ -31,12 +31,12 @@ module Legion
               end
 
               def decay_cycle(store: nil, tick_count: 1, maintenance: true, **)
-                store ||= default_store
                 unless maintenance
-                  deferred = deferred_decay_summary(store)
+                  deferred = deferred_decay_summary(store || cached_default_store)
                   return { **deferred }
                 end
 
+                store ||= default_store
                 decayed = 0
                 pruned = 0
                 total = trace_count(store)
@@ -139,7 +139,7 @@ module Legion
 
               def deferred_decay_summary(store)
                 summary = Legion::Extensions::Agentic::Memory::Trace.last_maintenance_summary || {}
-                current_count = trace_count(store)
+                current_count = store ? trace_count(store) : 0
 
                 {
                   decayed:       summary[:decayed] || 0,
@@ -173,6 +173,10 @@ module Legion
                 @default_store ||= Legion::Extensions::Agentic::Memory::Trace.shared_store
               end
 
+              def cached_default_store
+                @default_store if instance_variable_defined?(:@default_store)
+              end
+
               include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
             end
           end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.33'
+        VERSION = '0.1.35'
       end
     end
   end

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

@@ -24,6 +24,14 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Client do
     expect(client).to respond_to(:erase_by_agent)
   end
 
+  it 'does not initialize the shared trace store until a store-backed operation needs it' do
+    allow(Legion::Extensions::Agentic::Memory::Trace).to receive(:shared_store)
+
+    described_class.new
+
+    expect(Legion::Extensions::Agentic::Memory::Trace).not_to have_received(:shared_store)
+  end
+
   it 'uses provided store' do
     store = Legion::Extensions::Agentic::Memory::Trace::Helpers::Store.new
     client = described_class.new(store: store)

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

@@ -238,6 +238,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/store_spec.rb

@@ -128,6 +128,30 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::Store do
     end
   end
 
+  describe '#parse_db_content' do
+    let(:parser) { described_class.allocate }
+
+    it 'returns bracket-prefixed raw log text without logging malformed JSON noise' do
+      expect(parser).not_to receive(:log)
+
+      result = parser.send(:parse_db_content, '[tool][file_read] opened file')
+
+      expect(result).to eq('[tool][file_read] opened file')
+    end
+
+    it 'still parses JSON object content' do
+      result = parser.send(:parse_db_content, '{"event":"meeting"}')
+
+      expect(result).to eq({ event: 'meeting' })
+    end
+
+    it 'still parses JSON array content when it looks like serialized payload data' do
+      result = parser.send(:parse_db_content, '[{"event":"meeting"}]')
+
+      expect(result).to eq([{ event: 'meeting' }])
+    end
+  end
+
   describe '#count' do
     it 'returns number of stored traces' do
       expect(store.count).to eq(0)

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/runners/consolidation_spec.rb

@@ -53,6 +53,23 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Runners::Consolidatio
   end
 
   describe '#decay_cycle' do
+    it 'does not initialize the shared store when Gaia defers heartbeat maintenance' do
+      runner = Object.new.extend(described_class)
+      allow(Legion::Extensions::Agentic::Memory::Trace).to receive(:shared_store)
+
+      result = runner.decay_cycle(maintenance: false)
+
+      expect(Legion::Extensions::Agentic::Memory::Trace).not_to have_received(:shared_store)
+      expect(result).to include(
+        decayed:   0,
+        pruned:    0,
+        total:     0,
+        remaining: 0,
+        deferred:  true,
+        reason:    :background_decay_actor
+      )
+    end
+
     it 'defers Gaia heartbeat decay work to the background actor when maintenance is false' do
       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.33
+  version: 0.1.35
 platform: ruby
 authors:
 - Esity