lex-agentic-social 0.1.19 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49f5148e440e4e58060bf6ff47c9dc8d31bfde5092ab17b7ad078fb95344e711
-  data.tar.gz: 191fddf9d835866196a20ed7efafcbfb4ef34729d7d5b585f7d68a95dc225b00
+  metadata.gz: 813631a90b8945655f76aaca3c5b8ba2bbb8b09a60126da891c1d3c6353e47a9
+  data.tar.gz: cc24309702a44a0a1cd7866d8b6632cce6551949079d646e6bb697f4bcd284a9
 SHA512:
-  metadata.gz: e052b2d246149565565a6f0a7654bb7d7bf689bc149c2bb17b22fdcc59c15339178805127b1a07e8a602a3d9fd1fcebb3e5b3a1bacef01622f6f4ac934be120f
-  data.tar.gz: 92f66448450959900ac87054fc9a5b4e9e442b3217f52d35e7b8a6e17c377317932c6f92ed129d64c82c177b101d7c95d30ce0a7e52a818f4d74c49edc87a695
+  metadata.gz: db8bafe82e2b2c3e57af811c93ca2cadbd5593d98c95c7deaef69764b55cc35ab8fd54ff3218c3ffce5bd310a002d20ec9f698058a9e90c876eb259cc347894b
+  data.tar.gz: 3e461b5ca49eb3d7ff2ad53c4da56c89ec9ed51f74a0cf37c13479a4a17ec57ee5c09e6a9025c07fdb7ddd744e1876ed435e8cba155cc2af47a04bb998b2e62e

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.1.21] - 2026-07-16
+### Added
+- `CalibrationStore#record_advisory` gains `applied:` kwarg to store which behavioral synapses were applied alongside the advisory.
+- `CalibrationStore#evaluate_reaction` now returns `reaction_score` (Float 0.0–1.0) and `applied` hash in its result hash, enabling legion-gaia's H2 synapse grading path.
+- `Calibration` runner `record_advisory_meta` accepts and passes through the `applied:` kwarg.
+- `Calibration` runner `update_calibration` passes through `reaction_score` and `applied` from the store result.
+
+## [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/helpers/calibration_store.rb

@@ -28,10 +28,11 @@ module Legion
                 self
               end
 
-              def record_advisory(advisory_id:, advisory_types:)
+              def record_advisory(advisory_id:, advisory_types:, applied: nil)
                 @last_advisory_meta = {
                   advisory_id:    advisory_id,
                   advisory_types: Array(advisory_types).map(&:to_s),
+                  applied:        applied,
                   timestamp:      Time.now.utc
                 }
               end
@@ -45,6 +46,7 @@ module Legion
 
                 reaction_score = compute_reaction_score(observation)
                 confidence = compute_confidence(observation)
+                applied_from_meta = @last_advisory_meta[:applied]
 
                 deltas = @last_advisory_meta[:advisory_types].map do |type|
                   apply_delta(type: type, reaction_score: reaction_score, confidence: confidence)
@@ -52,7 +54,7 @@ module Legion
 
                 @last_advisory_meta = nil
                 @dirty = true
-                { success: true, deltas: deltas }
+                { success: true, deltas: deltas, reaction_score: reaction_score, applied: applied_from_meta }
               end
 
               def calibration_weights

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

@@ -21,11 +21,12 @@ module Legion
                 result = calibration_store.evaluate_reaction(observation: observation)
                 return { success: true, skipped: :no_advisory } unless result
 
-                { success: true, deltas: result[:deltas], weights: calibration_store.calibration_weights }
+                { success: true, deltas: result[:deltas], weights: calibration_store.calibration_weights,
+                  reaction_score: result[:reaction_score], applied: result[:applied] }
               end
 
-              def record_advisory_meta(advisory_id:, advisory_types:, **)
-                calibration_store.record_advisory(advisory_id: advisory_id, advisory_types: advisory_types)
+              def record_advisory_meta(advisory_id:, advisory_types:, applied: nil, **)
+                calibration_store.record_advisory(advisory_id: advisory_id, advisory_types: advisory_types, applied: applied)
                 { success: true }
               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.21'
       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/calibration/helpers/calibration_store_spec.rb

@@ -48,6 +48,19 @@ RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Helpers::Calibr
       expect(result).not_to be_nil
       expect(result[:deltas].size).to eq(2)
     end
