lex-agentic-social 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e4e4cf74f2655992c34c4945a8da0de92c597fc5371ff6fa595e583a4cdd88a
-  data.tar.gz: b0696e9bc1f7b990fb8e3a153fd22755edf34e18a6fdce7ea7efe23eccaa5afb
+  metadata.gz: 2a637b1280b8b3159e22384a36f90577406b8f3531189100d5d379cadd2dc00b
+  data.tar.gz: 16d221421b1212af948a0afffa6bb54e149087b13b4d473f1dcfe4cdd459ba27
 SHA512:
-  metadata.gz: 362432beb980f6e62f4097db1c37f444929ce2edd84439daee258de6e15dae346b5c33b09e3bfab19b2ca5d38ecd75b8f65269099247586750c329e05f5e7728
-  data.tar.gz: 1309465c2e0655fe62b68b3bfb58cf4f07eb9bbd808215927eb64c240dd4a16575117eb1e3cf6c757d7cd40e586bf3416ce4ddc3ba7feb040d8b2589f6f34c9a
+  metadata.gz: 94e0f0c04272c236d18011f3b8bb63798f06be346335bb0dcebac5472439f927817465d2f07bffa5c0633302c0d3bdb8b8a64bb7c30b3d7633a6b38e8cb52029
+  data.tar.gz: 5fbd869c1827ee00431b24d9ac317d001dfd4af19926a241f70f06cccad44656467585b6adea2499df1938524151dc096be4ceac3a784c34d52d8461fc744920

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.1.7] - 2026-03-31
+
+### Changed
+- Migrate `TrustMap` persistence from Data::Local SQLite to Apollo Local (`to_apollo_entries`, `from_apollo`)
+- Add dirty tracking (`dirty?`, `mark_clean!`) to `TrustMap` matching SocialGraph/MentalStateTracker pattern
+- Tag schema: `['trust', 'trust_entry', '<agent_id>', '<domain>']` with optional `'partner'` tag via BondRegistry
+- Remove Data::Local migration registration from trust entry point (migration file retained for existing installs)
+- Add one-time `scripts/migrate_trust_to_apollo.rb` for legacy SQLite data migration
+
 ## [0.1.6] - 2026-03-31
 
 ### Added

data/lib/legion/extensions/agentic/social/trust/helpers/trust_map.rb

@@ -11,7 +11,16 @@ module Legion
 
               def initialize
                 @entries = {} # key: "agent_id:domain"
-                load_from_local
+                @dirty = false
+              end
+
+              def dirty?
+                @dirty
+              end
+
+              def mark_clean!
+                @dirty = false
+                self
               end
 
               def get(agent_id, domain: :general)
@@ -40,6 +49,7 @@ module Legion
                 end
 
                 entry[:composite] = TrustModel.composite_score(entry[:dimensions])
+                @dirty = true
                 entry
               end
 
@@ -49,6 +59,7 @@ module Legion
 
                 entry[:dimensions][dimension] = TrustModel.clamp(entry[:dimensions][dimension] + amount)
                 entry[:composite] = TrustModel.composite_score(entry[:dimensions])
+                @dirty = true
               end
 
               def decay_all
@@ -61,6 +72,7 @@ module Legion
                   entry[:composite] = TrustModel.composite_score(entry[:dimensions])
                   decayed += 1
                 end
+                @dirty = true if decayed.positive?
                 decayed
               end
 
@@ -78,72 +90,33 @@ module Legion
                 @entries.size
               end
 
