lex-agentic-social 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b5652d5875cf5aae7e51adf8b8b09f0e664a719144a7575ac9eb2f4bd7b7b56
-  data.tar.gz: 62101c073d3970708e278b2e7afd1dbbe3efc582eb03246bf19f975ad1999bd4
+  metadata.gz: 56e3b653aee6a0da01599ef4ed7dfcb409c637f3b730ce7231b532db528e2e8b
+  data.tar.gz: 7669f59e7277f6418734d2f9ab55057151876896894f0aacc56a93fa923ffa3e
 SHA512:
-  metadata.gz: 5e210bfd1a546461a34290e84e49a893cbb792c1d304b2087c759d2345a0cc30ac37c3f15760024ab19fdf83106f7cdefb87fa83c025100fd36852931f60c82f
-  data.tar.gz: 7a49e748bfc08d1c918c494f16d8ec4f579e63b3ec97120b532d168ffc9865e1748c9113025c0dfe7c9505c0f1aa3830624299e16926bc1b60be52187a71b0a5
+  metadata.gz: 5832f51b26be00617b30a934b8e62759b8ee0f3837afdb6a42af04bdd505d65280e8ca2877513c0f5ebea9f39f14d3cc0e7d748a772c0bc21a166e88c62a0065
+  data.tar.gz: e117c35dda203a26a34aa3a879878c42e32c9cd4b9d53e64227a8bc8d02ca884696eba6262e7fab4ead62a066db752147ece0ca8f3423ca8a7bef01ad172be9c

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.1.9] - 2026-03-31
+
+### Added
+- Calibration sub-module: CalibrationStore with EMA tracking, explicit feedback detection, partner baseline tracking
+- CalibrationRunner: update_calibration, record_advisory_meta, detect_explicit_feedback, calibration_weights, calibration_stats
+- sync_partner_knowledge: LLM preference extraction (weekly) + partner knowledge promotion to Apollo Global
+- Apollo Local persistence via dirty?/to_apollo_entries/from_apollo pattern
+
 ## [0.1.8] - 2026-03-31
 
 ### Added

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Calibration
+          class Client
+            include Runners::Calibration
+
+            def initialize(**)
+              @calibration_store = Helpers::CalibrationStore.new
+            end
+
+            private
+
+            attr_reader :calibration_store
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Calibration
+          module Helpers
+            class CalibrationStore
+              attr_reader :weights, :history
+
+              def initialize
+                @weights = Constants::ADVISORY_TYPES.to_h do |type|
+                  [type.to_s, Constants::NEUTRAL_SCORE]
+                end
+                @history = {}
+                @last_advisory_meta = nil
+                @partner_baselines = { 'avg_latency' => nil, 'avg_length' => nil }
+                @dirty = false
+              end
+
+              def dirty?
+                @dirty
+              end
+
+              def mark_clean!
+                @dirty = false
+                self
+              end
+
+              def record_advisory(advisory_id:, advisory_types:)
+                @last_advisory_meta = {
+                  advisory_id:    advisory_id,
+                  advisory_types: Array(advisory_types).map(&:to_s),
+                  timestamp:      Time.now.utc
+                }
+              end
+
+              def evaluate_reaction(observation:)
+                return nil unless @last_advisory_meta
+                return nil if @last_advisory_meta[:advisory_types].empty?
+
+                elapsed = Time.now.utc - @last_advisory_meta[:timestamp]
+                return nil if elapsed > 3600
+
+                reaction_score = compute_reaction_score(observation)
+                confidence = compute_confidence(observation)
+
+                deltas = @last_advisory_meta[:advisory_types].map do |type|
+                  apply_delta(type: type, reaction_score: reaction_score, confidence: confidence)
+                end
+
+                @last_advisory_meta = nil
+                @dirty = true
+                { success: true, deltas: deltas }
+              end
+
+              def calibration_weights
+                @weights.dup
+              end
+
+              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)
+
+                :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
+              end
+
+              def to_apollo_entries
+                entries = []
+
+                content = Legion::JSON.dump({
+                                              'weights'    => @weights,
+                                              'baselines'  => @partner_baselines,
+                                              'updated_at' => Time.now.utc.iso8601
+                                            })
+                entries << { content: content, tags: Constants::WEIGHTS_TAGS.dup + ['partner'] }
+
+                @history.each do |type, events|
+                  hist_content = Legion::JSON.dump({
+                                                     'advisory_type'  => type,
+                                                     'events'         => events.last(Constants::MAX_HISTORY),
+                                                     'current_weight' => @weights[type]
+                                                   })
+                  entries << { content: hist_content, tags: Constants::HISTORY_TAG_PREFIX + [type] }
+                end
+
+                entries
+              end
+
+              def from_apollo(store:)
+                result = store.query(text: 'bond calibration weights', tags: Constants::WEIGHTS_TAGS)
+                return false unless result[:success] && result[:results]&.any?
+
+                entry = result[:results].first
+                parsed = ::JSON.parse(entry[:content])
+                @weights.merge!(parsed['weights']) if parsed['weights']
+                @partner_baselines = parsed['baselines'] if parsed['baselines']
+                true
+              rescue StandardError => e
+                Legion::Logging.warn("[calibration_store] from_apollo error: #{e.message}")
+                false
+              end
+
+              private
+
+              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
+
+                if @partner_baselines['avg_latency'] && 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
+                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
+                end
+
+                score += Constants::SIGNAL_WEIGHTS[:direct_address] if observation[:direct_address]
+
+                ((score + 1.0) / 2.0).clamp(0.0, 1.0)
+              end
+
+              def compute_confidence(observation)
+                signals = 0
+                signals += 1 if observation[:content].to_s.length.positive?
+                signals += 1 if observation[:latency]
+                signals += 1 if observation[:content_length]
+                signals += 1 if observation.key?(:direct_address)
+                (signals / 4.0).clamp(0.2, 1.0)
+              end
+
+              def apply_delta(type:, reaction_score:, confidence:)
+                delta = (reaction_score - Constants::NEUTRAL_SCORE) * confidence * Constants::EMA_ALPHA
+                old_weight = @weights[type] || Constants::NEUTRAL_SCORE
+                new_weight = (old_weight + delta).clamp(0.0, 1.0)
+                @weights[type] = new_weight
+
+                event = {
+                  'reaction_score' => reaction_score.round(3),
+                  'confidence'     => confidence.round(3),
+                  'delta'          => delta.round(4),
+                  'old_weight'     => old_weight.round(3),
+                  'new_weight'     => new_weight.round(3),
+                  'timestamp'      => Time.now.utc.iso8601
+                }
+
+                @history[type] ||= []
+                @history[type] << event
+                @history[type] = @history[type].last(Constants::MAX_HISTORY)
+
+                {
+                  advisory_type:  type,
+                  reaction_score: reaction_score.round(3),
+                  confidence:     confidence.round(3),
+                  delta:          delta.round(4),
+                  new_weight:     new_weight.round(3)
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Calibration
+          module Helpers
+            module Constants
+              ADVISORY_TYPES = %i[
+                tone_adjustment
+                verbosity_adjustment
+                format_adjustment
+                context_injection
+                partner_hint
+              ].freeze
+
+              EMA_ALPHA = 0.1
+              NEUTRAL_SCORE = 0.5
+              SUPPRESSION_THRESHOLD = 0.4
+              HIGH_CALIBRATION = 0.7
+              MAX_HISTORY = 50
+
+              TAG_PREFIX = %w[bond calibration].freeze
+              WEIGHTS_TAGS = (TAG_PREFIX + ['weights']).freeze
+              HISTORY_TAG_PREFIX = (TAG_PREFIX + ['history']).freeze
+
+              POSITIVE_PATTERNS = /\b(thanks|perfect|exactly|great|good|helpful|nice|yes)\b/i
+              NEGATIVE_PATTERNS = /\b(no|wrong|not what|stop|don't|didn't ask|incorrect)\b/i
+
+              SIGNAL_WEIGHTS = {
+                explicit_feedback: 0.35,
+                response_latency:  0.20,
+                message_length:    0.15,
+                direct_address:    0.15,
+                continuation:      0.15
+              }.freeze
+
+              PROMOTABLE_TAGS = [
+                %w[bond attachment],
+                %w[bond communication_pattern],
+                %w[bond calibration weights],
+                %w[partner preference]
+              ].freeze
+
+              PROMOTION_MIN_CONFIDENCE = 0.6
+              PREFERENCE_EXTRACTION_INTERVAL = 604_800 # 7 days
+
+              module_function
+
+              def advisory_type?(type)
+                ADVISORY_TYPES.include?(type.to_sym)
+              end
+
+              def suppressed?(score)
+                score < SUPPRESSION_THRESHOLD
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Calibration
+          module Runners
+            module Calibration
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
+
+              def update_calibration(observation: nil, **)
+                return { success: true, skipped: :no_observation } unless observation
+
+                calibration_store.update_baseline(
+                  latency: observation[:latency] || 0,
+                  length:  observation[:content_length] || 0
+                )
+
+                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 }
+              end
+
+              def record_advisory_meta(advisory_id:, advisory_types:, **)
+                calibration_store.record_advisory(advisory_id: advisory_id, advisory_types: advisory_types)
+                { success: true }
+              end
+
+              def detect_explicit_feedback(content:, **)
+                feedback = calibration_store.detect_explicit_feedback(content)
+                { success: true, feedback: feedback }
+              end
+
+              def calibration_weights(**)
+                { success: true, weights: calibration_store.calibration_weights }
+              end
+
+              def calibration_stats(**)
+                {
+                  success:        true,
+                  weights:        calibration_store.calibration_weights,
+                  history_counts: calibration_store.history.transform_values(&:size),
+                  dirty:          calibration_store.dirty?
+                }
+              end
+
+              def sync_partner_knowledge(**)
+                results = {}
+                results[:preferences] = extract_preferences_via_llm
+                results[:promotion] = promote_partner_knowledge
+                { success: true, results: results }
+              rescue StandardError => e
+                { success: false, error: e.message }
+              end
+
+              def extract_preferences_via_llm(**)
+                return { success: true, skipped: :too_soon } unless should_extract_preferences?
+                return { success: true, skipped: :llm_unavailable } unless llm_available?
+
+                traces = retrieve_interaction_traces
+                return { success: true, skipped: :insufficient_data } if traces.empty?
+
+                context = summarize_traces(traces)
+                prompt = build_preference_prompt(context)
+                result = Legion::LLM.ask(message: prompt)
+                return { success: false, error: :llm_failed } unless result&.content
+
+                parsed = parse_preference_response(result.content)
+                return { success: false, error: :parse_failed } unless parsed
+
+                store_llm_preferences(parsed)
+                @last_preference_extraction_at = Time.now.utc
+                { success: true, preferences_extracted: parsed.size }
+              rescue StandardError => e
+                { success: false, error: e.message }
+              end
+
+              def promote_partner_knowledge(**)
+                return { success: true, skipped: :local_unavailable } unless apollo_local_available?
+
+                total = 0
+                Helpers::Constants::PROMOTABLE_TAGS.each do |tags|
+                  result = Legion::Apollo::Local.promote_to_global(tags: tags, min_confidence: Helpers::Constants::PROMOTION_MIN_CONFIDENCE)
+                  total += result[:promoted] if result[:success]
+                end
+
+                { success: true, promoted: total }
+              rescue StandardError => e
+                { success: false, error: e.message }
+              end
+
+              private
+
+              def calibration_store
+                @calibration_store ||= Helpers::CalibrationStore.new
+              end
+
+              def should_extract_preferences?
+                return true if @last_preference_extraction_at.nil?
+
+                (Time.now.utc - @last_preference_extraction_at) > Helpers::Constants::PREFERENCE_EXTRACTION_INTERVAL
+              end
+
+              def llm_available?
+                defined?(Legion::LLM) && Legion::LLM.started?
+              end
+
+              def apollo_local_available?
+                defined?(Legion::Apollo::Local) && Legion::Apollo::Local.started?
+              end
+
+              def retrieve_interaction_traces
+                return [] unless defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+
+                runner = Object.new
+                runner.extend(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+                result = runner.retrieve_by_domain(domain_tag: 'partner_interaction', limit: 50)
+                return [] unless result[:success]
+
+                result[:traces] || []
+              rescue StandardError => e
+                Legion::Logging.warn("[calibration] retrieve_interaction_traces error: #{e.message}")
+                []
+              end
+
+              def summarize_traces(traces)
+                traces.first(50).map do |t|
+                  payload = t[:content_payload] || t[:content] || ''
+                  "[#{t[:recorded_at] || t[:created_at]}] #{payload}"
+                end.join("\n")
+              end
+
+              def build_preference_prompt(context)
+                <<~PROMPT
+                  Based on these interaction patterns with my partner, what communication preferences can I infer? Consider:
+                  - Preferred verbosity (concise/normal/detailed)
+                  - Preferred tone (casual/professional/technical)
+                  - Preferred format (prose/structured/bullet_points)
+                  - Technical depth (high_level/moderate/deep)
+
+                  Interaction summary:
+                  #{context}
+
+                  Return ONLY a JSON array of objects, each with: domain (string), value (string), confidence (float 0-1).
+                PROMPT
+              end
+
+              def parse_preference_response(content)
+                json_match = content.match(/\[.*\]/m)
+                return nil unless json_match
+
+                Legion::JSON.parse(json_match[0])
+              rescue StandardError => e
+                Legion::Logging.warn("[calibration] parse_preference_response error: #{e.message}")
+                nil
+              end
+
+              def store_llm_preferences(preferences)
+                return unless apollo_local_available?
+
+                base_tags = %w[partner preference llm_inference]
+                preferences.each do |pref|
+                  content = Legion::JSON.dump({
+                                                'domain'     => pref['domain'],
+                                                'value'      => pref['value'],
+                                                'source'     => 'llm_inference',
+                                                'confidence' => pref['confidence'] || 0.65
+                                              })
+                  tags = base_tags + ["preference:#{pref['domain']}"]
+                  Legion::Apollo::Local.upsert(content: content, tags: tags, confidence: pref['confidence'] || 0.65)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'calibration/helpers/constants'
+require_relative 'calibration/helpers/calibration_store'
+require_relative 'calibration/runners/calibration'
+require_relative 'calibration/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Calibration
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Social
-        VERSION = '0.1.8'
+        VERSION = '0.1.9'
       end
     end
   end

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

@@ -19,6 +19,7 @@ require_relative 'social/governance'
 require_relative 'social/joint_attention'
 require_relative 'social/mirror_system'
 require_relative 'social/attachment'
+require_relative 'social/calibration'
 
 module Legion
   module Extensions

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Helpers::CalibrationStore do
+  subject(:store) { described_class.new }
+
+  let(:constants) { Legion::Extensions::Agentic::Social::Calibration::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'starts with neutral weights for all advisory types' do
+      expect(store.weights.size).to eq(5)
+      store.weights.each_value { |v| expect(v).to eq(0.5) }
+    end
+
+    it 'starts clean' do
+      expect(store).not_to be_dirty
+    end
+
+    it 'starts with empty history' do
+      expect(store.history).to be_empty
+    end
+  end
+
+  describe '#dirty? and #mark_clean!' do
+    it 'becomes dirty after evaluation' do
+      store.record_advisory(advisory_id: 'test', advisory_types: [:tone_adjustment])
+      store.evaluate_reaction(observation: { content: 'thanks', direct_address: true, content_length: 50 })
+      expect(store).to be_dirty
+    end
+
+    it 'returns self from mark_clean!' do
+      expect(store.mark_clean!).to eq(store)
+    end
+
+    it 'is clean after mark_clean!' do
+      store.record_advisory(advisory_id: 'test', advisory_types: [:tone_adjustment])
+      store.evaluate_reaction(observation: { content: 'thanks' })
+      store.mark_clean!
+      expect(store).not_to be_dirty
+    end
+  end
+
+  describe '#record_advisory' do
+    it 'stores advisory metadata for next evaluation' do
+      store.record_advisory(advisory_id: 'abc', advisory_types: %i[tone_adjustment verbosity_adjustment])
+      result = store.evaluate_reaction(observation: { content: 'thanks' })
+      expect(result).not_to be_nil
+      expect(result[:deltas].size).to eq(2)
+    end
+  end
+
+  describe '#evaluate_reaction' do
+    it 'returns nil when no advisory recorded' do
+      expect(store.evaluate_reaction(observation: { content: 'hello' })).to be_nil
+    end
+
+    it 'returns nil when advisory types are empty' do
+      store.record_advisory(advisory_id: 'test', advisory_types: [])
+      expect(store.evaluate_reaction(observation: { content: 'hello' })).to be_nil
+    end
+
+    context 'with recorded advisory' do
+      before { store.record_advisory(advisory_id: 'test', advisory_types: [:tone_adjustment]) }
+
+      it 'produces deltas for positive feedback' do
+        result = store.evaluate_reaction(observation: { content: 'thanks, perfect!', direct_address: true, content_length: 20 })
+        expect(result[:success]).to be true
+        expect(result[:deltas].first[:advisory_type]).to eq('tone_adjustment')
+        expect(result[:deltas].first[:new_weight]).to be > 0.5
+      end
+
+      it 'produces deltas for negative feedback' do
+        result = store.evaluate_reaction(observation: { content: 'no, wrong', content_length: 5 })
+        expect(result[:success]).to be true
+        expect(result[:deltas].first[:new_weight]).to be < 0.5
+      end
+
+      it 'clears advisory meta after evaluation' do
+        store.evaluate_reaction(observation: { content: 'ok' })
+        expect(store.evaluate_reaction(observation: { content: 'hello' })).to be_nil
+      end
+
+      it 'marks store as dirty' do
+        store.evaluate_reaction(observation: { content: 'thanks' })
+        expect(store).to be_dirty
+      end
+
+      it 'records history entry' do
+        store.evaluate_reaction(observation: { content: 'thanks' })
+        expect(store.history['tone_adjustment']).not_to be_empty
+      end
+    end
+  end
+
+  describe '#detect_explicit_feedback' do
+    it 'detects positive' do
+      expect(store.detect_explicit_feedback('thanks for that')).to eq(:positive)
+      expect(store.detect_explicit_feedback('exactly what I needed')).to eq(:positive)
+    end
+
+    it 'detects negative' do
+      expect(store.detect_explicit_feedback('no that is wrong')).to eq(:negative)
+      expect(store.detect_explicit_feedback("didn't ask for that")).to eq(:negative)
+    end
+
+    it 'returns neutral for ambiguous' do
+      expect(store.detect_explicit_feedback('I see')).to eq(:neutral)
+      expect(store.detect_explicit_feedback('interesting')).to eq(:neutral)
+    end
+  end
+
+  describe '#calibration_weights' do
+    it 'returns a copy' do
+      weights = store.calibration_weights
+      weights['tone_adjustment'] = 999
+      expect(store.calibration_weights['tone_adjustment']).to eq(0.5)
+    end
+  end
+
+  describe '#update_baseline' do
+    it 'initializes baselines on first call' do
+      store.update_baseline(latency: 2.0, length: 100)
+      entries = store.to_apollo_entries
+      weights_entry = entries.find { |e| e[:tags].include?('weights') }
+      parsed = Legion::JSON.parse(weights_entry[:content])
+      expect(parsed[:baselines][:avg_latency]).to eq(2.0)
+    end
+
+    it 'applies EMA on subsequent calls' do
+      store.update_baseline(latency: 2.0, length: 100)
+      store.update_baseline(latency: 4.0, length: 200)
+      entries = store.to_apollo_entries
+      weights_entry = entries.find { |e| e[:tags].include?('weights') }
+      parsed = Legion::JSON.parse(weights_entry[:content])
+      expect(parsed[:baselines][:avg_latency]).to be_between(2.0, 4.0)
+    end
+  end
+
+  describe '#to_apollo_entries' do
+    it 'produces a weights entry with partner tag' do
+      entries = store.to_apollo_entries
+      weights_entry = entries.find { |e| e[:tags].include?('weights') }
+      expect(weights_entry).not_to be_nil
+      expect(weights_entry[:tags]).to include('bond', 'calibration', 'weights', 'partner')
+    end
+
+    it 'produces history entries after evaluation' do
+      store.record_advisory(advisory_id: 'test', advisory_types: [:tone_adjustment])
+      store.evaluate_reaction(observation: { content: 'thanks' })
+      entries = store.to_apollo_entries
+      history_entries = entries.select { |e| e[:tags].include?('history') }
+      expect(history_entries).not_to be_empty
+    end
+  end
+
+  describe '#from_apollo' do
+    let(:mock_store) { double('store') }
+
+    it 'restores weights from Apollo Local' do
+      content = Legion::JSON.dump({ 'weights' => { 'tone_adjustment' => 0.8 }, 'baselines' => {}, 'updated_at' => Time.now.utc.iso8601 })
+      allow(mock_store).to receive(:query).and_return({ success: true, results: [{ content: content, confidence: 0.9 }] })
+      expect(store.from_apollo(store: mock_store)).to be true
+      expect(store.weights['tone_adjustment']).to eq(0.8)
+    end
+
+    it 'returns false when no data' do
+      allow(mock_store).to receive(:query).and_return({ success: true, results: [] })
+      expect(store.from_apollo(store: mock_store)).to be false
+    end
+
+    it 'returns false on error' do
+      allow(mock_store).to receive(:query).and_raise(StandardError, 'boom')
+      expect(store.from_apollo(store: mock_store)).to be false
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Helpers::Constants do
+  describe 'ADVISORY_TYPES' do
+    it 'defines five advisory types' do
+      expect(described_class::ADVISORY_TYPES.size).to eq(5)
+    end
+
+    it 'contains expected types' do
+      expect(described_class::ADVISORY_TYPES).to include(:tone_adjustment, :verbosity_adjustment)
+    end
+  end
+
+  describe '.advisory_type?' do
+    it 'returns true for valid types' do
+      expect(described_class.advisory_type?(:tone_adjustment)).to be true
+    end
+
+    it 'returns false for invalid types' do
+      expect(described_class.advisory_type?(:bogus)).to be false
+    end
+
+    it 'accepts string conversion' do
+      expect(described_class.advisory_type?('partner_hint')).to be true
+    end
+  end
+
+  describe '.suppressed?' do
+    it 'returns true below threshold' do
+      expect(described_class.suppressed?(0.3)).to be true
+    end
+
+    it 'returns false at or above threshold' do
+      expect(described_class.suppressed?(0.4)).to be false
+      expect(described_class.suppressed?(0.7)).to be false
+    end
+  end
+
+  describe 'SIGNAL_WEIGHTS' do
+    it 'sums to 1.0' do
+      expect(described_class::SIGNAL_WEIGHTS.values.sum).to be_within(0.001).of(1.0)
+    end
+  end
+
+  describe 'TAG constants' do
+    it 'has correct weights tags' do
+      expect(described_class::WEIGHTS_TAGS).to eq(%w[bond calibration weights])
+    end
+
+    it 'has correct history tag prefix' do
+      expect(described_class::HISTORY_TAG_PREFIX).to eq(%w[bond calibration history])
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Runners::Calibration do
+  let(:client) { Legion::Extensions::Agentic::Social::Calibration::Client.new }
+
+  describe '#update_calibration' do
+    it 'skips when no observation' do
+      result = client.update_calibration
+      expect(result[:skipped]).to eq(:no_observation)
+    end
+
+    it 'skips when no advisory recorded' do
+      result = client.update_calibration(observation: { content: 'hi', content_length: 2 })
+      expect(result[:skipped]).to eq(:no_advisory)
+    end
+
+    it 'produces deltas 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[:success]).to be true
+      expect(result[:deltas]).not_to be_empty
+    end
+  end
+
+  describe '#record_advisory_meta' do
+    it 'succeeds' do
+      result = client.record_advisory_meta(advisory_id: 'abc', advisory_types: [:partner_hint])
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#detect_explicit_feedback' do
+    it 'returns positive for thanks' do
+      result = client.detect_explicit_feedback(content: 'thanks!')
+      expect(result[:feedback]).to eq(:positive)
+    end
+
+    it 'returns negative for wrong' do
+      result = client.detect_explicit_feedback(content: 'wrong answer')
+      expect(result[:feedback]).to eq(:negative)
+    end
+
+    it 'returns neutral for ambiguous' do
+      result = client.detect_explicit_feedback(content: 'okay')
+      expect(result[:feedback]).to eq(:neutral)
+    end
+  end
+
+  describe '#calibration_weights' do
+    it 'returns all advisory types' do
+      result = client.calibration_weights
+      expect(result[:weights].keys.size).to eq(5)
+    end
+  end
+
+  describe '#calibration_stats' do
+    it 'returns stats hash' do
+      result = client.calibration_stats
+      expect(result[:success]).to be true
+      expect(result).to have_key(:weights)
+      expect(result).to have_key(:history_counts)
+      expect(result).to have_key(:dirty)
+    end
+  end
+
+  describe '#extract_preferences_via_llm' do
+    it 'skips when LLM unavailable' do
+      result = client.extract_preferences_via_llm
+      expect(result[:skipped]).to eq(:llm_unavailable)
+    end
+  end
+
+  describe '#promote_partner_knowledge' do
+    it 'skips when Apollo Local unavailable' do
+      result = client.promote_partner_knowledge
+      expect(result[:skipped]).to eq(:local_unavailable)
+    end
+  end
+
+  describe '#sync_partner_knowledge' do
+    it 'returns combined results' do
+      result = client.sync_partner_knowledge
+      expect(result[:success]).to be true
+      expect(result[:results]).to have_key(:preferences)
+      expect(result[:results]).to have_key(:promotion)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-social
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Esity
@@ -190,6 +190,11 @@ files:
 - lib/legion/extensions/agentic/social/attachment/helpers/constants.rb
 - lib/legion/extensions/agentic/social/attachment/runners/attachment.rb
 - 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_store.rb
+- lib/legion/extensions/agentic/social/calibration/helpers/constants.rb
+- lib/legion/extensions/agentic/social/calibration/runners/calibration.rb
 - lib/legion/extensions/agentic/social/conflict.rb
 - lib/legion/extensions/agentic/social/conflict/actors/stale_check.rb
 - lib/legion/extensions/agentic/social/conflict/client.rb
@@ -328,6 +333,9 @@ 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_store_spec.rb
+- spec/legion/extensions/agentic/social/calibration/helpers/constants_spec.rb
+- spec/legion/extensions/agentic/social/calibration/runners/calibration_spec.rb
 - spec/legion/extensions/agentic/social/conflict/actors/stale_check_spec.rb
 - spec/legion/extensions/agentic/social/conflict/client_spec.rb
 - spec/legion/extensions/agentic/social/conflict/helpers/conflict_log_spec.rb