lex-agentic-memory 0.1.32 → 0.1.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07b491ea4b919f623905cf3fe0c651c6a462e46bfe096e06e4221e9eb9e6b801
-  data.tar.gz: b92fc5808525806e2dca50c86ea4382583adcbe5b6b9e84d0dd8e1c4add0f14b
+  metadata.gz: 606b711547732f1f697b57ce2392509c2774397c725b51f87baeaee591cf2ae2
+  data.tar.gz: f9f704beca9f4f33c8d71ad54627ef400561819898aeebf06c0097a0c0a535b1
 SHA512:
-  metadata.gz: ed8eb6cff096080b1435aab249896d4c473d1aab7b11ebec1f687081aa9494bc8671c029d3d7e2e80b4144b705b477e6d58fc796c412d2a6bf75a852fa02f27e
-  data.tar.gz: 834d02319dbf0c63722d8bc8e59e5f63d6c18c42c740a71a47ac5f1c6df0c1ad9b983e73b246f751bd24a784aa4e43c5d5f508ed516dbd7f94321fea220f2cf3
+  metadata.gz: 35f855a01efbfb5b29f23fe12f92e89082a3a4c8001b149dd16f6ccd648bc9d67a699755230e5b08c4a86f1147522f86b71d5fea3e31f3842448c20e4af3d094
+  data.tar.gz: 8e9afdf79c62437fefe856a61a0432d1574a7fba7dadab51c4a6b19a0e8a6d6a3658a19fbfa725d5cdb5c4c8de300169818aeee15c1e204e9cf7ff15a9cf12d3

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # 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.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
+- `PostgresStore#parse_json_array` now guards against nil/empty strings before parsing
+- `Store#parse_db_json` now short-circuits on nil/empty columns (domain_tags, associations, child_ids, emotional_valence) before attempting parse, fixing ERROR spam on traces with sparse optional fields
+
 ## [0.1.32] - 2026-05-07
 ### Fixed
 - Trace association retrieval now snapshots associated traces under the store mutex before filtering.

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/postgres_store.rb

@@ -394,15 +394,18 @@ module Legion
               def parse_json_or_raw(raw)
                 return raw unless raw.is_a?(String)
 
-                parsed = Legion::JSON.load(raw)
-                parsed.is_a?(Hash) ? parsed : raw
+                stripped = raw.strip
+                return raw unless stripped.start_with?('{', '[')
+
+                parsed = Legion::JSON.load(stripped)
+                parsed.is_a?(Hash) || parsed.is_a?(Array) ? parsed : raw
               rescue StandardError => e
                 log.error "[trace_persistence] parse_json_or_raw: #{e.message}"
                 raw
               end
 
               def parse_json_array(raw)
-                return [] unless raw.is_a?(String)
+                return [] if raw.nil? || !raw.is_a?(String) || raw.strip.empty?
 
                 result = Legion::JSON.load(raw)
                 result.is_a?(Array) ? result : []

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

@@ -348,16 +348,25 @@ 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 parse_db_json(raw, field, symbolize: false, &default)
+                return default&.call if raw.nil? || raw.to_s.strip.empty?
+
                 parsed = Legion::JSON.load(raw.to_s)
                 symbolize ? symbolize_keys(parsed) : parsed
               rescue StandardError => e

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.32'
+        VERSION = '0.1.34'
       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

@@ -556,4 +556,61 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::PostgresStor
       expect(store.flush).to be_nil
     end
   end
