lex-agentic-social 0.1.20 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a649d923310d4a98480e6069c03d586585c2a27d3045c625f5c76d608b066016
-  data.tar.gz: d5983148aebfa19722b6ae1c5c4e564bd7be94455f3838401bbbe36cdbc087fe
+  metadata.gz: c6d1a18883c8b134af22df999670a6f0cd58ad633c193af3ae9d04cf05cad356
+  data.tar.gz: 9c83991c4a5787d6b2f75a21cd199d28eac62e823e00d76d8a88240464c02f93
 SHA512:
-  metadata.gz: cc6fc74f2620bc3e2cd96c2ba567f61dd0d1596127e33c75db88af80048879944d8d8719f861c7d2b9368d0d53a87f4ea2978c0c7e0e52b949f91b4168b5d650
-  data.tar.gz: e6de6e946ebb7468dd4adf14e35e97e6104cfd13f288b7730cd1f92420764713ea0afb4ed6c3a137f2146765da060de24e0e41a70a6000a9c73148c3d904b3f8
+  metadata.gz: 27f56a7138662a32573fef178cffebd154d386bb620ec48eedf59248a4f8412e1ce12ee70a4a3598725678c8d1e9baa88076fe2f9888834af2c3c7fa480df105
+  data.tar.gz: 32e06a56b8c36e1f70dca344ce6836ba502f4ac4d1f7a1b32ca9535c9e82fb2d89dae0cc6b851b795103f67f780f17b88f7fd120cb9b0341127061a6512e18f0

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.2.0] - 2026-10-29
+### Changed
+- Scope calibration by human and match pending feedback to existing exchange attribution. Identified feedback cannot consume legacy unattributed receipts; callers must pass matching identity and applied exchange context.
+- Preserve partner identity in serialized trust state. Older readers that discard this identity are not safe rollback targets for scoped trust data.
+### Fixed
+- Reject ambiguous and duplicate feedback; evaluate against prior baselines and prioritize explicit corrections over weak timing/length cues.
+- Stop treating delayed or terse replies as negative evidence, and leave missing measurements out of baseline updates.
+- Honor partner-scoped trust during recording, reinforcement, lookup, and delegation queries.
+- Reject expired consent approvals synchronously and invalidate pending approval after a tier change without affecting other domains.
+
+## [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.

data/README.md

@@ -5,7 +5,7 @@ Domain consolidation gem for social cognition, governance, and multi-agent inter
 ## Overview
 
 **Gem**: `lex-agentic-social`
-**Version**: 0.1.14
+**Version**: 0.2.0
 **Namespace**: `Legion::Extensions::Agentic::Social`
 
 ## Sub-Modules
@@ -48,6 +48,27 @@ Domain consolidation gem for social cognition, governance, and multi-agent inter
 
 `Social::Consent` governs whether actions require human approval — the HITL gate must not be bypassed. `Social::Governance` provides the council approval mechanism used by `Defense::Extinction` for containment escalation.
 
