lex-agentic-social 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56e3b653aee6a0da01599ef4ed7dfcb409c637f3b730ce7231b532db528e2e8b
-  data.tar.gz: 7669f59e7277f6418734d2f9ab55057151876896894f0aacc56a93fa923ffa3e
+  metadata.gz: 0fc83af9a2de72c88452553af56512be4b8fd0ae78460677ede2acb8741b4717
+  data.tar.gz: c73bca2d3963eb2d3b565e5086e471e34a822bc5b51e4ea6e7beb40cf8a065f3
 SHA512:
-  metadata.gz: 5832f51b26be00617b30a934b8e62759b8ee0f3837afdb6a42af04bdd505d65280e8ca2877513c0f5ebea9f39f14d3cc0e7d748a772c0bc21a166e88c62a0065
-  data.tar.gz: e117c35dda203a26a34aa3a879878c42e32c9cd4b9d53e64227a8bc8d02ca884696eba6262e7fab4ead62a066db752147ece0ca8f3423ca8a7bef01ad172be9c
+  metadata.gz: b49a7f8ff8a8c950c03fd88291efa84ccbdf73be77c3581572149fcfa99d4084d041584c63c6044da0fd275803ad75a2ef10cc930ac1c0f0561b624fab73190e
+  data.tar.gz: d37843a8af2d489580cb9f74923a82390e763939f8a81edc1870d28e42476b383e33d88074305df3c371bcf8ed4b8e01fa6f469ca5753b99cc71fcc1e15f1736

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.1.10] - 2026-03-31
+
+### Fixed
+- `extract_style_signals`: replace hardcoded `frequency_variance: 0.0` and `reciprocity_imbalance: 0.0` with real computations (`compute_frequency_variance` from hourly bucket counts, `compute_reciprocity_imbalance` from agent/human direction ratio); `:anxious` attachment style is now reachable
+- `reflect_on_bonds`: `narrative:` field now returns a mechanically generated sentence (stage, style, health, chapter, milestones) instead of always nil
+- `reflect_on_bonds`: add `absence_exceeds_pattern:` field backed by `Legion::Extensions::Agentic::Memory::CommunicationPattern` when available, falling back to Apollo Local communication pattern data
+- `retrieve_interaction_traces` in calibration: split into `retrieve_from_memory` + `retrieve_from_apollo_local` fallback; now returns data from Apollo Local when lex-agentic-memory is absent
+- `check_airb_compliance` in shadow_ai: return `reason:` field alongside `source: :unavailable` so callers know why the check could not run; emit debug log entry
+
 ## [0.1.9] - 2026-03-31
 
 ### Added

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

@@ -39,12 +39,13 @@ module Legion
                   bonds_reflected: attachment_store.all_models.size,
                   partner_bond:    if model
                                      {
-                                       stage:            model.bond_stage,
-                                       strength:         model.attachment_strength,
-                                       style:            model.attachment_style,
-                                       health:           health,
-                                       milestones_today: arc_state[:milestones_today] || [],
-                                       narrative:        nil
+                                       stage:                   model.bond_stage,
+                                       strength:                model.attachment_strength,
+                                       style:                   model.attachment_style,
+                                       health:                  health,
+                                       milestones_today:        arc_state[:milestones_today] || [],
+                                       narrative:               build_narrative(model, health, arc_state),
+                                       absence_exceeds_pattern: absence_exceeds_pattern?(partner_id)
                                      }
                                    end
                 }
@@ -98,13 +99,37 @@ module Legion
                 obs = human_observations.select { |o| o[:agent_id].to_s == agent_id }
                 direct_count = obs.count { |o| o[:direct_address] }
                 {
-                  frequency_variance:    0.0,
-                  reciprocity_imbalance: 0.0,
+                  frequency_variance:    compute_frequency_variance(obs),
+                  reciprocity_imbalance: compute_reciprocity_imbalance(obs),
                   frequency:             obs.size.clamp(0, 10) / 10.0,
                   direct_address_ratio:  obs.empty? ? 0.0 : direct_count.to_f / obs.size
                 }
               end
 