+
+  # --- plain-text content round-trip (log spam regression) ---
+
+  describe 'plain-text content deserialization' do
+    it 'returns plain-text content as-is without logging errors' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: 'It appears the service is down.')
+      store.store(trace)
+
+      expect(store).not_to receive(:log)
+      result = store.retrieve(trace[:trace_id])
+      expect(result[:content]).to eq('It appears the service is down.')
+    end
+
+    it 'parses JSON object content into a hash' do
+      trace = trace_helper.new_trace(type: :semantic, content_payload: { fact: 'ruby' })
+      store.store(trace)
+
+      result = store.retrieve(trace[:trace_id])
+      expect(result[:content]).to be_a(Hash)
+    end
+
+    it 'does not log errors when domain_tags column is nil' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: 'hello')
+      store.store(trace)
+
+      db[:memory_traces].where(trace_id: trace[:trace_id]).update(domain_tags: nil)
+
+      expect(store).not_to receive(:log)
+      result = store.retrieve(trace[:trace_id])
+      expect(result[:domain_tags]).to eq([])
+    end
+
+    it 'does not log errors when associations column is nil' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: 'hello')
+      store.store(trace)
+
+      db[:memory_traces].where(trace_id: trace[:trace_id]).update(associations: nil)
+
+      expect(store).not_to receive(:log)
+      result = store.retrieve(trace[:trace_id])
+      expect(result[:associated_traces]).to eq([])
+    end
+
+    it 'generates no ERROR log lines during a bulk read with mixed content types' do
+      plain_trace = trace_helper.new_trace(type: :episodic, content_payload: 'Hello, I am plain text')
+      json_trace  = trace_helper.new_trace(type: :semantic, content_payload: { fact: 'structured' })
+      store.store(plain_trace)
+      store.store(json_trace)
+
+      log_double = double('log', debug: nil, info: nil, warn: nil)
+      allow(store).to receive(:log).and_return(log_double)
+      expect(log_double).not_to receive(:error)
+
+      results = store.all_traces
+      expect(results.size).to eq(2)
+    end
+  end
 end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'sequel'
+
 RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::Store do
   let(:store) { described_class.new }
   let(:trace_helper) { Legion::Extensions::Agentic::Memory::Trace::Helpers::Trace }
@@ -126,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)
@@ -235,6 +261,78 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::Store do
     end
   end
 
+  describe 'parse_db_json nil/empty guard (log spam regression)' do
+    let(:local_db) do
+      d = Sequel.sqlite
+      d.create_table(:memory_traces) do
+        primary_key :id
+        String   :trace_id, size: 36, null: false, unique: true
+        String   :trace_type, null: false, default: 'episodic'
+        String   :content, text: true, null: false, default: ''
+        Float    :strength, default: 1.0
+        Float    :peak_strength, default: 1.0
+        Float    :base_decay_rate, default: 0.02
+        Float    :emotional_valence
+        Float    :emotional_intensity, default: 0.0
+        String   :domain_tags, text: true
+        String   :origin
+        String   :storage_tier, default: 'hot'
+        DateTime :created_at
+        DateTime :last_reinforced
+        DateTime :last_decayed
+        Integer  :reinforcement_count, default: 0
+        Float    :confidence, default: 0.5
+        String   :partition_id
+        String   :associated_traces, text: true
+        String   :parent_id
+        String   :child_ids, text: true
+        TrueClass :unresolved, default: false
+        TrueClass :consolidation_candidate, default: false
+      end
+      d.create_table(:memory_associations) do
+        primary_key :id
+        String :trace_id_a, size: 36, null: false
+        String :trace_id_b, size: 36, null: false
+        Integer :coactivation_count, default: 1, null: false
+        String :partition_id
+        unique %i[trace_id_a trace_id_b]
+      end
+      d
+    end
+
+    let(:data_local_stub) do
+      conn = local_db
+      Module.new do
+        define_singleton_method(:connected?) { true }
+        define_singleton_method(:connection) { conn }
+        define_singleton_method(:table_exists?) { |name| conn.table_exists?(name) }
+      end
+    end
+
+    before { stub_const('Legion::Data::Local', data_local_stub) }
+
+    it 'does not log errors when nil optional columns are deserialized on load' do
+      local_db[:memory_traces].insert(
+        trace_id:          SecureRandom.uuid,
+        trace_type:        'episodic',
+        content:           'plain text content',
+        partition_id:      'default',
+        strength:          1.0,
+        domain_tags:       nil,
+        associated_traces: nil,
+        child_ids:         nil,
+        emotional_valence: nil
+      )
+
+      fresh = described_class.new
+      expect(fresh.count).to eq(1)
+      trace = fresh.traces.values.first
+      expect(trace[:domain_tags]).to eq([])
+      expect(trace[:associated_traces]).to eq([])
+      expect(trace[:child_trace_ids]).to eq([])
+    end
+  end
+
   describe '#restore_traces' do
     it 'replaces existing traces and clears stale associations' do
       store.store(semantic_trace)

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.32
+  version: 0.1.34
 platform: ruby
 authors:
 - Esity