lex-agentic-social 0.1.18 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c669852940dd9abfa0890d908ed6520df5ba9aa89dad4fc58fadd28a8ecd8529
-  data.tar.gz: 65832a10c828873e86131c0e1c7adbc23708a70f607ace40f73e1b4aa457dd33
+  metadata.gz: a649d923310d4a98480e6069c03d586585c2a27d3045c625f5c76d608b066016
+  data.tar.gz: d5983148aebfa19722b6ae1c5c4e564bd7be94455f3838401bbbe36cdbc087fe
 SHA512:
-  metadata.gz: 821f62c6dd7086ab97cc23958319080e4b6fcd8eddb2f59929bc6c9c9fa24291ef3c2d32eedf08767f67a5cbbad312a9ea9e12703429060a9d3aa3a4d2327284
-  data.tar.gz: 83751ac84ae50a28275479b1ef216f40ec43de7d75f45116e7e383ca649f73763da16b00ca9737ab76d67a23bcf9f3352841c8c49f806dc745874e3f334ab136
+  metadata.gz: cc6fc74f2620bc3e2cd96c2ba567f61dd0d1596127e33c75db88af80048879944d8d8719f861c7d2b9368d0d53a87f4ea2978c0c7e0e52b949f91b4168b5d650
+  data.tar.gz: e6de6e946ebb7468dd4adf14e35e97e6104cfd13f288b7730cd1f92420764713ea0afb4ed6c3a137f2146765da060de24e0e41a70a6000a9c73148c3d904b3f8

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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`.
+- Governance Proposal store now persists to Apollo Local on create, vote, and resolution — safety-critical proposal state survives restarts.
+- ConsentMap changes (tier changes, action outcomes, pending approvals) are now saved to local storage automatically on every mutation.
+- ConflictLog now evicts old resolved conflicts (30-day retention) and enforces a 1000-entry cap to prevent unbounded memory growth.
+
 ## [0.1.18] - 2026-05-29
 ### Added
 - Database index on `trust_entries.domain` column for faster filtered domain lookups

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

@@ -65,7 +65,13 @@ module Legion
 
                 context = summarize_traces(traces)
                 prompt = build_preference_prompt(context)
-                result = Legion::LLM.ask(message: prompt)
+                result = Legion::LLM.chat(
+                  message: [
+                    { role: 'system', content: 'You are a preference inference engine. Respond ONLY with JSON.' },
+                    { role: 'user', content: prompt }
+                  ],
+                  caller:  { extension: 'lex-agentic-social', mode: :calibration }
+                )
                 return { success: false, error: :llm_failed } unless result&.content
 
                 parsed = parse_preference_response(result.content)

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/conflict/helpers/conflict_log.rb

@@ -9,6 +9,9 @@ module Legion
         module Conflict
           module Helpers
             class ConflictLog
+              MAX_CONFLICTS = 1000
+              RESOLVED_RETENTION_DAYS = 30
+
               attr_reader :conflicts
 
               def initialize
@@ -61,6 +64,39 @@ module Legion
               def count
                 @conflicts.size
               end
+
+              def evict
+                evict_expired_resolved
+                evict_overflow
+              end
+
+              private
+
+              def evict_expired_resolved
+                cutoff = Time.now.utc - (RESOLVED_RETENTION_DAYS * 86_400)
+                @conflicts.reject! do |_id, conflict|
+                  conflict[:status] == :resolved && conflict[:resolved_at] && conflict[:resolved_at] < cutoff
+                end
+              end
+
+              def evict_overflow
+                return if @conflicts.size <= MAX_CONFLICTS
+
+                # Evict oldest resolved conflicts first, then oldest active
+                resolved = @conflicts.select { |_, c| c[:status] == :resolved }
+                active   = @conflicts.select { |_, c| c[:status] == :active }
+
+                # Remove oldest resolved until under limit
+                resolved.sort_by { |_, c| c[:resolved_at] || c[:created_at] }
+                        .first(resolved.size - 50)
+                        .each_key { |id| @conflicts.delete(id) }
+                return if @conflicts.size <= MAX_CONFLICTS
+
+                # Still over? Remove oldest active
+                active.sort_by { |_, c| c[:created_at] }
+                      .first(active.size - 10)
+                      .each_key { |id| @conflicts.delete(id) }
+              end
             end
           end
         end

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

@@ -17,6 +17,7 @@ module Legion
 
                 id = conflict_log.record(parties: parties, severity: severity, description: description)
                 conflict = conflict_log.get(id)
+                conflict_log.evict
                 log.info "[conflict] registered: id=#{id[0..7]} severity=#{severity} posture=#{conflict[:posture]} parties=#{parties.join(',')}"
                 { conflict_id: id, severity: severity, posture: conflict[:posture] }
               end

data/lib/legion/extensions/agentic/social/consent/helpers/consent_map.rb

@@ -14,38 +14,32 @@ module Legion
               attr_reader :domains
 
               def initialize
-                @domains = Hash.new do |h, k|
-                  h[k] = {
-                    tier:                 Tiers::DEFAULT_TIER,
-                    success_count:        0,
-                    failure_count:        0,
-                    total_actions:        0,
-                    last_changed_at:      nil,
-                    history:              [],
-                    pending_tier:         nil,
-                    pending_since:        nil,
-                    pending_requested_by: nil
-                  }
-                end
+                @domains = {}
                 load_from_local
               end
 
               def get_tier(domain)
-                @domains[domain][:tier]
+                entry = @domains[domain]
+                return Tiers::DEFAULT_TIER unless entry
+
+                entry[:tier]
               end
 
               def set_tier(domain, tier)
                 return unless Tiers.valid_tier?(tier)
 
+                ensure_domain(domain)
                 entry = @domains[domain]
                 old_tier = entry[:tier]
                 entry[:tier] = tier
                 entry[:last_changed_at] = Time.now.utc
                 entry[:history] << { from: old_tier, to: tier, at: Time.now.utc }
                 entry[:history].shift while entry[:history].size > 50
+                persist!
               end
 
               def record_outcome(domain, success:)
+                ensure_domain(domain)
                 entry = @domains[domain]
                 entry[:total_actions] += 1
                 if success
@@ -53,18 +47,19 @@ module Legion
                 else
                   entry[:failure_count] += 1
                 end
+                persist!
               end
 
               def success_rate(domain)
                 entry = @domains[domain]
-                return 0.0 if entry[:total_actions].zero?
+                return 0.0 unless entry && entry[:total_actions].positive?
 
                 entry[:success_count].to_f / entry[:total_actions]
               end
 
               def eligible_for_change?(domain)
                 entry = @domains[domain]
-                return false if entry[:total_actions] < Tiers::MIN_ACTIONS_TO_PROMOTE
+                return false unless entry && entry[:total_actions] >= Tiers::MIN_ACTIONS_TO_PROMOTE
 
                 if entry[:last_changed_at]
                   (Time.now.utc - entry[:last_changed_at]) >= Tiers::PROMOTION_COOLDOWN
@@ -106,28 +101,36 @@ module Legion
               end
 
               def set_pending(domain, proposed_tier:, requested_by: 'system')
+                ensure_domain(domain)
                 entry = @domains[domain]
                 entry[:pending_tier] = proposed_tier
                 entry[:pending_since] = Time.now
                 entry[:pending_requested_by] = requested_by
+                persist!
                 entry
               end
 
               def clear_pending(domain)
                 entry = @domains[domain]
+                return unless entry
+
                 entry[:pending_tier] = nil
                 entry[:pending_since] = nil
                 entry[:pending_requested_by] = nil
+                persist!
                 entry
               end
 
               def pending?(domain)
-                !@domains[domain][:pending_tier].nil?
+                entry = @domains[domain]
+                return false unless entry
+
+                !entry[:pending_tier].nil?
               end
 
               def pending_expired?(domain, timeout: APPROVAL_TIMEOUT)
                 entry = @domains[domain]
-                return false unless entry[:pending_since]
+                return false unless entry && entry[:pending_since]
 
                 Time.now - entry[:pending_since] > timeout
               end
@@ -170,6 +173,7 @@ module Legion
                     []
                   end
 
+                  @domains[key] = new_entry
                   @domains[key].merge!(
                     tier:            row[:tier].to_sym,
                     success_count:   row[:success_count].to_i,
@@ -185,6 +189,28 @@ module Legion
 
               private
 
+              def ensure_domain(domain)
+                @domains[domain] = new_entry unless @domains.key?(domain)
+              end
+
+              def new_entry
+                {
+                  tier:                 Tiers::DEFAULT_TIER,
+                  success_count:        0,
+                  failure_count:        0,
+                  total_actions:        0,
+                  last_changed_at:      nil,
+                  history:              [],
+                  pending_tier:         nil,
+                  pending_since:        nil,
+                  pending_requested_by: nil
+                }
+              end
+
+              def persist!
+                save_to_local
+              end
+
               def success_rate_from(entry)
                 return 0.0 if entry[:total_actions].zero?
 

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/helpers/proposal.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'time'
 require 'securerandom'
 
 module Legion
@@ -8,16 +9,14 @@ module Legion
       module Social
         module Governance
           module Helpers
-            # NOTE: Proposal state is stored in-memory only (@proposals hash).
-            # This is a safety-critical system (controls consent and containment approval).
-            # Persistence to a durable store (e.g. legion-data) is required so that
-            # proposals survive process restarts. Implementing persistence is tracked
-            # as a separate task.
             class Proposal
+              PROPOSAL_TAG_BASE = %w[governance proposal].freeze
+
               attr_reader :proposals
 
               def initialize
                 @proposals = {}
+                load_from_apollo
               end
 
               def create(category:, description:, proposer:, council_size: Layers::MIN_COUNCIL_SIZE)
@@ -34,6 +33,7 @@ module Legion
                   created_at:    Time.now.utc,
                   resolved_at:   nil
                 }
+                save_proposal(id)
                 id
               end
 
@@ -51,6 +51,7 @@ module Legion
                   prop[:votes_against] << voter
                 end
 
+                save_proposal(proposal_id)
                 check_resolution(proposal_id)
               end
 
@@ -68,11 +69,65 @@ module Legion
 
                 prop[:status]      = :timed_out
                 prop[:resolved_at] = Time.now.utc
+                save_proposal(proposal_id)
                 prop
               end
 
+              def load_from_apollo
+                return false unless defined?(Legion::Apollo::Local) && Legion::Apollo::Local.started?
+
+                result = Legion::Apollo::Local.query_by_tags(tags: PROPOSAL_TAG_BASE, limit: 1000)
+                return false unless result[:success] && result[:results].is_a?(Array)
+
+                result[:results].each do |entry|
+                  data = ::JSON.parse(entry[:content], symbolize_names: true)
+                  pid = data[:proposal_id]
+                  next unless pid
+
+                  # Convert string timestamps back to Time objects
+                  data[:created_at] = Time.parse(data[:created_at].to_s) if data[:created_at]
+                  data[:resolved_at] = data[:resolved_at] ? Time.parse(data[:resolved_at].to_s) : nil
+
+                  # Ensure status is a symbol
+                  data[:status] = data[:status].to_sym if data[:status].is_a?(String)
+
+                  @proposals[pid] = data
+                rescue StandardError => e
+                  Legion::Logging.warn "[governance] load_from_apollo parse error: #{e.message}"
+                end
+
+                @proposals.any?
+              rescue StandardError => e
+                Legion::Logging.warn "[governance] load_from_apollo failed: #{e.message}"
+                false
+              end
+
               private
 
+              def save_proposal(proposal_id)
+                return unless defined?(Legion::Apollo::Local) && Legion::Apollo::Local.started?
+
+                prop = @proposals[proposal_id]
+                return unless prop
+
+                # Convert to JSON-safe format
+                serializable = prop.dup
+                serializable[:created_at] = prop[:created_at].is_a?(Time) ? prop[:created_at].iso8601 : prop[:created_at]
+                serializable[:resolved_at] = prop[:resolved_at]&.iso8601
+
+                content = Legion::JSON.dump(serializable)
+                tags = PROPOSAL_TAG_BASE + ["category:#{prop[:category]}", "status:#{prop[:status]}"]
+
+                Legion::Apollo::Local.upsert(
+                  content:               content,
+                  tags:                  tags,
+                  access_scope:          'private',
+                  identity_principal_id: nil
+                )
+              rescue StandardError => e
+                Legion::Logging.warn "[governance] save_proposal failed: #{e.message}"
+              end
+
               def check_resolution(proposal_id)
                 prop = @proposals[proposal_id]
                 total_votes = prop[:votes_for].size + prop[:votes_against].size
@@ -80,11 +135,13 @@ module Legion
                 if Layers.quorum_met?(prop[:votes_for].size, prop[:council_size])
                   prop[:status] = :approved
                   prop[:resolved_at] = Time.now.utc
+                  save_proposal(proposal_id)
                   :approved
                 elsif Layers.quorum_met?(prop[:votes_against].size, prop[:council_size]) ||
                       total_votes >= prop[:council_size]
                   prop[:status] = :rejected
                   prop[:resolved_at] = Time.now.utc
+                  save_proposal(proposal_id)
                   :rejected
                 else
                   :pending

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.18'
+        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.18
+  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