-              def save_to_local
-                return unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
-
-                dataset = Legion::Data::Local.connection[:trust_entries]
-
-                @entries.each_value do |entry|
-                  row = {
-                    agent_id:          entry[:agent_id].to_s,
-                    domain:            entry[:domain].to_s,
-                    reliability:       entry[:dimensions][:reliability],
-                    competence:        entry[:dimensions][:competence],
-                    integrity:         entry[:dimensions][:integrity],
-                    benevolence:       entry[:dimensions][:benevolence],
-                    composite:         entry[:composite],
-                    interaction_count: entry[:interaction_count],
-                    positive_count:    entry[:positive_count],
-                    negative_count:    entry[:negative_count],
-                    last_interaction:  entry[:last_interaction],
-                    created_at:        entry[:created_at]
-                  }
-                  existing = dataset.where(agent_id: row[:agent_id], domain: row[:domain]).first
-                  if existing
-                    dataset.where(agent_id: row[:agent_id], domain: row[:domain])
-                           .update(row.except(:agent_id, :domain))
-                  else
-                    dataset.insert(row)
-                  end
+              def to_apollo_entries
+                @entries.map do |_key, entry|
+                  tags = build_apollo_tags(entry[:agent_id], entry[:domain])
+                  content = Legion::JSON.dump({
+                                                agent_id:          entry[:agent_id].to_s,
+                                                domain:            entry[:domain].to_s,
+                                                dimensions:        entry[:dimensions],
+                                                composite:         entry[:composite],
+                                                interaction_count: entry[:interaction_count],
+                                                positive_count:    entry[:positive_count],
+                                                negative_count:    entry[:negative_count],
+                                                last_interaction:  entry[:last_interaction]&.iso8601,
+                                                created_at:        entry[:created_at]&.iso8601
+                                              })
+                  { content: content, tags: tags }
                 end
+              end
 
-                # Remove DB rows for entries no longer in memory
-                memory_pairs = @entries.values.map { |e| [e[:agent_id].to_s, e[:domain].to_s] }
-                dataset.each do |row|
-                  pair = [row[:agent_id], row[:domain]]
-                  dataset.where(agent_id: pair[0], domain: pair[1]).delete unless memory_pairs.include?(pair)
-                end
-              rescue StandardError => e
-                Legion::Logging.warn "[trust] save_to_local failed: #{e.message}"
-              end
-
-              def load_from_local
-                return unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
-
-                Legion::Data::Local.connection[:trust_entries].each do |row|
-                  agent_id   = row[:agent_id]
-                  domain_str = row[:domain]
-                  domain_val = domain_str.to_sym
-                  entry_key  = "#{agent_id}:#{domain_str}"
-                  @entries[entry_key] = {
-                    agent_id:          agent_id,
-                    domain:            domain_val,
-                    dimensions:        {
-                      reliability: row[:reliability].to_f,
-                      competence:  row[:competence].to_f,
-                      integrity:   row[:integrity].to_f,
-                      benevolence: row[:benevolence].to_f
-                    },
-                    composite:         row[:composite].to_f,
-                    interaction_count: row[:interaction_count].to_i,
-                    positive_count:    row[:positive_count].to_i,
-                    negative_count:    row[:negative_count].to_i,
-                    last_interaction:  row[:last_interaction],
-                    created_at:        row[:created_at]
-                  }
-                end
+              def from_apollo(store:)
+                result = store.query(text: 'trust trust_entry', tags: %w[trust trust_entry])
+                return false unless result[:success] && result[:results]&.any?
+
+                result[:results].each { |entry| restore_from_entry(entry) }
+                true
               rescue StandardError => e
-                Legion::Logging.warn "[trust] load_from_local failed: #{e.message}"
+                Legion::Logging.warn("[trust_map] from_apollo error: #{e.message}")
+                false
               end
 
               private
@@ -151,6 +124,63 @@ module Legion
               def key(agent_id, domain)
                 "#{agent_id}:#{domain}"
               end