+## Scoped calibration and trust
+
+Pass a verified `identity:` when recording an advisory, or include it in the
+existing `applied:` hash. Carry the same identity and available `exchange_id`
+or `conversation_id` into the feedback observation. Multiple pending
+advisories are matched by this attribution; ambiguous, mismatched, expired,
+or repeated feedback cannot reinforce another response.
+
+`Calibration::Client.new(calibration_registry: registry)` shares an explicitly
+owned registry across clients. Without injection, clients remain independent.
+Legacy unscoped receipts only accept unscoped feedback. GAIA must supply the
+matching receipt attribution before identified feedback can be graded.
+Receipt deduplication is process-local within the existing one-hour lifetime,
+not durable exactly-once processing.
+
+Trust runner methods accept `partner_identity:` independently of the worker's
+`agent_id:`. Scoped trust is preserved through Apollo serialization and is
+separate from legacy unscoped trust. Do not roll persisted scoped trust back
+to readers that discard partner identity: they can merge separate people.
+Calibration and trust do not grant consent or tool authority.
+
 ## Installation
 
 ```ruby

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

@@ -8,13 +8,10 @@ module Legion
           class Client
             include Runners::Calibration
 
-            def initialize(**)
-              @calibration_store = Helpers::CalibrationStore.new
+            def initialize(calibration_store: nil, calibration_registry: nil, **)
+              @calibration_store = calibration_store || Legion::Extensions::Agentic::Social::Calibration::Helpers::CalibrationStore.new
+              @calibration_registry = calibration_registry || Legion::Extensions::Agentic::Social::Calibration::Helpers::CalibrationRegistry.new
             end
-
-            private
-
-            attr_reader :calibration_store
           end
         end
       end

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

@@ -14,7 +14,8 @@ module Legion
                   [type.to_s, Constants::NEUTRAL_SCORE]
                 end
                 @history = {}
-                @last_advisory_meta = nil
+                @pending_advisories = {}
+                @evaluated_advisories = {}
                 @partner_baselines = { 'avg_latency' => nil, 'avg_length' => nil }
                 @dirty = false
               end
@@ -28,31 +29,41 @@ module Legion
                 self
               end
 
-              def record_advisory(advisory_id:, advisory_types:)
-                @last_advisory_meta = {
+              def record_advisory(advisory_id:, advisory_types:, applied: nil, identity: nil)
+                return if identity && applied&.dig(:identity) && identity.to_s != applied[:identity].to_s
+
+                expire_advisories!
+                return if @evaluated_advisories.key?(advisory_id) || @pending_advisories.key?(advisory_id)
+
+                attribution = (applied || {}).slice(:identity, :exchange_id, :conversation_id).compact
+                attribution[:identity] = identity unless identity.nil?
+                @pending_advisories[advisory_id] = {
                   advisory_id:    advisory_id,
-                  advisory_types: Array(advisory_types).map(&:to_s),
+                  advisory_types: Array(advisory_types).map(&:to_s).uniq,
+                  applied:        applied,
+                  attribution:    attribution,
                   timestamp:      Time.now.utc
                 }
               end
 
               def evaluate_reaction(observation:)
-                return nil unless @last_advisory_meta
-                return nil if @last_advisory_meta[:advisory_types].empty?
+                expire_advisories!
+                candidates = @pending_advisories.values.select { |meta| matches_observation?(meta, observation) }
+                return nil unless candidates.one?
 
-                elapsed = Time.now.utc - @last_advisory_meta[:timestamp]
-                return nil if elapsed > 3600
+                meta = candidates.first
+                return nil if meta[:advisory_types].empty?
 
                 reaction_score = compute_reaction_score(observation)
                 confidence = compute_confidence(observation)
-
-                deltas = @last_advisory_meta[:advisory_types].map do |type|
+                deltas = meta[:advisory_types].map do |type|
                   apply_delta(type: type, reaction_score: reaction_score, confidence: confidence)
                 end
 
-                @last_advisory_meta = nil
+                @pending_advisories.delete(meta[:advisory_id])
+                @evaluated_advisories[meta[:advisory_id]] = meta[:timestamp]
                 @dirty = true
-                { success: true, deltas: deltas }
+                { success: true, deltas: deltas, reaction_score: reaction_score, applied: meta[:applied] }
               end
 
               def calibration_weights
@@ -61,23 +72,19 @@ module Legion
 
               def detect_explicit_feedback(content)
                 text = content.to_s
-                return :positive if text.match?(Constants::POSITIVE_PATTERNS)
                 return :negative if text.match?(Constants::NEGATIVE_PATTERNS)
+                return :positive if text.match?(Constants::POSITIVE_PATTERNS)
 
                 :neutral
               end
 
               def update_baseline(latency:, length:)
-                @partner_baselines['avg_latency'] = if @partner_baselines['avg_latency']
-                                                      (@partner_baselines['avg_latency'] * 0.9) + (latency.to_f * 0.1)
-                                                    else
-                                                      latency.to_f
-                                                    end
-                @partner_baselines['avg_length'] = if @partner_baselines['avg_length']
-                                                     (@partner_baselines['avg_length'] * 0.9) + (length.to_f * 0.1)
-                                                   else
-                                                     length.to_f
-                                                   end
+                { 'avg_latency' => latency, 'avg_length' => length }.each do |key, value|
+                  next if value.nil?
+
+                  previous = @partner_baselines[key]
+                  @partner_baselines[key] = previous ? (previous * 0.9) + (value.to_f * 0.1) : value.to_f
+                end
               end
 
               def to_apollo_entries
@@ -118,28 +125,40 @@ module Legion
 
               private
 
+              def expire_advisories!
+                cutoff = Time.now.utc - 3600
+                @pending_advisories.delete_if { |_id, meta| meta[:timestamp] < cutoff }
+                @evaluated_advisories.delete_if { |_id, timestamp| timestamp < cutoff }
+              end
+
+              def matches_observation?(meta, observation)
+                return false if observation[:advisory_id] && observation[:advisory_id] != meta[:advisory_id]
+
+                attribution = meta[:attribution]
+                return false unless attribution.all? do |key, value|
+                  !value.to_s.strip.empty? && observation[key] && observation[key].to_s == value.to_s
+                end
+
+                %i[identity exchange_id conversation_id].none? do |key|
+                  observation[key] && !attribution.key?(key)
+                end
+              end
+
               def compute_reaction_score(observation)
                 score = 0.0
 
                 feedback = detect_explicit_feedback(observation[:content] || '')
-                case feedback
-                when :positive then score += Constants::SIGNAL_WEIGHTS[:explicit_feedback]
-                when :negative then score -= Constants::SIGNAL_WEIGHTS[:explicit_feedback]
-                end
+                return (1.0 + Constants::SIGNAL_WEIGHTS[:explicit_feedback]) / 2.0 if feedback == :positive
+                return (1.0 - Constants::SIGNAL_WEIGHTS[:explicit_feedback]) / 2.0 if feedback == :negative
 
-                if @partner_baselines['avg_latency'] && observation[:latency]
+                if @partner_baselines['avg_latency']&.positive? && observation[:latency]
                   ratio = observation[:latency].to_f / @partner_baselines['avg_latency']
-                  latency_signal = if ratio < 0.8
-                                     1.0
-                                   else
-                                     (ratio > 1.5 ? -1.0 : 0.0)
-                                   end
-                  score += Constants::SIGNAL_WEIGHTS[:response_latency] * latency_signal
+                  score += Constants::SIGNAL_WEIGHTS[:response_latency] if ratio < 0.8
                 end
 
                 if @partner_baselines['avg_length'] && observation[:content_length]
-                  length_signal = observation[:content_length].to_f / [@partner_baselines['avg_length'], 1].max > 0.5 ? 1.0 : -1.0
-                  score += Constants::SIGNAL_WEIGHTS[:message_length] * length_signal
+                  ratio = observation[:content_length].to_f / [@partner_baselines['avg_length'], 1].max
+                  score += Constants::SIGNAL_WEIGHTS[:message_length] if ratio > 0.5
                 end
 
                 score += Constants::SIGNAL_WEIGHTS[:direct_address] if observation[:direct_address]

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

@@ -10,22 +10,32 @@ module Legion
               include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers) &&
                                                           Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
-              def update_calibration(observation: nil, **)
+              def update_calibration(observation: nil, identity: nil, **)
                 return { success: true, skipped: :no_observation } unless observation
+                return { success: true, skipped: :identity_mismatch } if identity && observation[:identity] && identity.to_s != observation[:identity].to_s
 
-                calibration_store.update_baseline(
-                  latency: observation[:latency] || 0,
-                  length:  observation[:content_length] || 0
-                )
+                identity ||= observation[:identity]
+                return { success: true, skipped: :unattributed_identity } if identity && identity.to_s.strip.empty?
 
-                result = calibration_store.evaluate_reaction(observation: observation)
+                store = calibration_store(identity: identity)
+                observation = observation.merge(identity: identity) if identity
+                result = store.evaluate_reaction(observation: observation)
+                store.update_baseline(latency: observation[:latency], length: observation[:content_length])
                 return { success: true, skipped: :no_advisory } unless result
 
-                { success: true, deltas: result[:deltas], weights: calibration_store.calibration_weights }
+                { success: true, deltas: result[:deltas], weights: 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, identity: nil, **)
+                return { success: false, error: :identity_mismatch } if identity && applied&.dig(:identity) && identity.to_s != applied[:identity].to_s
+
+                identity ||= applied&.dig(:identity)
+                return { success: false, error: :unattributed_identity } if identity && identity.to_s.strip.empty?
+
+                calibration_store(identity: identity).record_advisory(
+                  advisory_id: advisory_id, advisory_types: advisory_types, applied: applied, identity: identity
+                )
                 { success: true }
               end
 
@@ -34,16 +44,17 @@ module Legion
                 { success: true, feedback: feedback }
               end
 
-              def calibration_weights(**)
-                { success: true, weights: calibration_store.calibration_weights }
+              def calibration_weights(identity: nil, **)
+                { success: true, weights: calibration_store(identity: identity).calibration_weights }
               end
 
-              def calibration_stats(**)
+              def calibration_stats(identity: nil, **)
+                store = calibration_store(identity: identity)
                 {
                   success:        true,
-                  weights:        calibration_store.calibration_weights,
-                  history_counts: calibration_store.history.transform_values(&:size),
-                  dirty:          calibration_store.dirty?
+                  weights:        store.calibration_weights,
+                  history_counts: store.history.transform_values(&:size),
+                  dirty:          store.dirty?
                 }
               end
 
@@ -104,8 +115,11 @@ module Legion
 
               private
 
-              def calibration_store
-                @calibration_store ||= Helpers::CalibrationStore.new
+              def calibration_store(identity: nil)
+                return @calibration_store ||= Legion::Extensions::Agentic::Social::Calibration::Helpers::CalibrationStore.new if identity.nil?
+
+                @calibration_registry ||= Legion::Extensions::Agentic::Social::Calibration::Helpers::CalibrationRegistry.new
+                @calibration_registry.for(identity: identity)
               end
 
               def should_extract_preferences?

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

@@ -31,6 +31,11 @@ module Legion
                 ensure_domain(domain)
                 entry = @domains[domain]
                 old_tier = entry[:tier]
+                if old_tier != tier
+                  entry[:pending_tier] = nil
+                  entry[:pending_since] = nil
+                  entry[:pending_requested_by] = nil
+                end
                 entry[:tier] = tier
                 entry[:last_changed_at] = Time.now.utc
                 entry[:history] << { from: old_tier, to: tier, at: Time.now.utc }

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

@@ -119,6 +119,11 @@ module Legion
                 map = consent_map
                 return { approved: false, error: 'no_pending_approval' } unless map.pending?(domain)
 
+                if map.pending_expired?(domain)
+                  map.clear_pending(domain)
+                  return { approved: false, error: 'approval_expired' }
+                end
+
                 pending_tier = map.domains[domain][:pending_tier]
                 old_tier = map.get_tier(domain)
                 map.clear_pending(domain)

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

@@ -28,7 +28,9 @@ module Legion
               end
 
               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)
+                @entries[key(agent_id, domain, partner_identity)] ||= TrustModel.new_trust_entry(agent_id: agent_id, domain: domain).tap do |entry|
+                  entry[:partner_identity] = partner_identity.to_s if partner_identity
+                end
               end
 
               def record_interaction(agent_id, positive:, domain: :general, partner_identity: nil)
@@ -61,8 +63,8 @@ module Legion
                 removed.size
               end
 
-              def reinforce_dimension(agent_id, dimension:, domain: :general, amount: TrustModel::TRUST_REINFORCEMENT)
-                entry = get_or_create(agent_id, domain: domain)
+              def reinforce_dimension(agent_id, dimension:, domain: :general, amount: TrustModel::TRUST_REINFORCEMENT, partner_identity: nil)
+                entry = get_or_create(agent_id, domain: domain, partner_identity: partner_identity)
                 return unless TrustModel::TRUST_DIMENSIONS.include?(dimension)
 
                 entry[:dimensions][dimension] = TrustModel.clamp(entry[:dimensions][dimension] + amount)
@@ -84,14 +86,16 @@ module Legion
                 decayed
               end
 
-              def trusted_agents(domain: :general, min_trust: TrustModel::TRUST_CONSIDER_THRESHOLD)
-                @entries.values
-                        .select { |e| e[:domain] == domain && e[:composite] >= min_trust }
-                        .sort_by { |e| -e[:composite] }
+              def trusted_agents(domain: :general, min_trust: TrustModel::TRUST_CONSIDER_THRESHOLD, partner_identity: nil)
+                identity = partner_identity&.to_s
+                selected = @entries.values.select do |entry|
+                  entry[:domain] == domain && entry[:composite] >= min_trust && entry[:partner_identity] == identity
+                end
+                selected.sort_by! { |entry| -entry[:composite] }
               end
 
-              def delegatable_agents(domain: :general)
-                trusted_agents(domain: domain, min_trust: TrustModel::TRUST_DELEGATE_THRESHOLD)
+              def delegatable_agents(domain: :general, partner_identity: nil)
+                trusted_agents(domain: domain, min_trust: TrustModel::TRUST_DELEGATE_THRESHOLD, partner_identity: partner_identity)
               end
 
               def count
@@ -101,8 +105,10 @@ module Legion
               def to_apollo_entries
                 @entries.map do |_key, entry|
                   tags = build_apollo_tags(entry[:agent_id], entry[:domain])
+                  tags << "partner:#{entry[:partner_identity]}" if entry[:partner_identity]
                   content = Legion::JSON.dump({
                                                 agent_id:          entry[:agent_id].to_s,
+                                                partner_identity:  entry[:partner_identity],
                                                 domain:            entry[:domain].to_s,
                                                 dimensions:        entry[:dimensions],
                                                 composite:         entry[:composite],
@@ -155,8 +161,10 @@ module Legion
                 domain_val = (flex(data, 'domain') || 'general').to_sym
                 dims = restore_dimensions(flex(data, 'dimensions') || {})
 
-                @entries[key(agent_id, domain_val)] = {
+                partner_identity = flex(data, 'partner_identity')
+                @entries[key(agent_id, domain_val, partner_identity)] = {
                   agent_id:          agent_id,
+                  partner_identity:  partner_identity&.to_s,
                   domain:            domain_val,
                   dimensions:        dims,
                   composite:         (flex(data, 'composite') || TrustModel::NEUTRAL_TRUST).to_f,

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

@@ -10,8 +10,8 @@ module Legion
               include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                           Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
-              def get_trust(agent_id:, domain: :general, **)
-                entry = trust_map.get(agent_id, domain: domain)
+              def get_trust(agent_id:, domain: :general, partner_identity: nil, **)
+                entry = trust_map.get(agent_id, domain: domain, partner_identity: partner_identity)
                 if entry
                   log.debug "[trust] get agent=#{agent_id} domain=#{domain} composite=#{entry[:composite].round(2)}"
                   { found: true, trust: entry }
@@ -21,8 +21,8 @@ module Legion
                 end
               end
 
-              def record_trust_interaction(agent_id:, positive:, domain: :general, **)
-                entry = trust_map.record_interaction(agent_id, domain: domain, positive: positive)
+              def record_trust_interaction(agent_id:, positive:, domain: :general, partner_identity: nil, **)
+                entry = trust_map.record_interaction(agent_id, domain: domain, positive: positive, partner_identity: partner_identity)
                 msg = "[trust] interaction: agent=#{agent_id} domain=#{domain} positive=#{positive} " \
                       "composite=#{entry[:composite].round(2)} total=#{entry[:interaction_count]}"
                 log.info msg
@@ -35,10 +35,10 @@ module Legion
                 }
               end
 
-              def reinforce_trust_dimension(agent_id:, dimension:, domain: :general, amount: nil, **)
+              def reinforce_trust_dimension(agent_id:, dimension:, domain: :general, amount: nil, partner_identity: nil, **)
                 amt = amount || Helpers::TrustModel::TRUST_REINFORCEMENT
-                trust_map.reinforce_dimension(agent_id, domain: domain, dimension: dimension, amount: amt)
-                entry = trust_map.get(agent_id, domain: domain)
+                trust_map.reinforce_dimension(agent_id, domain: domain, dimension: dimension, amount: amt, partner_identity: partner_identity)
+                entry = trust_map.get(agent_id, domain: domain, partner_identity: partner_identity)
                 log.debug "[trust] reinforce: agent=#{agent_id} dimension=#{dimension} amount=#{amt} composite=#{entry[:composite].round(2)}"
                 { agent_id: agent_id, domain: domain, dimension: dimension, composite: entry[:composite] }
               end
@@ -49,15 +49,15 @@ module Legion
                 { decayed: decayed }
               end
 
-              def trusted_agents(domain: :general, min_trust: nil, **)
+              def trusted_agents(domain: :general, min_trust: nil, partner_identity: nil, **)
                 min = min_trust || Helpers::TrustModel::TRUST_CONSIDER_THRESHOLD
-                agents = trust_map.trusted_agents(domain: domain, min_trust: min)
+                agents = trust_map.trusted_agents(domain: domain, min_trust: min, partner_identity: partner_identity)
                 log.debug "[trust] trusted agents: domain=#{domain} min=#{min} count=#{agents.size}"
                 { agents: agents, count: agents.size }
               end
 
-              def delegatable_agents(domain: :general, **)
-                agents = trust_map.delegatable_agents(domain: domain)
+              def delegatable_agents(domain: :general, partner_identity: nil, **)
+                agents = trust_map.delegatable_agents(domain: domain, partner_identity: partner_identity)
                 log.debug "[trust] delegatable agents: domain=#{domain} count=#{agents.size}"
                 { agents: agents, count: agents.size }
               end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Social
-        VERSION = '0.1.20'
+        VERSION = '0.2.0'
       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,125 @@ 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: { advisory_id: 'test2', 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
+
+    it 'matches out-of-order feedback to its exchange without consuming the newer advisory' do
+      first = { identity: 'alice', exchange_id: 'first' }
+      second = { identity: 'alice', exchange_id: 'second' }
+      store.record_advisory(advisory_id: 'first', advisory_types: [:tone_adjustment], applied: first)
+      store.record_advisory(advisory_id: 'second', advisory_types: [:verbosity_adjustment], applied: second)
+
+      result = store.evaluate_reaction(observation: first.merge(content: 'wrong'))
+      expect(result[:applied]).to eq(first)
+      expect(store.calibration_weights['tone_adjustment']).to be < 0.5
+      expect(store.calibration_weights['verbosity_adjustment']).to eq(0.5)
+      expect(store.evaluate_reaction(observation: second.merge(content: 'thanks'))[:applied]).to eq(second)
+      expect(store.calibration_weights['verbosity_adjustment']).to be > 0.5
+    end
+
+    it 'leaves ambiguous and unattributed feedback ungraded until the exchange is identified' do
+      %w[first second].each do |exchange|
+        store.record_advisory(advisory_id: exchange, advisory_types: [:tone_adjustment],
+                              applied: { identity: 'alice', exchange_id: exchange })
+      end
+
+      expect(store.evaluate_reaction(observation: { identity: 'alice', content: 'wrong' })).to be_nil
+      expect(store.evaluate_reaction(observation: { exchange_id: 'first', content: 'wrong' })).to be_nil
+      expect(store.calibration_weights['tone_adjustment']).to eq(0.5)
+      result = store.evaluate_reaction(observation: { identity: 'alice', exchange_id: 'first', content: 'wrong' })
+      expect(result[:deltas].first[:new_weight]).to be < 0.5
+    end
+
+    it 'does not grade an unattributed advisory using an identified human' do
+      store.record_advisory(advisory_id: 'legacy', advisory_types: [:tone_adjustment])
+      expect(store.evaluate_reaction(observation: { identity: 'bob', content: 'wrong' })).to be_nil
+      expect(store.calibration_weights['tone_adjustment']).to eq(0.5)
+    end
+
+    it 'grades an advisory once despite repeated receipt and feedback delivery' do
+      applied = { identity: 'alice', exchange_id: 'exchange' }
+      2.times do
+        store.record_advisory(advisory_id: 'receipt', advisory_types: %i[tone_adjustment tone_adjustment], applied: applied)
+      end
+      store.evaluate_reaction(observation: applied.merge(content: 'thanks'))
+      weight = store.calibration_weights['tone_adjustment']
+      store.record_advisory(advisory_id: 'receipt', advisory_types: [:tone_adjustment], applied: applied)
+
+      expect(store.evaluate_reaction(observation: applied.merge(content: 'thanks'))).to be_nil
+      expect(store.calibration_weights['tone_adjustment']).to eq(weight)
+      expect(store.history['tone_adjustment'].size).to eq(1)
+    end
+
+    it 'does not guess which pending legacy advisory a reaction describes' do
+      store.record_advisory(advisory_id: 'first', advisory_types: [:tone_adjustment])
+      store.record_advisory(advisory_id: 'second', advisory_types: [:verbosity_adjustment])
+      expect(store.evaluate_reaction(observation: { content: 'wrong' })).to be_nil
+      expect(store.calibration_weights.values).to all(eq(0.5))
+    end
+
+    it 'keeps an explicit correction negative despite polite words and positive weak cues' do
+      store.update_baseline(latency: 10, length: 20)
+      store.record_advisory(advisory_id: 'correction', advisory_types: [:tone_adjustment])
+      result = store.evaluate_reaction(observation: {
+                                         content: 'thanks, but that is wrong', latency: 1,
+                                         content_length: 100, direct_address: true
+                                       })
+      expect(result[:reaction_score]).to be < 0.5
+      expect(store.calibration_weights['tone_adjustment']).to be < 0.5
+    end
+
+    it 'does not treat delayed terse replies as negative evidence' do
+      store.update_baseline(latency: 2, length: 100)
+      store.record_advisory(advisory_id: 'delayed', advisory_types: [:tone_adjustment])
+      result = store.evaluate_reaction(observation: { content: 'ok', latency: 500, content_length: 2 })
+      expect(result[:reaction_score]).to eq(0.5)
+      expect(store.calibration_weights['tone_adjustment']).to eq(0.5)
+    end
+
+    it 'expires old receipts without discarding a fresh exchange' do
+      now = Time.utc(2026, 10, 29)
+      allow(Time).to receive(:now).and_return(now)
+      store.record_advisory(advisory_id: 'old', advisory_types: [:tone_adjustment])
+      allow(Time).to receive(:now).and_return(now + 3601)
+      store.record_advisory(advisory_id: 'fresh', advisory_types: [:verbosity_adjustment])
+      expect(store.evaluate_reaction(observation: { advisory_id: 'old', content: 'wrong' })).to be_nil
+      store.evaluate_reaction(observation: { advisory_id: 'fresh', content: 'thanks' })
+      expect(store.calibration_weights['tone_adjustment']).to eq(0.5)
+      expect(store.calibration_weights['verbosity_adjustment']).to be > 0.5
     end
   end
 
@@ -135,6 +267,14 @@ RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Helpers::Calibr
       parsed = Legion::JSON.parse(weights_entry[:content])
       expect(parsed[:baselines][:avg_latency]).to be_between(2.0, 4.0)
     end
+
+    it 'does not turn missing measurements into a zero baseline' do
+      store.update_baseline(latency: 10, length: 100)
+      store.update_baseline(latency: nil, length: nil)
+      store.record_advisory(advisory_id: 'baseline', advisory_types: [:tone_adjustment])
+      result = store.evaluate_reaction(observation: { latency: 7.5, content_length: 48 })
+      expect(result[:reaction_score]).to eq(0.6)
+    end
   end
 
   describe '#to_apollo_entries' do

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

@@ -22,6 +22,74 @@ 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
+
+    it 'keeps two humans baselines, pending exchanges and weights independent' do
+      client.update_calibration(observation: { identity: 'alice', latency: 10 })
+      client.update_calibration(observation: { identity: 'bob', latency: 1 })
+      client.record_advisory_meta(advisory_id: 'alice-reply', advisory_types: [:tone_adjustment],
+                                  applied: { identity: 'alice', exchange_id: 'a' })
+      client.record_advisory_meta(advisory_id: 'bob-reply', advisory_types: [:verbosity_adjustment],
+                                  applied: { identity: 'bob', exchange_id: 'b' })
+
+      wrong_human = client.update_calibration(observation: { identity: 'bob', exchange_id: 'a', content: 'wrong' })
+      expect(wrong_human[:skipped]).to eq(:no_advisory)
+      bob = client.update_calibration(observation: { identity: 'bob', exchange_id: 'b', content: 'wrong' })
+      alice = client.update_calibration(observation: { identity: 'alice', exchange_id: 'a', latency: 7.9 })
+
+      expect(bob[:weights]['verbosity_adjustment']).to be < 0.5
+      expect(bob[:weights]['tone_adjustment']).to eq(0.5)
+      expect(alice[:reaction_score]).to eq(0.6)
+      expect(alice[:weights]['tone_adjustment']).to be > 0.5
+      expect(alice[:weights]['verbosity_adjustment']).to eq(0.5)
+      expect(client.calibration_weights[:weights].values).to all(eq(0.5))
+    end
+
+    it 'does not consume scoped feedback using missing or contradictory identity' do
+      client.record_advisory_meta(advisory_id: 'alice', advisory_types: [:tone_adjustment],
+                                  applied: { identity: 'alice', exchange_id: 'a' })
+      expect(client.update_calibration(observation: { exchange_id: 'a', content: 'wrong' })[:skipped]).to eq(:no_advisory)
+      result = client.update_calibration(identity: 'alice', observation: { identity: 'bob', exchange_id: 'a', content: 'wrong' })
+      expect(result[:skipped]).to eq(:identity_mismatch)
+      expect(client.calibration_weights(identity: 'alice')[:weights]['tone_adjustment']).to eq(0.5)
+      result = client.update_calibration(observation: { identity: 'alice', exchange_id: 'a', content: 'thanks' })
+      expect(result[:weights]['tone_adjustment']).to be > 0.5
+    end
+
+    it 'uses an injected registry as the state owner across client instances' do
+      registry = Legion::Extensions::Agentic::Social::Calibration::Helpers::CalibrationRegistry.new
+      writer = Legion::Extensions::Agentic::Social::Calibration::Client.new(calibration_registry: registry)
+      reader = Legion::Extensions::Agentic::Social::Calibration::Client.new(calibration_registry: registry)
+      writer.record_advisory_meta(advisory_id: 'shared', identity: 'alice', advisory_types: [:tone_adjustment])
+      reader.update_calibration(observation: { identity: 'alice', content: 'wrong' })
+
+      expect(writer.calibration_weights(identity: 'alice')[:weights]['tone_adjustment']).to be < 0.5
+      expect(reader.calibration_stats(identity: 'alice')[:history_counts]['tone_adjustment']).to eq(1)
+      expect(client.calibration_weights(identity: 'alice')[:weights]['tone_adjustment']).to eq(0.5)
+    end
+
+    it 'keeps a bare runner on the same scoped contract as clients' do
+      runner = Object.new.extend(described_class)
+      runner.record_advisory_meta(advisory_id: 'bare', identity: 'alice', advisory_types: [:tone_adjustment])
+      runner.update_calibration(observation: { identity: 'bob', content: 'wrong' })
+      runner.update_calibration(observation: { identity: 'alice', content: 'thanks' })
+
+      expect(runner.calibration_weights(identity: 'alice')[:weights]['tone_adjustment']).to be > 0.5
+      expect(runner.calibration_weights(identity: 'bob')[:weights]['tone_adjustment']).to eq(0.5)
+    end
   end
 
   describe '#record_advisory_meta' do
@@ -29,6 +97,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/consent/runners/consent_spec.rb

@@ -136,6 +136,46 @@ RSpec.describe Legion::Extensions::Agentic::Social::Consent::Runners::Consent do
       expect(result[:approved]).to be false
       expect(result[:error]).to eq('no_pending_approval')
     end
+
+    it 'rejects expired approval without relying on a scheduled expiry sweep' do
+      now = Time.utc(2026, 10, 29)
+      allow(Time).to receive(:now).and_return(now)
+      client.request_autonomous_approval(domain: 'email')
+      timeout = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap::APPROVAL_TIMEOUT
+      allow(Time).to receive(:now).and_return(now + timeout + 1)
+
+      expect(client.approve_promotion(domain: 'email', approved_by: 'admin')[:approved]).to be false
+      expect(client.check_consent(domain: 'email')[:allowed]).to be false
+      expect(client.request_autonomous_approval(domain: 'email')[:requested]).to be true
+    end
+
+    it 'does not let an old approval undo a subsequent demotion in another domain' do
+      client.request_autonomous_approval(domain: 'email')
+      client.request_autonomous_approval(domain: 'calendar')
+      client.apply_tier_change(domain: 'email', new_tier: :human_only)
+
+      expect(client.approve_promotion(domain: 'email', approved_by: 'admin')[:approved]).to be false
+      expect(client.check_consent(domain: 'email')[:human_only]).to be true
+      expect(client.approve_promotion(domain: 'calendar', approved_by: 'admin')[:approved]).to be true
+      expect(client.check_consent(domain: 'email')[:allowed]).to be false
+    end
+
+    it 'does not grant consent from positive calibration or trust feedback' do
+      calibration = Legion::Extensions::Agentic::Social::Calibration::Client.new
+      trust = Legion::Extensions::Agentic::Social::Trust::Client.new
+      client.apply_tier_change(domain: 'email', new_tier: :human_only)
+      client.request_autonomous_approval(domain: 'calendar')
+      20.times do |index|
+        calibration.record_advisory_meta(advisory_id: index, identity: 'alice', advisory_types: [:tone_adjustment])
+        calibration.update_calibration(observation: { identity: 'alice', content: 'thanks' })
+        trust.record_trust_interaction(agent_id: 'alice', positive: true)
+      end
+
+      expect(client.check_consent(domain: 'email')[:human_only]).to be true
+      expect(client.check_consent(domain: 'calendar')[:allowed]).to be false
+      expect(client.approve_promotion(domain: 'calendar', approved_by: 'admin')[:approved]).to be true
+      expect(client.check_consent(domain: 'email')[:allowed]).to be false
+    end
   end
 
   describe '#reject_promotion' do

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

@@ -324,6 +324,23 @@ RSpec.describe Legion::Extensions::Agentic::Social::Trust::Helpers::TrustMap do
       map.get_or_create(agent_id, partner_identity: partner_y)
       expect(map.count).to eq(2)
     end
+
+    it 'preserves scoped trust across serialization without overwriting legacy or another partner' do
+      map.record_interaction(agent_id, positive: true, partner_identity: partner_x)
+      map.record_interaction(agent_id, positive: false, partner_identity: partner_y)
+      map.record_interaction(agent_id, positive: true)
+      restored = described_class.new
+      persisted = double('apollo', query: { success: true, results: map.to_apollo_entries })
+      expect(restored.from_apollo(store: persisted)).to be true
+
+      expect(restored.get(agent_id, partner_identity: partner_x)[:positive_count]).to eq(1)
+      expect(restored.get(agent_id, partner_identity: partner_y)[:negative_count]).to eq(1)
+      expect(restored.get(agent_id)[:positive_count]).to eq(1)
+      restored.erase_partner!(identity: partner_x)
+      expect(restored.get(agent_id, partner_identity: partner_x)).to be_nil
+      expect(restored.get(agent_id, partner_identity: partner_y)[:negative_count]).to eq(1)
+      expect(restored.get(agent_id)[:positive_count]).to eq(1)
+    end
   end
 
   describe '#erase_partner!(identity:)' do

data/spec/legion/extensions/agentic/social/trust/runners/trust_spec.rb

@@ -44,6 +44,22 @@ RSpec.describe Legion::Extensions::Agentic::Social::Trust::Runners::Trust do
 
       expect(code_trust[:trust][:composite]).to be > ops_trust[:trust][:composite]
     end
+
+    it 'isolates partner trust through recording, reinforcement and delegation queries' do
+      20.times do
+        client.record_trust_interaction(agent_id: 'worker', positive: true, partner_identity: 'alice')
+      end
+      client.record_trust_interaction(agent_id: 'worker', positive: false, partner_identity: 'bob')
+      alice_before = client.get_trust(agent_id: 'worker', partner_identity: 'alice')[:trust][:composite]
+      client.reinforce_trust_dimension(agent_id: 'worker', dimension: :competence, amount: 0.1, partner_identity: 'bob')
+
+      expect(client.get_trust(agent_id: 'worker', partner_identity: 'alice')[:trust][:composite]).to eq(alice_before)
+      expect(client.get_trust(agent_id: 'worker', partner_identity: 'bob')[:trust][:interaction_count]).to eq(1)
+      expect(client.get_trust(agent_id: 'worker')[:found]).to be false
+      expect(client.delegatable_agents(partner_identity: 'alice')[:agents].map { |entry| entry[:agent_id] }).to eq(['worker'])
+      expect(client.trusted_agents(partner_identity: 'bob')[:agents]).to be_empty
+      expect(client.trusted_agents[:agents]).to be_empty
+    end
   end
 
   describe '#reinforce_trust_dimension' do

metadata

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