lex-agentic-social 0.1.19 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49f5148e440e4e58060bf6ff47c9dc8d31bfde5092ab17b7ad078fb95344e711
-  data.tar.gz: 191fddf9d835866196a20ed7efafcbfb4ef34729d7d5b585f7d68a95dc225b00
+  metadata.gz: a649d923310d4a98480e6069c03d586585c2a27d3045c625f5c76d608b066016
+  data.tar.gz: d5983148aebfa19722b6ae1c5c4e564bd7be94455f3838401bbbe36cdbc087fe
 SHA512:
-  metadata.gz: e052b2d246149565565a6f0a7654bb7d7bf689bc149c2bb17b22fdcc59c15339178805127b1a07e8a602a3d9fd1fcebb3e5b3a1bacef01622f6f4ac934be120f
-  data.tar.gz: 92f66448450959900ac87054fc9a5b4e9e442b3217f52d35e7b8a6e17c377317932c6f92ed129d64c82c177b101d7c95d30ce0a7e52a818f4d74c49edc87a695
+  metadata.gz: cc6fc74f2620bc3e2cd96c2ba567f61dd0d1596127e33c75db88af80048879944d8d8719f861c7d2b9368d0d53a87f4ea2978c0c7e0e52b949f91b4168b5d650
+  data.tar.gz: e6de6e946ebb7468dd4adf14e35e97e6104cfd13f288b7730cd1f92420764713ea0afb4ed6c3a137f2146765da060de24e0e41a70a6000a9c73148c3d904b3f8

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.1.20] - 2026-07-16
+### Added
+- `CalibrationRegistry`: per-identity `CalibrationStore` instances keyed by identity string, fixing the grading-contamination bug where one interlocutor's reactions moved another's calibration weights.
+- `CalibrationRegistry#erase_partner!(identity:)`: removes all calibration data for a given identity, leaving others untouched.
+- `CalibrationRegistry#known_identities`: returns all registered identity keys.
+- `CalibrationRegistry#to_apollo_entries_for(identity:)`: returns Apollo persistence entries scoped to one identity.
+- `TrustMap` gains `partner_identity:` keyword on `get`, `get_or_create`, and `record_interaction` — entries are keyed as `(partner_identity, agent_id, domain)` for H7 scoping.
+- `TrustMap#erase_partner!(identity:)`: removes all trust entries scoped to the given partner identity and marks the map dirty.
+
 ## [0.1.19] - 2026-06-01
 ### Fixed
 - Calibration LLM preference extraction now uses `Legion::LLM.chat` with explicit system/user messages instead of legacy `Legion::LLM.ask`.

data/lib/legion/extensions/agentic/social/attachment/runners/attachment.rb

@@ -25,7 +25,7 @@ module Legion
                 { agents_updated: agents.size, models: agents.map { |id| attachment_store.get(id)&.to_h } }
               end
 
-              def reflect_on_bonds(_tick_results: {}, _bond_summary: {}, **)
+              def reflect_on_bonds(**)
                 store = apollo_local_store
                 return { success: false, error: :no_store } unless store
 

data/lib/legion/extensions/agentic/social/calibration/helpers/calibration_registry.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Calibration
+          module Helpers
+            class CalibrationRegistry
+              def initialize
+                @stores = {}
+                @mutex  = Mutex.new
+              end
+
+              def for(identity:)
+                @mutex.synchronize { @stores[identity.to_s] ||= CalibrationStore.new }
+              end
+
+              def erase_partner!(identity:)
+                @mutex.synchronize { @stores.delete(identity.to_s) }
+                true
+              end
+
+              def known_identities
+                @mutex.synchronize { @stores.keys.dup }
+              end
+
+              def to_apollo_entries_for(identity:)
+                store = @mutex.synchronize { @stores[identity.to_s] }
+                return [] unless store
+
+                store.to_apollo_entries
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative 'calibration/helpers/constants'
 require_relative 'calibration/helpers/calibration_store'
+require_relative 'calibration/helpers/calibration_registry'
 require_relative 'calibration/runners/calibration'
 require_relative 'calibration/client'
 