+
+              def build_apollo_tags(agent_id, domain)
+                tags = ['trust', 'trust_entry', agent_id.to_s, domain.to_s]
+                tags << 'partner' if defined?(Legion::Gaia::BondRegistry) && partner_agent?(agent_id)
+                tags
+              end
+
+              def partner_agent?(agent_id)
+                Legion::Gaia::BondRegistry.partner?(agent_id.to_s)
+              rescue StandardError => e
+                Legion::Logging.debug("[trust_map] BondRegistry check failed: #{e.message}")
+                false
+              end
+
+              def restore_from_entry(entry)
+                data = Legion::JSON.parse(entry[:content])
+                agent_id = flex(data, 'agent_id')
+                return unless agent_id
+
+                domain_val = (flex(data, 'domain') || 'general').to_sym
+                dims = restore_dimensions(flex(data, 'dimensions') || {})
+
+                @entries[key(agent_id, domain_val)] = {
+                  agent_id:          agent_id,
+                  domain:            domain_val,
+                  dimensions:        dims,
+                  composite:         (flex(data, 'composite') || TrustModel::NEUTRAL_TRUST).to_f,
+                  interaction_count: (flex(data, 'interaction_count') || 0).to_i,
+                  positive_count:    (flex(data, 'positive_count') || 0).to_i,
+                  negative_count:    (flex(data, 'negative_count') || 0).to_i,
+                  last_interaction:  parse_time(flex(data, 'last_interaction')),
+                  created_at:        parse_time(flex(data, 'created_at')) || Time.now.utc
+                }
+              rescue StandardError => e
+                Legion::Logging.debug("[trust_map] restore entry failed: #{e.message}")
+                nil
+              end
+
+              def flex(hash, string_key)
+                hash[string_key] || hash[string_key.to_sym]
+              end
+
+              def restore_dimensions(dims)
+                TrustModel::TRUST_DIMENSIONS.to_h do |dim|
+                  [dim, (flex(dims, dim.to_s) || TrustModel::NEUTRAL_TRUST).to_f]
+                end
+              end
+
+              def parse_time(value)
+                return nil if value.nil?
+                return value if value.is_a?(Time)
+
+                Time.parse(value.to_s)
+              rescue ArgumentError => e
+                Legion::Logging.debug("[trust_map] parse_time failed: #{e.message}")
+                nil
+              end
             end
           end
         end

data/lib/legion/extensions/agentic/social/trust.rb

@@ -14,12 +14,5 @@ module Legion
         end
       end
     end
-
-    if defined?(Legion::Data::Local)
-      Legion::Data::Local.register_migrations(
-        name: :trust,
-        path: File.join(__dir__, 'trust', 'local_migrations')
-      )
-    end
   end
 end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Social
-        VERSION = '0.1.6'
+        VERSION = '0.1.7'
       end
     end
   end

data/spec/legion/extensions/agentic/social/trust/local_persistence_spec.rb

@@ -1,204 +1,200 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'sequel'
-require 'tmpdir'
-
-RSpec.describe 'lex-trust local SQLite persistence' do
-  let(:db_path) { File.join(Dir.tmpdir, "trust_test_#{Process.pid}_#{rand(9999)}.db") }
-  let(:db) { Sequel.sqlite(db_path) }
-
-  before do
-    db.create_table(:trust_entries) do
-      primary_key :id
-      String :agent_id, null: false
-      String :domain, null: false
-      Float :reliability, default: 0.3
-      Float :competence, default: 0.3
-      Float :integrity, default: 0.3
-      Float :benevolence, default: 0.3
-      Float :composite, default: 0.3
-      Integer :interaction_count, default: 0
-      Integer :positive_count, default: 0
-      Integer :negative_count, default: 0
-      DateTime :last_interaction
-      DateTime :created_at, null: false
-      unique %i[agent_id domain]
-      index [:agent_id]
-    end
-
-    stub_const('Legion::Data::Local', Module.new do
-      def self.connected?
-        true
-      end
 
-      def self.connection
-        @_connection
-      end
+RSpec.describe 'lex-trust Apollo Local persistence' do
+  subject(:map) { described_class.new }
 
-      def self._set_connection(conn)
-        @_connection = conn
-      end
-    end)
+  let(:described_class) { Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap }
 
-    Legion::Data::Local._set_connection(db)
-  end
-
-  after do
-    db.disconnect
-    FileUtils.rm_f(db_path)
-  end
+  describe '#dirty?' do
+    it 'starts clean' do
+      expect(map.dirty?).to be false
+    end
 
-  describe 'save_to_local' do
-    it 'writes an entry to the database' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+    it 'becomes dirty after record_interaction' do
       map.record_interaction('agent-001', positive: true)
-      map.save_to_local
-
-      row = db[:trust_entries].where(agent_id: 'agent-001', domain: 'general').first
-      expect(row).not_to be_nil
-      expect(row[:agent_id]).to eq('agent-001')
-      expect(row[:domain]).to eq('general')
-      expect(row[:positive_count]).to eq(1)
-      expect(row[:interaction_count]).to eq(1)
+      expect(map.dirty?).to be true
     end
 