+
+    it 'stores applied kwarg when provided' do
+      applied_data = { synapse_ids: [1, 2, 3], strategy: 'tone' }
+      store.record_advisory(advisory_id: 'abc', advisory_types: [:tone_adjustment], applied: applied_data)
+      result = store.evaluate_reaction(observation: { content: 'thanks' })
+      expect(result[:applied]).to eq(applied_data)
+    end
+
+    it 'stores nil applied when not provided' do
+      store.record_advisory(advisory_id: 'abc', advisory_types: [:tone_adjustment])
+      result = store.evaluate_reaction(observation: { content: 'thanks' })
+      expect(result[:applied]).to be_nil
+    end
   end
 
   describe '#evaluate_reaction' do
@@ -90,6 +103,40 @@ RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Helpers::Calibr
         store.evaluate_reaction(observation: { content: 'thanks' })
         expect(store.history['tone_adjustment']).not_to be_empty
       end
+
+      it 'returns reaction_score as a float between 0.0 and 1.0' do
+        result = store.evaluate_reaction(observation: { content: 'thanks' })
+        expect(result[:reaction_score]).to be_a(Float)
+        expect(result[:reaction_score]).to be_between(0.0, 1.0)
+      end
+
+      it 'returns applied from recorded advisory' do
+        store.mark_clean!
+        applied_data = { synapse_ids: [10, 20] }
+        store.record_advisory(advisory_id: 'test2', advisory_types: [:tone_adjustment], applied: applied_data)
+        result = store.evaluate_reaction(observation: { content: 'ok' })
+        expect(result[:applied]).to eq(applied_data)
+      end
+    end
+
+    context 'reaction_score signal ranges' do
+      it 'returns reaction_score >= 0.6 for positive feedback' do
+        store.record_advisory(advisory_id: 'pos', advisory_types: [:tone_adjustment])
+        result = store.evaluate_reaction(observation: { content: 'thanks, perfect!', direct_address: true, content_length: 50 })
+        expect(result[:reaction_score]).to be >= 0.6
+      end
+
+      it 'returns reaction_score <= 0.4 for negative feedback' do
+        store.record_advisory(advisory_id: 'neg', advisory_types: [:tone_adjustment])
+        result = store.evaluate_reaction(observation: { content: 'no, wrong, stop', content_length: 5 })
+        expect(result[:reaction_score]).to be <= 0.4
+      end
+
+      it 'returns reaction_score between 0.4 and 0.6 for neutral feedback' do
+        store.record_advisory(advisory_id: 'neu', advisory_types: [:tone_adjustment])
+        result = store.evaluate_reaction(observation: { content: 'I see', content_length: 10 })
+        expect(result[:reaction_score]).to be_between(0.4, 0.6)
+      end
     end
   end
 

data/spec/legion/extensions/agentic/social/calibration/runners/calibration_spec.rb

@@ -22,6 +22,20 @@ RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Runners::Calibr
       expect(result[:success]).to be true
       expect(result[:deltas]).not_to be_empty
     end
+
+    it 'returns reaction_score in result when advisory recorded' do
+      client.record_advisory_meta(advisory_id: 'test', advisory_types: [:tone_adjustment])
+      result = client.update_calibration(observation: { content: 'thanks', direct_address: true, content_length: 20 })
+      expect(result).to have_key(:reaction_score)
+      expect(result[:reaction_score]).to be_a(Float)
+    end
+
+    it 'returns applied in result when advisory recorded with applied kwarg' do
+      applied_data = { synapse_ids: [5, 6] }
+      client.record_advisory_meta(advisory_id: 'test', advisory_types: [:tone_adjustment], applied: applied_data)
+      result = client.update_calibration(observation: { content: 'thanks', direct_address: true, content_length: 20 })
+      expect(result[:applied]).to eq(applied_data)
+    end
   end
 
   describe '#record_advisory_meta' do
@@ -29,6 +43,15 @@ RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Runners::Calibr
       result = client.record_advisory_meta(advisory_id: 'abc', advisory_types: [:partner_hint])
       expect(result[:success]).to be true
     end
+
+    it 'accepts and passes applied kwarg' do
+      applied_data = { synapse_ids: [1, 2], strategy: 'verbosity' }
+      result = client.record_advisory_meta(advisory_id: 'abc', advisory_types: [:partner_hint], applied: applied_data)
+      expect(result[:success]).to be true
+      # Verify the applied data flows through to evaluate_reaction
+      eval_result = client.update_calibration(observation: { content: 'thanks', content_length: 10 })
+      expect(eval_result[:applied]).to eq(applied_data)
+    end
   end
 
   describe '#detect_explicit_feedback' do

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.21
 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