+              def compute_frequency_variance(observations)
+                return 0.0 if observations.size < 3
+
+                timestamps = observations.filter_map { |o| o[:observed_at] || o[:timestamp] }
+                return 0.0 if timestamps.size < 3
+
+                buckets = timestamps.group_by { |t| t.to_i / 3600 }
+                counts  = buckets.values.map { |b| b.size.to_f }
+                mean    = counts.sum / counts.size
+                variance = counts.sum { |c| (c - mean)**2 } / counts.size
+                [variance / [mean, 1.0].max, 1.0].min
+              end
+
+              def compute_reciprocity_imbalance(observations)
+                return 0.0 if observations.empty?
+
+                initiated = observations.count { |o| o[:initiated_by] == :agent || o[:direction] == :outgoing }
+                received  = observations.size - initiated
+                total     = observations.size.to_f
+                return 0.0 if total.zero?
+
+                ((initiated - received).abs / total).clamp(0.0, 1.0)
+              end
+
               def resolve_partner_id
                 if defined?(Legion::Gaia::BondRegistry)
                   bond = Legion::Gaia::BondRegistry.all_bonds.find { |b| b[:role] == :partner }
@@ -154,6 +179,69 @@ module Legion
                 (strength_component + reciprocity_component + consistency_component).clamp(0.0, 1.0)
               end
 
+              def build_narrative(model, health, arc_state)
+                return nil unless model
+
+                stage     = model.bond_stage
+                style     = model.attachment_style
+                chapter   = arc_state[:current_chapter]
+                parts     = ["Bond is #{stage} (#{style} style)"]
+                parts << "health: #{format('%.1f', health)}" if health
+                parts << "chapter: #{chapter}" if chapter
+                milestones = arc_state[:milestones_today]
+                parts << "#{milestones.size} milestone(s) today" if milestones&.any?
+                "#{parts.join(', ')}."
+              end
+
+              def absence_exceeds_pattern?(agent_id)
+                return false unless agent_id
+
+                if defined?(Legion::Extensions::Agentic::Memory::CommunicationPattern::Runners::CommunicationPattern)
+                  begin
+                    runner = Object.new
+                    runner.extend(Legion::Extensions::Agentic::Memory::CommunicationPattern::Runners::CommunicationPattern)
+                    stats = runner.partner_stats(agent_id: agent_id)
+                    return false unless stats.is_a?(Hash)
+
+                    avg_gap = stats[:average_gap_seconds] || stats[:avg_gap]
+                    return false unless avg_gap&.positive?
+
+                    last_interaction = stats[:last_interaction_at]
+                    return false unless last_interaction
+
+                    current_gap = Time.now - Time.parse(last_interaction.to_s)
+                    return current_gap > (avg_gap * 2.0)
+                  rescue StandardError => _e
+                    return false
+                  end
+                end
+
+                absence_exceeds_pattern_from_observations?(agent_id)
+              end
+
+              def absence_exceeds_pattern_from_observations?(agent_id)
+                store = apollo_local_store
+                return false unless store
+
+                result = store.query(text: 'communication_pattern',
+                                     tags: ['bond', 'communication_pattern', agent_id.to_s])
+                return false unless result[:success] && result[:results]&.any?
+
+                data = deserialize(result[:results].first[:content])
+                return false unless data.is_a?(Hash)
+
+                avg_gap = (data[:average_gap_seconds] || data[:avg_gap])&.to_f
+                return false unless avg_gap&.positive?
+
+                last_str = data[:last_interaction_at]
+                return false unless last_str
+
+                current_gap = Time.now - Time.parse(last_str.to_s)
+                current_gap > (avg_gap * 2.0)
+              rescue StandardError => _e
+                false
+              end
+
               def deserialize(content)
                 parsed = defined?(Legion::JSON) ? Legion::JSON.parse(content) : ::JSON.parse(content, symbolize_names: true)
                 parsed.is_a?(Hash) ? parsed.transform_keys(&:to_sym) : {}

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

@@ -113,6 +113,13 @@ module Legion
               end
 
               def retrieve_interaction_traces
+                traces = retrieve_from_memory
+                return traces if traces.any?
+
+                retrieve_from_apollo_local
+              end
+
+              def retrieve_from_memory
                 return [] unless defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
 
                 runner = Object.new