-    it 'updates an existing row on second save' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      map.record_interaction('agent-001', positive: true)
-      map.save_to_local
+    it 'becomes dirty after reinforce_dimension' do
+      map.get_or_create('agent-001')
+      map.reinforce_dimension('agent-001', dimension: :competence)
+      expect(map.dirty?).to be true
+    end
 
-      map.record_interaction('agent-001', positive: false)
-      map.save_to_local
+    it 'becomes dirty after decay_all with entries' do
+      map.get_or_create('agent-001')
+      map.decay_all
+      expect(map.dirty?).to be true
+    end
 
-      rows = db[:trust_entries].where(agent_id: 'agent-001', domain: 'general').all
-      expect(rows.size).to eq(1)
-      expect(rows.first[:negative_count]).to eq(1)
-      expect(rows.first[:interaction_count]).to eq(2)
+    it 'stays clean after decay_all with no entries' do
+      map.decay_all
+      expect(map.dirty?).to be false
     end
 
-    it 'persists composite score' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+    it 'becomes clean after mark_clean!' do
       map.record_interaction('agent-001', positive: true)
-      map.save_to_local
+      map.mark_clean!
+      expect(map.dirty?).to be false
+    end
+  end
 
-      row = db[:trust_entries].where(agent_id: 'agent-001', domain: 'general').first
-      expect(row[:composite]).to be > 0.3
+  describe '#mark_clean!' do
+    it 'returns self' do
+      expect(map.mark_clean!).to eq(map)
     end
 
-    it 'persists all four dimension scores' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+    it 'resets dirty flag' do
       map.record_interaction('agent-001', positive: true)
-      map.save_to_local
+      map.mark_clean!
+      expect(map.dirty?).to be false
+    end
+  end
 
-      row = db[:trust_entries].where(agent_id: 'agent-001', domain: 'general').first
-      expect(row[:reliability]).to be > 0.3
-      expect(row[:competence]).to be > 0.3
-      expect(row[:integrity]).to be > 0.3
-      expect(row[:benevolence]).to be > 0.3
+  describe '#to_apollo_entries' do
+    it 'returns empty array when no entries' do
+      expect(map.to_apollo_entries).to eq([])
     end
 
-    it 'persists entries for multiple agents' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+    it 'returns one entry per trust record' do
       map.record_interaction('agent-a', positive: true)
       map.record_interaction('agent-b', positive: false)
-      map.save_to_local
-
-      expect(db[:trust_entries].count).to eq(2)
+      expect(map.to_apollo_entries.size).to eq(2)
     end
 
-    it 'persists entries for multiple domains of the same agent' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+    it 'returns separate entries for different domains of the same agent' do
       map.record_interaction('agent-001', positive: true, domain: :code)
       map.record_interaction('agent-001', positive: false, domain: :ops)
-      map.save_to_local
+      expect(map.to_apollo_entries.size).to eq(2)
+    end
+
+    it 'entry content is a JSON string with agent_id' do
+      map.record_interaction('agent-001', positive: true)
+      entry = map.to_apollo_entries.first
+      parsed = JSON.parse(entry[:content])
+      expect(parsed).to have_key('agent_id')
+      expect(parsed['agent_id']).to eq('agent-001')
+    end
+
+    it 'entry content includes domain' do
+      map.record_interaction('agent-001', positive: true, domain: :code)
+      entry = map.to_apollo_entries.first
+      parsed = JSON.parse(entry[:content])
+      expect(parsed['domain']).to eq('code')
+    end
+
+    it 'entry content includes all four dimensions' do
+      map.record_interaction('agent-001', positive: true)
+      entry = map.to_apollo_entries.first
+      parsed = JSON.parse(entry[:content])
+      expect(parsed['dimensions']).to have_key('reliability')
+      expect(parsed['dimensions']).to have_key('competence')
+      expect(parsed['dimensions']).to have_key('integrity')
+      expect(parsed['dimensions']).to have_key('benevolence')
+    end
 