data/lib/legion/extensions/agentic/social/consent/runners/consent.rb

@@ -10,7 +10,7 @@ module Legion
               include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                           Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
-              def check_consent(domain:, _action_type: :general, **)
+              def check_consent(domain:, **)
                 tier = consent_map.get_tier(domain)
                 log.debug "[consent] check: domain=#{domain} tier=#{tier} allowed=#{tier == :autonomous}"
 

data/lib/legion/extensions/agentic/social/governance/runners/governance.rb

@@ -61,7 +61,7 @@ module Legion
                 validate_action(layer: :agent_validation, action: action, _context: context)
               end
 
-              def validate_action(layer:, action: nil, _context: {}, **)
+              def validate_action(layer:, action: nil, **)
                 return { error: :invalid_layer } unless Helpers::Layers.valid_layer?(layer)
 
                 log.info "[governance] validating action=#{action} layer=#{layer}"

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

@@ -10,7 +10,7 @@ module Legion
               attr_reader :entries
 
               def initialize
-                @entries = {} # key: "agent_id:domain"
+                @entries = {} # key: "partner_identity|agent_id:domain"
                 @dirty = false
               end
 
@@ -23,16 +23,16 @@ module Legion
                 self
               end
 
-              def get(agent_id, domain: :general)
-                @entries[key(agent_id, domain)]
+              def get(agent_id, domain: :general, partner_identity: nil)
+                @entries[key(agent_id, domain, partner_identity)]
               end
 
-              def get_or_create(agent_id, domain: :general)
-                @entries[key(agent_id, domain)] ||= TrustModel.new_trust_entry(agent_id: agent_id, domain: domain)
+              def get_or_create(agent_id, domain: :general, partner_identity: nil)
+                @entries[key(agent_id, domain, partner_identity)] ||= TrustModel.new_trust_entry(agent_id: agent_id, domain: domain)
               end
 
-              def record_interaction(agent_id, positive:, domain: :general)
-                entry = get_or_create(agent_id, domain: domain)
+              def record_interaction(agent_id, positive:, domain: :general, partner_identity: nil)
+                entry = get_or_create(agent_id, domain: domain, partner_identity: partner_identity)
                 entry[:interaction_count] += 1
                 entry[:last_interaction] = Time.now.utc
 
@@ -53,6 +53,14 @@ module Legion
                 entry
               end
 
+              def erase_partner!(identity:)
+                prefix = "#{identity}|"
+                removed = @entries.keys.select { |k| k.start_with?(prefix) }
+                removed.each { |k| @entries.delete(k) }
+                @dirty = true if removed.any?
+                removed.size
+              end
+
               def reinforce_dimension(agent_id, dimension:, domain: :general, amount: TrustModel::TRUST_REINFORCEMENT)
                 entry = get_or_create(agent_id, domain: domain)
                 return unless TrustModel::TRUST_DIMENSIONS.include?(dimension)
@@ -121,8 +129,9 @@ module Legion
 
               private
 
-              def key(agent_id, domain)
-                "#{agent_id}:#{domain}"
+              def key(agent_id, domain, partner_identity = nil)
+                base = "#{agent_id}:#{domain}"
+                partner_identity ? "#{partner_identity}|#{base}" : base
               end
 
               def build_apollo_tags(agent_id, domain)

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Social
-        VERSION = '0.1.19'
+        VERSION = '0.1.20'
       end
     end
   end