@@ -122,7 +129,17 @@ module Legion
 
                 result[:traces] || []
               rescue StandardError => e
-                Legion::Logging.warn("[calibration] retrieve_interaction_traces error: #{e.message}")
+                Legion::Logging.warn("[calibration] retrieve_from_memory error: #{e.message}")
+                []
+              end
+
+              def retrieve_from_apollo_local
+                return [] unless defined?(Legion::Apollo::Local) && Legion::Apollo::Local.started?
+
+                entries = Legion::Apollo::Local.query_by_tags(tags: ['partner_interaction'], limit: 50)
+                entries.map { |e| { content: e[:content], tags: e[:tags], confidence: e[:confidence] } }
+              rescue StandardError => e
+                Legion::Logging.warn("[calibration] retrieve_from_apollo_local error: #{e.message}")
                 []
               end
 

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

@@ -25,7 +25,10 @@ module Legion
               end
 
               def check_airb_compliance(**)
-                return { checked: 0, source: :unavailable } unless defined?(Legion::Data::Model::DigitalWorker)
+                unless defined?(Legion::Data::Model::DigitalWorker)
+                  Legion::Logging.debug('[governance:shadow_ai] AIRB compliance check unavailable — DigitalWorker model not loaded')
+                  return { checked: 0, source: :unavailable, reason: 'DigitalWorker model not loaded' }
+                end
 
                 workers = Legion::Data::Model::DigitalWorker.where(lifecycle_state: 'active').all
                 non_compliant = workers.select do |w|

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

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

data/spec/legion/extensions/agentic/social/attachment/runners/attachment_spec.rb

@@ -97,8 +97,8 @@ RSpec.describe Legion::Extensions::Agentic::Social::Attachment::Runners::Attachm
 
     it 'reads communication patterns from Apollo Local' do
       host.reflect_on_bonds(tick_results: {}, bond_summary: {})
-      expect(mock_store).to have_received(:query)
-        .with(hash_including(tags: array_including('bond', 'communication_pattern')))
+      expect(mock_store).to have_received(:query).at_least(:once)
+                                                 .with(hash_including(tags: array_including('bond', 'communication_pattern')))
     end
 
     it 'reads relationship arc from Apollo Local' do
@@ -127,4 +127,234 @@ RSpec.describe Legion::Extensions::Agentic::Social::Attachment::Runners::Attachm
       expect(result).to have_key(:partner_bond)
     end
   end