-      expect(db[:trust_entries].where(agent_id: 'agent-001').count).to eq(2)
+    it 'entry content includes composite score' do
+      map.record_interaction('agent-001', positive: true)
+      entry = map.to_apollo_entries.first
+      parsed = JSON.parse(entry[:content])
+      expect(parsed['composite']).to be > 0.3
     end
 
-    it 'removes DB rows for entries removed from memory' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      map.get_or_create('agent-a')
-      map.get_or_create('agent-b')
-      map.save_to_local
+    it 'entry content includes interaction counts' do
+      map.record_interaction('agent-001', positive: true)
+      entry = map.to_apollo_entries.first
+      parsed = JSON.parse(entry[:content])
+      expect(parsed['interaction_count']).to eq(1)
+      expect(parsed['positive_count']).to eq(1)
+      expect(parsed['negative_count']).to eq(0)
+    end
 
-      expect(db[:trust_entries].count).to eq(2)
+    it 'entry tags include trust, trust_entry, agent_id, and domain' do
+      map.record_interaction('agent-001', positive: true, domain: :code)
+      entry = map.to_apollo_entries.first
+      expect(entry[:tags]).to include('trust', 'trust_entry', 'agent-001', 'code')
+    end
 
-      # Simulate removal: build new map with only agent-a, then save
-      map2 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      map2.save_to_local # loaded agent-a and agent-b from DB, both still in memory
-      expect(db[:trust_entries].count).to eq(2) # nothing deleted yet
+    it 'entry tags include partner when BondRegistry reports partner' do
+      bond_registry = Module.new do
+        def self.partner?(agent_id)
+          agent_id == 'agent-001'
+        end
+      end
+      stub_const('Legion::Gaia::BondRegistry', bond_registry)
 
-      # Remove agent-b from memory then save
-      map2.entries.delete_if { |k, _| k.start_with?('agent-b') }
-      map2.save_to_local
+      map.record_interaction('agent-001', positive: true)
+      entry = map.to_apollo_entries.first
+      expect(entry[:tags]).to include('partner')
+    end
 
-      expect(db[:trust_entries].count).to eq(1)
-      expect(db[:trust_entries].first[:agent_id]).to eq('agent-a')
+    it 'entry tags exclude partner for non-partner agents' do
+      bond_registry = Module.new do
+        def self.partner?(_agent_id)
+          false
+        end
+      end
+      stub_const('Legion::Gaia::BondRegistry', bond_registry)
+
+      map.record_interaction('agent-001', positive: true)
+      entry = map.to_apollo_entries.first
+      expect(entry[:tags]).not_to include('partner')
     end
   end
 
-  describe 'load_from_local' do
-    it 'restores entries from the database on initialize' do
-      db[:trust_entries].insert(
-        agent_id:          'agent-001',
-        domain:            'general',
-        reliability:       0.45,
-        competence:        0.45,
-        integrity:         0.45,
-        benevolence:       0.45,
-        composite:         0.45,
-        interaction_count: 3,
-        positive_count:    3,
-        negative_count:    0,
-        created_at:        Time.now.utc
-      )
+  describe '#from_apollo' do
+    let(:mock_store) do
+      double('ApolloLocal').tap do |store|
+        allow(store).to receive(:query).and_return({ success: false, results: [] })
+      end
+    end
 
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      entry = map.get('agent-001')
-      expect(entry).not_to be_nil
-      expect(entry[:composite]).to be_within(0.0001).of(0.45)
-      expect(entry[:interaction_count]).to eq(3)
-      expect(entry[:positive_count]).to eq(3)
+    it 'returns false when store query fails or returns no results' do
+      result = map.from_apollo(store: mock_store)
+      expect(result).to be false
     end
 