data/spec/legion/extensions/agentic/social/calibration/helpers/calibration_registry_spec.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Helpers::CalibrationRegistry do
+  subject(:registry) { described_class.new }
+
+  let(:identity_x) { 'user:alice' }
+  let(:identity_y) { 'user:bob' }
+
+  describe '#for(identity:)' do
+    it 'returns a CalibrationStore instance' do
+      expect(registry.for(identity: identity_x)).to be_a(
+        Legion::Extensions::Agentic::Social::Calibration::Helpers::CalibrationStore
+      )
+    end
+
+    it 'returns the same instance on repeated calls for the same identity' do
+      first  = registry.for(identity: identity_x)
+      second = registry.for(identity: identity_x)
+      expect(first).to equal(second)
+    end
+
+    it 'returns independent instances per identity' do
+      x = registry.for(identity: identity_x)
+      y = registry.for(identity: identity_y)
+      expect(x).not_to equal(y)
+    end
+
+    it 'X reads never see Y data — weights are independent' do
+      store_x = registry.for(identity: identity_x)
+      store_x.record_advisory(advisory_id: 'ax', advisory_types: [:tone_adjustment])
+      store_x.evaluate_reaction(observation: { content: 'thanks, perfect!', direct_address: true, content_length: 20 })
+
+      store_y = registry.for(identity: identity_y)
+      expect(store_y.weights['tone_adjustment']).to eq(0.5)
+    end
+
+    it 'Y negative reaction never moves X calibration weights (contamination guard)' do
+      store_x = registry.for(identity: identity_x)
+      store_x.record_advisory(advisory_id: 'ax', advisory_types: [:tone_adjustment])
+
+      store_y = registry.for(identity: identity_y)
+      store_y.record_advisory(advisory_id: 'ay', advisory_types: [:tone_adjustment])
+      store_y.evaluate_reaction(observation: { content: 'no, wrong', content_length: 5 })
+
+      # X advisory meta should still be present (Y's reaction didn't consume X's advisory)
+      result = store_x.evaluate_reaction(observation: { content: 'hello' })
+      expect(result).not_to be_nil
+    end
+  end
+
+  describe '#erase_partner!(identity:)' do
+    before do
+      store = registry.for(identity: identity_x)
+      store.record_advisory(advisory_id: 'ax', advisory_types: [:tone_adjustment])
+      store.evaluate_reaction(observation: { content: 'thanks' })
+
+      registry.for(identity: identity_y)
+    end
+
+    it 'removes the store for the given identity' do
+      registry.erase_partner!(identity: identity_x)
+      # A new store is created — weights reset to neutral
+      new_store = registry.for(identity: identity_x)
+      expect(new_store.weights['tone_adjustment']).to eq(0.5)
+      expect(new_store.history).to be_empty
+    end
+
+    it 'leaves other identities untouched' do
+      store_y = registry.for(identity: identity_y)
+      original_y = store_y.object_id
+      registry.erase_partner!(identity: identity_x)
+      expect(registry.for(identity: identity_y).object_id).to eq(original_y)
+    end
+
+    it 'returns true' do
+      expect(registry.erase_partner!(identity: identity_x)).to be true
+    end
+
+    it 'returns true even when identity does not exist' do
+      expect(registry.erase_partner!(identity: 'unknown')).to be true
+    end
+  end
+
+  describe '#known_identities' do
+    it 'returns empty array when no identities registered' do
+      expect(registry.known_identities).to be_empty
+    end
+
+    it 'returns registered identities' do
+      registry.for(identity: identity_x)
+      registry.for(identity: identity_y)
+      expect(registry.known_identities).to contain_exactly(identity_x, identity_y)
+    end
+
+    it 'does not include erased identities' do
+      registry.for(identity: identity_x)
+      registry.erase_partner!(identity: identity_x)
+      expect(registry.known_identities).not_to include(identity_x)
+    end
+  end
+
+  describe 'boot-order / idempotent registration' do
+    it 're-registering an already-registered identity is a no-op (no duplicate store)' do
+      first = registry.for(identity: identity_x)
+      second = registry.for(identity: identity_x)
+      expect(first).to equal(second)
+    end
+  end
+
+  describe 'fail-closed guard' do
+    it 'to_apollo_entries_for returns empty array when identity not registered' do
+      expect(registry.to_apollo_entries_for(identity: 'unregistered')).to eq([])
+    end
+
+    it 'to_apollo_entries_for returns entries for a registered identity' do
+      registry.for(identity: identity_x)
+      entries = registry.to_apollo_entries_for(identity: identity_x)
+      expect(entries).to be_an(Array)
+      expect(entries).not_to be_empty
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/trust/helpers/trust_map_spec.rb

@@ -296,4 +296,70 @@ RSpec.describe Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap do
       expect(map.count).to eq(3)
     end
   end