+
+  describe '#compute_frequency_variance' do
+    it 'returns 0.0 for fewer than 3 observations' do
+      obs = [{ timestamp: Time.now }, { timestamp: Time.now }]
+      expect(host.send(:compute_frequency_variance, obs)).to eq(0.0)
+    end
+
+    it 'returns 0.0 when observations have no timestamps' do
+      obs = [{ agent_id: 'x' }, { agent_id: 'x' }, { agent_id: 'x' }]
+      expect(host.send(:compute_frequency_variance, obs)).to eq(0.0)
+    end
+
+    it 'returns a positive value for unevenly distributed timestamps' do
+      base = Time.now
+      # Cluster 6 in one bucket and 1 in another — high variance
+      ts = Array.new(6) { base } + [base + 7200]
+      obs = ts.map { |t| { timestamp: t } }
+      result = host.send(:compute_frequency_variance, obs)
+      expect(result).to be > 0.0
+      expect(result).to be_between(0.0, 1.0)
+    end
+
+    it 'returns low variance for evenly distributed timestamps' do
+      base = Time.now
+      # One per hour — perfectly even
+      ts = (0..4).map { |i| base + (i * 3600) }
+      obs = ts.map { |t| { timestamp: t } }
+      result = host.send(:compute_frequency_variance, obs)
+      expect(result).to eq(0.0)
+    end
+
+    it 'uses :observed_at field when present' do
+      base = Time.now
+      ts = Array.new(5) { base } + [base + 7200]
+      obs = ts.map { |t| { observed_at: t } }
+      result = host.send(:compute_frequency_variance, obs)
+      expect(result).to be > 0.0
+    end
+  end
+
+  describe '#compute_reciprocity_imbalance' do
+    it 'returns 0.0 for empty observations' do
+      expect(host.send(:compute_reciprocity_imbalance, [])).to eq(0.0)
+    end
+
+    it 'returns 0.0 for balanced initiated/received' do
+      obs = [
+        { direction: :outgoing },
+        { direction: :incoming }
+      ]
+      expect(host.send(:compute_reciprocity_imbalance, obs)).to eq(0.0)
+    end
+
+    it 'returns 1.0 when all interactions are agent-initiated' do
+      obs = Array.new(4) { { initiated_by: :agent } }
+      expect(host.send(:compute_reciprocity_imbalance, obs)).to eq(1.0)
+    end
+
+    it 'returns 1.0 when all interactions are received' do
+      obs = Array.new(4) { { direction: :incoming } }
+      expect(host.send(:compute_reciprocity_imbalance, obs)).to eq(1.0)
+    end
+
+    it 'computes partial imbalance correctly' do
+      # 3 outgoing, 1 incoming => |3-1|/4 = 0.5
+      obs = Array.new(3) { { direction: :outgoing } } + [{ direction: :incoming }]
+      expect(host.send(:compute_reciprocity_imbalance, obs)).to be_within(0.001).of(0.5)
+    end
+  end
+
+  describe '#extract_style_signals — anxious style reachability' do
+    it 'produces frequency_variance and reciprocity_imbalance values that can trigger anxious style' do
+      base = Time.now
+      # 6 in one bucket + 1 isolated — high frequency variance
+      timestamps = Array.new(6) { base } + [base + 7200]
+      # All agent-initiated — max reciprocity imbalance
+      obs = timestamps.map.with_index do |t, i|
+        { agent_id: 'partner-1', timestamp: t, initiated_by: :agent, direction: :outgoing,
+          direct_address: i.even? }
+      end
+
+      signals = host.send(:extract_style_signals, 'partner-1', obs)
+      expect(signals[:frequency_variance]).to be > 0.4
+      expect(signals[:reciprocity_imbalance]).to be > 0.3
+    end
+
+    it 'actually drives derive_style! to :anxious with high-variance, high-imbalance signals' do
+      model = Legion::Extensions::Agentic::Social::Attachment::Helpers::AttachmentModel.new(agent_id: 'p')
+      model.derive_style!(
+        frequency_variance:    0.5,
+        reciprocity_imbalance: 0.4,
+        frequency:             0.6,
+        direct_address_ratio:  0.3
+      )
+      expect(model.attachment_style).to eq(:anxious)
+    end
+  end
+
+  describe '#build_narrative' do
+    let(:model) do
+      m = Legion::Extensions::Agentic::Social::Attachment::Helpers::AttachmentModel.new(agent_id: 'p')
+      m.instance_variable_set(:@bond_stage, :established)
+      m.instance_variable_set(:@attachment_style, :secure)
+      m
+    end
+
+    it 'returns nil when model is nil' do
+      expect(host.send(:build_narrative, nil, 0.5, {})).to be_nil
+    end
+
+    it 'returns a non-empty string' do
+      result = host.send(:build_narrative, model, 0.75, {})
+      expect(result).to be_a(String)
+      expect(result).not_to be_empty
+    end
+
+    it 'includes stage and style' do
+      result = host.send(:build_narrative, model, 0.75, {})
+      expect(result).to include('established')
+      expect(result).to include('secure')
+    end
+
+    it 'includes health value' do
+      result = host.send(:build_narrative, model, 0.75, {})
+      expect(result).to include('0.8') # format('%.1f', 0.75) => '0.8'
+    end
+
+    it 'includes chapter when present in arc_state' do
+      result = host.send(:build_narrative, model, 0.5, { current_chapter: 'discovery' })
+      expect(result).to include('discovery')
+    end
+
+    it 'includes milestone count when milestones present' do
+      arc = { milestones_today: %w[first_conflict repair] }
+      result = host.send(:build_narrative, model, 0.5, arc)
+      expect(result).to include('2 milestone(s) today')
+    end
+
+    it 'does not include milestone text when milestones empty' do
+      result = host.send(:build_narrative, model, 0.5, { milestones_today: [] })
+      expect(result).not_to include('milestone')
+    end
+  end
+
+  describe '#absence_exceeds_pattern?' do
+    it 'returns false when agent_id is nil' do
+      expect(host.send(:absence_exceeds_pattern?, nil)).to be false
+    end
+
+    it 'returns false when CommunicationPattern not defined and no apollo store' do
+      allow(host).to receive(:apollo_local_store).and_return(nil)
+      expect(host.send(:absence_exceeds_pattern?, 'partner-1')).to be false
+    end
+
+    it 'returns false when apollo store returns no results' do
+      mock_store = double('apollo_local')
+      allow(host).to receive(:apollo_local_store).and_return(mock_store)
+      allow(mock_store).to receive(:query).and_return({ success: true, results: [] })
+      expect(host.send(:absence_exceeds_pattern?, 'partner-1')).to be false
+    end
+
+    it 'returns false when apollo data has no avg_gap' do
+      mock_store = double('apollo_local')
+      allow(host).to receive(:apollo_local_store).and_return(mock_store)
+      content = Legion::JSON.dump({ last_interaction_at: (Time.now - 3600).to_s })
+      allow(mock_store).to receive(:query).and_return({
+                                                        success: true,
+                                                        results: [{ content: content }]
+                                                      })
+      expect(host.send(:absence_exceeds_pattern?, 'partner-1')).to be false
+    end
+
+    it 'returns true when current gap exceeds 2x average gap' do
+      mock_store = double('apollo_local')
+      allow(host).to receive(:apollo_local_store).and_return(mock_store)
+      last_seen = Time.now - 7200 # 2 hours ago
+      content = Legion::JSON.dump({
+                                    average_gap_seconds: 1800.0, # normal = 30 min
+                                    last_interaction_at: last_seen.to_s
+                                  })
+      allow(mock_store).to receive(:query).and_return({
+                                                        success: true,
+                                                        results: [{ content: content }]
+                                                      })
+      expect(host.send(:absence_exceeds_pattern?, 'partner-1')).to be true
+    end
+
+    it 'returns false when current gap is within normal range' do
+      mock_store = double('apollo_local')
+      allow(host).to receive(:apollo_local_store).and_return(mock_store)
+      last_seen = Time.now - 600 # 10 minutes ago
+      content = Legion::JSON.dump({
+                                    average_gap_seconds: 1800.0, # normal = 30 min
+                                    last_interaction_at: last_seen.to_s
+                                  })
+      allow(mock_store).to receive(:query).and_return({
+                                                        success: true,
+                                                        results: [{ content: content }]
+                                                      })
+      expect(host.send(:absence_exceeds_pattern?, 'partner-1')).to be false
+    end
+  end
+
+  describe '#reflect_on_bonds — narrative and absence fields' do
+    let(:mock_store) { double('apollo_local') }
+
+    before do
+      allow(host).to receive(:apollo_local_store).and_return(mock_store)
+      allow(mock_store).to receive(:query).and_return({ success: true, results: [] })
+
+      store = host.send(:attachment_store)
+      model = store.get_or_create('partner-1')
+      model.update_from_signals(frequency_score: 0.6, reciprocity_score: 0.5,
+                                prediction_accuracy: 0.7, direct_address_ratio: 0.4,
+                                channel_consistency: 0.8)
+      model.instance_variable_set(:@interaction_count, 55)
+      model.instance_variable_set(:@bond_stage, :established)
+    end
+
+    it 'includes a non-nil narrative in partner_bond' do
+      result = host.reflect_on_bonds(tick_results: {}, bond_summary: {})
+      expect(result[:partner_bond][:narrative]).not_to be_nil
+      expect(result[:partner_bond][:narrative]).to be_a(String)
+    end
+
+    it 'includes absence_exceeds_pattern in partner_bond' do
+      result = host.reflect_on_bonds(tick_results: {}, bond_summary: {})
+      expect(result[:partner_bond]).to have_key(:absence_exceeds_pattern)
+    end
+  end
 end

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