-    it 'restores domain as a symbol' do
-      db[:trust_entries].insert(
-        agent_id:          'agent-001',
-        domain:            'code',
-        reliability:       0.3,
-        competence:        0.3,
-        integrity:         0.3,
-        benevolence:       0.3,
-        composite:         0.3,
-        interaction_count: 0,
-        positive_count:    0,
-        negative_count:    0,
-        created_at:        Time.now.utc
+    it 'populates entries from stored JSON' do
+      content = JSON.dump({
+                            agent_id: 'agent-001', domain: 'general',
+                            dimensions: { reliability: 0.6, competence: 0.5, integrity: 0.4, benevolence: 0.3 },
+                            composite: 0.45, interaction_count: 3, positive_count: 3, negative_count: 0,
+                            last_interaction: Time.now.utc.iso8601, created_at: Time.now.utc.iso8601
+                          })
+      allow(mock_store).to receive(:query).and_return(
+        { success: true, results: [{ content: content, tags: %w[trust trust_entry agent-001 general] }] }
       )
+      map.from_apollo(store: mock_store)
+      expect(map.get('agent-001')).not_to be_nil
+    end
 
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+    it 'restores domain as a symbol' do
+      content = JSON.dump({
+                            agent_id: 'agent-001', domain: 'code',
+                            dimensions: { reliability: 0.3, competence: 0.3, integrity: 0.3, benevolence: 0.3 },
+                            composite: 0.3, interaction_count: 0, positive_count: 0, negative_count: 0
+                          })
+      allow(mock_store).to receive(:query).and_return(
+        { success: true, results: [{ content: content, tags: %w[trust trust_entry agent-001 code] }] }
+      )
+      map.from_apollo(store: mock_store)
       entry = map.get('agent-001', domain: :code)
       expect(entry).not_to be_nil
       expect(entry[:domain]).to eq(:code)
     end
 
     it 'restores all four dimension values' do
-      db[:trust_entries].insert(
-        agent_id:          'agent-001',
-        domain:            'general',
-        reliability:       0.6,
-        competence:        0.5,
-        integrity:         0.4,
-        benevolence:       0.3,
-        composite:         0.45,
-        interaction_count: 0,
-        positive_count:    0,
-        negative_count:    0,
-        created_at:        Time.now.utc
+      content = JSON.dump({
+                            agent_id: 'agent-001', domain: 'general',
+                            dimensions: { reliability: 0.6, competence: 0.5, integrity: 0.4, benevolence: 0.3 },
+                            composite: 0.45, interaction_count: 0, positive_count: 0, negative_count: 0
+                          })
+      allow(mock_store).to receive(:query).and_return(
+        { success: true, results: [{ content: content, tags: %w[trust trust_entry agent-001 general] }] }
       )
-
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+      map.from_apollo(store: mock_store)
       entry = map.get('agent-001')
       expect(entry[:dimensions][:reliability]).to be_within(0.0001).of(0.6)
       expect(entry[:dimensions][:competence]).to be_within(0.0001).of(0.5)
@@ -207,64 +203,98 @@ RSpec.describe 'lex-trust local SQLite persistence' do
     end
 
     it 'restores multiple entries' do
-      db[:trust_entries].insert(
-        agent_id: 'agent-a', domain: 'general',
-        reliability: 0.3, competence: 0.3, integrity: 0.3, benevolence: 0.3,
-        composite: 0.3, interaction_count: 0, positive_count: 0, negative_count: 0,
-        created_at: Time.now.utc
+      content_a = JSON.dump({
+                              agent_id: 'agent-a', domain: 'general',
+                              dimensions: { reliability: 0.3, competence: 0.3, integrity: 0.3, benevolence: 0.3 },
+                              composite: 0.3, interaction_count: 0, positive_count: 0, negative_count: 0
+                            })
+      content_b = JSON.dump({
+                              agent_id: 'agent-b', domain: 'ops',
+                              dimensions: { reliability: 0.3, competence: 0.3, integrity: 0.3, benevolence: 0.3 },
+                              composite: 0.3, interaction_count: 0, positive_count: 0, negative_count: 0
+                            })
+      allow(mock_store).to receive(:query).and_return(
+        { success: true, results: [
+          { content: content_a, tags: %w[trust trust_entry agent-a general] },
+          { content: content_b, tags: %w[trust trust_entry agent-b ops] }
+        ] }
       )
-      db[:trust_entries].insert(
-        agent_id: 'agent-b', domain: 'ops',
-        reliability: 0.3, competence: 0.3, integrity: 0.3, benevolence: 0.3,
-        composite: 0.3, interaction_count: 0, positive_count: 0, negative_count: 0,
-        created_at: Time.now.utc
-      )
-
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+      map.from_apollo(store: mock_store)
       expect(map.count).to eq(2)
     end
 
-    it 'allows normal operations on restored entries' do
-      db[:trust_entries].insert(
-        agent_id:          'agent-001',
-        domain:            'general',
-        reliability:       0.4,
-        competence:        0.4,
-        integrity:         0.4,
-        benevolence:       0.4,
-        composite:         0.4,
-        interaction_count: 2,
-        positive_count:    2,
-        negative_count:    0,
-        created_at:        Time.now.utc
+    it 'restores interaction counts' do
+      content = JSON.dump({
+                            agent_id: 'agent-001', domain: 'general',
+                            dimensions: { reliability: 0.45, competence: 0.45, integrity: 0.45, benevolence: 0.45 },
+                            composite: 0.45, interaction_count: 5, positive_count: 3, negative_count: 2
+                          })
+      allow(mock_store).to receive(:query).and_return(
+        { success: true, results: [{ content: content, tags: %w[trust trust_entry agent-001 general] }] }
       )
+      map.from_apollo(store: mock_store)
+      entry = map.get('agent-001')
+      expect(entry[:interaction_count]).to eq(5)
+      expect(entry[:positive_count]).to eq(3)
+      expect(entry[:negative_count]).to eq(2)
+    end
 
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+    it 'allows normal operations on restored entries' do
+      content = JSON.dump({
+                            agent_id: 'agent-001', domain: 'general',
+                            dimensions: { reliability: 0.4, competence: 0.4, integrity: 0.4, benevolence: 0.4 },
+                            composite: 0.4, interaction_count: 2, positive_count: 2, negative_count: 0
+                          })
+      allow(mock_store).to receive(:query).and_return(
+        { success: true, results: [{ content: content, tags: %w[trust trust_entry agent-001 general] }] }
+      )
+      map.from_apollo(store: mock_store)
       map.record_interaction('agent-001', positive: true)
       entry = map.get('agent-001')
       expect(entry[:interaction_count]).to eq(3)
       expect(entry[:positive_count]).to eq(3)
     end
+
+    it 'trusted_agents works correctly after hydration' do
+      content = JSON.dump({
+                            agent_id: 'agent-001', domain: 'general',
+                            dimensions: { reliability: 0.6, competence: 0.6, integrity: 0.6, benevolence: 0.6 },
+                            composite: 0.6, interaction_count: 5, positive_count: 5, negative_count: 0
+                          })
+      allow(mock_store).to receive(:query).and_return(
+        { success: true, results: [{ content: content, tags: %w[trust trust_entry agent-001 general] }] }
+      )
+      map.from_apollo(store: mock_store)
+      trusted = map.trusted_agents
+      expect(trusted).not_to be_empty
+      expect(trusted.first[:agent_id]).to eq('agent-001')
+    end
   end
 
-  describe 'round-trip persistence' do
-    it 'saves and restores trust score across instances' do
-      map1 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      5.times { map1.record_interaction('agent-001', positive: true) }
-      composite_before = map1.get('agent-001')[:composite]
-      map1.save_to_local
+  describe 'round-trip via to_apollo_entries / from_apollo' do
+    let(:mock_store) { double('ApolloLocal') }
+
+    it 'preserves trust scores across serialize/deserialize' do
+      5.times { map.record_interaction('agent-001', positive: true) }
+      composite_before = map.get('agent-001')[:composite]
+
+      entries = map.to_apollo_entries
+      allow(mock_store).to receive(:query).and_return({ success: true, results: entries })
 
-      map2 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+      map2 = described_class.new
+      map2.from_apollo(store: mock_store)
       expect(map2.get('agent-001')[:composite]).to be_within(0.0001).of(composite_before)
     end
 
     it 'round-trips interaction counts accurately' do
-      map1 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      3.times { map1.record_interaction('agent-001', positive: true) }
-      2.times { map1.record_interaction('agent-001', positive: false) }
-      map1.save_to_local
+      3.times { map.record_interaction('agent-001', positive: true) }
+      2.times { map.record_interaction('agent-001', positive: false) }
 
-      map2 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+      entries = map.to_apollo_entries
+      allow(mock_store).to receive(:query).and_return({ success: true, results: entries })
+
+      map2 = described_class.new
+      map2.from_apollo(store: mock_store)
       entry = map2.get('agent-001')
       expect(entry[:interaction_count]).to eq(5)
       expect(entry[:positive_count]).to eq(3)
@@ -272,88 +302,45 @@ RSpec.describe 'lex-trust local SQLite persistence' do
     end
 
     it 'round-trips multiple agents independently' do
-      map1 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      5.times { map1.record_interaction('agent-high', positive: true) }
-      map1.record_interaction('agent-low', positive: false)
-      map1.save_to_local
+      5.times { map.record_interaction('agent-high', positive: true) }
+      map.record_interaction('agent-low', positive: false)
+
+      entries = map.to_apollo_entries
+      allow(mock_store).to receive(:query).and_return({ success: true, results: entries })
 
-      map2 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+      map2 = described_class.new
+      map2.from_apollo(store: mock_store)
       expect(map2.get('agent-high')[:composite]).to be > map2.get('agent-low')[:composite]
     end
 
     it 'round-trips domain-scoped entries independently' do
-      map1 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      5.times { map1.record_interaction('agent-001', positive: true, domain: :code) }
-      map1.record_interaction('agent-001', positive: false, domain: :ops)
-      map1.save_to_local
+      5.times { map.record_interaction('agent-001', positive: true, domain: :code) }
+      map.record_interaction('agent-001', positive: false, domain: :ops)
 
-      map2 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+      entries = map.to_apollo_entries
+      allow(mock_store).to receive(:query).and_return({ success: true, results: entries })
+
+      map2 = described_class.new
+      map2.from_apollo(store: mock_store)
       code_entry = map2.get('agent-001', domain: :code)
       ops_entry  = map2.get('agent-001', domain: :ops)
       expect(code_entry[:composite]).to be > ops_entry[:composite]
     end
 
-    it 'trusted_agents works correctly after round-trip' do
-      map1 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      5.times { map1.record_interaction('agent-001', positive: true) }
-      map1.save_to_local
-
-      map2 = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      trusted = map2.trusted_agents
-      expect(trusted).not_to be_empty
-      expect(trusted.first[:agent_id]).to eq('agent-001')
-    end
-  end
-
-  describe 'graceful no-op when Legion::Data::Local is unavailable' do
-    before do
-      hide_const('Legion::Data::Local')
-    end
-
-    it 'initialize completes without raising' do
-      expect { Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new }.not_to raise_error
-    end
-
-    it 'save_to_local does nothing without raising' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      map.record_interaction('agent-001', positive: true)
-      expect { map.save_to_local }.not_to raise_error
-    end
-
-    it 'starts with empty in-memory state' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      expect(map.count).to eq(0)
-    end
-
-    it 'operates normally in memory when DB unavailable' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
+    it 'round-trips all four dimension values' do
       map.record_interaction('agent-001', positive: true)
-      expect(map.get('agent-001')[:positive_count]).to eq(1)
-    end
-  end
-
-  describe 'graceful no-op when Legion::Data::Local is defined but not connected' do
-    before do
-      stub_const('Legion::Data::Local', Module.new do
-        def self.connected?
-          false
-        end
-      end)
-    end
-
-    it 'initialize completes without raising' do
-      expect { Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new }.not_to raise_error
-    end
+      map.reinforce_dimension('agent-001', dimension: :competence, amount: 0.2)
 
-    it 'save_to_local does nothing without raising' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      map.record_interaction('agent-001', positive: true)
-      expect { map.save_to_local }.not_to raise_error
-    end
+      entries = map.to_apollo_entries
+      allow(mock_store).to receive(:query).and_return({ success: true, results: entries })
 
-    it 'starts with empty in-memory state' do
-      map = Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap.new
-      expect(map.count).to eq(0)
+      map2 = described_class.new
+      map2.from_apollo(store: mock_store)
+      original = map.get('agent-001')[:dimensions]
+      restored = map2.get('agent-001')[:dimensions]
+      Legion::Extensions::Agentic::Social::Trust::Helpers::TrustModel::TRUST_DIMENSIONS.each do |dim|
+        expect(restored[dim]).to be_within(0.0001).of(original[dim])
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-social
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Esity