+
+  describe 'partner_identity keying (H0)' do
+    let(:partner_x) { 'user:alice' }
+    let(:partner_y) { 'user:bob' }
+
+    it 'entries scoped to partner_x are not visible under partner_y' do
+      map.record_interaction(agent_id, positive: true, partner_identity: partner_x)
+      expect(map.get(agent_id, partner_identity: partner_y)).to be_nil
+    end
+
+    it 'independent entries exist per partner_identity' do
+      map.record_interaction(agent_id, positive: true, partner_identity: partner_x)
+      map.record_interaction(agent_id, positive: false, partner_identity: partner_y)
+      expect(map.get(agent_id, partner_identity: partner_x)[:composite]).to be >
+                                                                            map.get(agent_id, partner_identity: partner_y)[:composite]
+    end
+
+    it 'entries keyed without partner_identity are independent from partner-scoped entries' do
+      map.record_interaction(agent_id, positive: true)
+      map.record_interaction(agent_id, positive: false, partner_identity: partner_x)
+      expect(map.get(agent_id)[:composite]).not_to eq(map.get(agent_id, partner_identity: partner_x)[:composite])
+    end
+
+    it 'count includes all partner-scoped entries' do
+      map.get_or_create(agent_id, partner_identity: partner_x)
+      map.get_or_create(agent_id, partner_identity: partner_y)
+      expect(map.count).to eq(2)
+    end
+  end
+
+  describe '#erase_partner!(identity:)' do
+    let(:partner_x) { 'user:alice' }
+    let(:partner_y) { 'user:bob' }
+
+    before do
+      map.record_interaction(agent_id, positive: true, partner_identity: partner_x)
+      map.record_interaction(agent_id, positive: true, partner_identity: partner_y)
+      map.record_interaction('other-agent', positive: true, partner_identity: partner_x)
+    end
+
+    it 'removes all entries for the given partner_identity' do
+      map.erase_partner!(identity: partner_x)
+      expect(map.get(agent_id, partner_identity: partner_x)).to be_nil
+      expect(map.get('other-agent', partner_identity: partner_x)).to be_nil
+    end
+
+    it 'leaves entries for other partner identities untouched' do
+      map.erase_partner!(identity: partner_x)
+      expect(map.get(agent_id, partner_identity: partner_y)).not_to be_nil
+    end
+
+    it 'marks the map as dirty' do
+      map.mark_clean!
+      map.erase_partner!(identity: partner_x)
+      expect(map).to be_dirty
+    end
+
+    it 'returns the count of removed entries' do
+      count = map.erase_partner!(identity: partner_x)
+      expect(count).to eq(2)
+    end
+
+    it 'returns 0 when no entries exist for that identity' do
+      expect(map.erase_partner!(identity: 'unknown')).to eq(0)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-social
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.20
 platform: ruby
 authors:
 - Esity
@@ -192,6 +192,7 @@ files:
 - lib/legion/extensions/agentic/social/attachment/version.rb
 - lib/legion/extensions/agentic/social/calibration.rb
 - lib/legion/extensions/agentic/social/calibration/client.rb
+- lib/legion/extensions/agentic/social/calibration/helpers/calibration_registry.rb
 - lib/legion/extensions/agentic/social/calibration/helpers/calibration_store.rb
 - lib/legion/extensions/agentic/social/calibration/helpers/constants.rb
 - lib/legion/extensions/agentic/social/calibration/runners/calibration.rb
@@ -335,6 +336,7 @@ files:
 - spec/legion/extensions/agentic/social/attachment/helpers/attachment_store_spec.rb
 - spec/legion/extensions/agentic/social/attachment/helpers/constants_spec.rb
 - spec/legion/extensions/agentic/social/attachment/runners/attachment_spec.rb
+- spec/legion/extensions/agentic/social/calibration/helpers/calibration_registry_spec.rb
 - spec/legion/extensions/agentic/social/calibration/helpers/calibration_store_spec.rb
 - spec/legion/extensions/agentic/social/calibration/helpers/constants_spec.rb
 - spec/legion/extensions/agentic/social/calibration/runners/calibration_spec.rb