@@ -72,6 +72,73 @@ RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Runners::Calibr
     end
   end
 
+  describe '#retrieve_from_memory' do
+    it 'returns empty array when lex-agentic-memory is not loaded' do
+      result = client.send(:retrieve_from_memory)
+      expect(result).to eq([])
+    end
+  end
+
+  describe '#retrieve_from_apollo_local' do
+    it 'returns empty array when Apollo Local is not available' do
+      result = client.send(:retrieve_from_apollo_local)
+      expect(result).to eq([])
+    end
+
+    it 'maps Apollo Local entries to trace-compatible hashes when available' do
+      mock_local = double('apollo_local')
+      stub_const('Legion::Apollo', Module.new)
+      stub_const('Legion::Apollo::Local', mock_local)
+      allow(mock_local).to receive(:started?).and_return(true)
+      allow(mock_local).to receive(:query_by_tags).with(tags: ['partner_interaction'], limit: 50).and_return([
+                                                                                                               {
+                                                                                                                 content:    'hello partner',
+                                                                                                                 tags:       ['partner_interaction'],
+                                                                                                                 confidence: 0.8
+                                                                                                               }
+                                                                                                             ])
+
+      result = client.send(:retrieve_from_apollo_local)
+      expect(result).to be_an(Array)
+      expect(result.size).to eq(1)
+      expect(result.first[:content]).to eq('hello partner')
+      expect(result.first[:confidence]).to eq(0.8)
+    end
+
+    it 'returns empty array and logs warning when Apollo Local raises' do
+      mock_local = double('apollo_local')
+      stub_const('Legion::Apollo', Module.new)
+      stub_const('Legion::Apollo::Local', mock_local)
+      allow(mock_local).to receive(:started?).and_return(true)
+      allow(mock_local).to receive(:query_by_tags).and_raise(StandardError, 'db error')
+      allow(Legion::Logging).to receive(:warn)
+
+      result = client.send(:retrieve_from_apollo_local)
+      expect(result).to eq([])
+      expect(Legion::Logging).to have_received(:warn).with(a_string_including('retrieve_from_apollo_local'))
+    end
+  end
+
+  describe '#retrieve_interaction_traces' do
+    it 'falls through to Apollo Local when memory returns no traces' do
+      allow(client).to receive(:retrieve_from_memory).and_return([])
+      allow(client).to receive(:retrieve_from_apollo_local).and_return([{ content: 'trace', tags: [], confidence: 0.5 }])
+
+      result = client.send(:retrieve_interaction_traces)
+      expect(result).not_to be_empty
+      expect(result.first[:content]).to eq('trace')
+    end
+
+    it 'returns memory traces directly without calling Apollo Local when memory has results' do
+      memory_trace = { content: 'memory trace', tags: ['partner_interaction'], recorded_at: Time.now }
+      allow(client).to receive(:retrieve_from_memory).and_return([memory_trace])
+      expect(client).not_to receive(:retrieve_from_apollo_local)
+
+      result = client.send(:retrieve_interaction_traces)
+      expect(result).to eq([memory_trace])
+    end
+  end
+
   describe '#promote_partner_knowledge' do
     it 'skips when Apollo Local unavailable' do
       result = client.promote_partner_knowledge

data/spec/legion/extensions/agentic/social/governance/runners/shadow_ai_spec.rb

@@ -43,6 +43,20 @@ RSpec.describe Legion::Extensions::Agentic::Social::Governance::Runners::ShadowA
       result = host.check_airb_compliance
       expect(result[:source]).to eq(:unavailable)
     end
+
+    it 'includes a reason field when unavailable' do
+      result = host.check_airb_compliance
+      expect(result).to have_key(:reason)
+      expect(result[:reason]).to be_a(String)
+      expect(result[:reason]).not_to be_empty
+    end
+
+    it 'logs a debug message when DigitalWorker model is not loaded' do
+      allow(Legion::Logging).to receive(:debug)
+      host.check_airb_compliance
+      expect(Legion::Logging).to have_received(:debug)
+        .with(a_string_including('AIRB compliance check unavailable'))
+    end
   end
 
   describe '#full_scan' do

metadata

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