lex-agentic-social 0.1.14 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 785afcf396e852ec5c417d3ddd68f04dc62bb290f5687a9115156f98cf5f59d2
-  data.tar.gz: f6ee2703b49a5e2dcc331596f703dee60a8ddd8ea601425439e26cc4b2e00706
+  metadata.gz: e415a1e8df317c84447b21607aa89a50091a52ee603c103532434e613b5c79f8
+  data.tar.gz: '0485cc912a12c05e87ed0d6a89f34a20e678f92bdb1fd33f40bee1f03fd5f6ce'
 SHA512:
-  metadata.gz: 687b70c4adafc0718c5634a83ad86353bc02f3b42782eae1d62b637081a4b69f9e4554942f8e9b2f09b28d78d6f4571a09d422259e160c69056bdd091f06d5bd
-  data.tar.gz: c6236731a1a0fae572ed1a36af0b7e7f8e842a95b64b1eac16331a2a366782d99a7313f82a7faa0f9f67b30668f25242a7a4ffd7573ede3105c6de1474b069e3
+  metadata.gz: 73b527381fc34d087abce74fd3fa0f704bd8c2717c5100b2b822a83c8a392c9a79aa5a44e78d9667d6429b733390d31056c1573661e03696ea317fdb25fecb30
+  data.tar.gz: 37e46998cc523737472ca6884db0a24320c18e252190cef94fefed44e70b70f5c60c57fa30f20832d7aed9cc847fb6d90615d1a7589b754e12099cadde1edbaf

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.1.16] - 2026-05-07
+### Fixed
+- Calibration preference storage now handles symbol-keyed parsed LLM preferences without dropping domain or value.
+- Consent restore preserves pending approval fields after local DB reloads.
+- Shadow AI scans flag scan failures as issues, conflict stale checks parse restored string timestamps, and moral reasoning reinforcement uses dilemma severity.
+
+## [0.1.15] - 2026-04-27
+### Fixed
+- Stop social calibration partner-knowledge promotion when Legion is shutting down or Apollo Local becomes unavailable between promotable tag groups
+
 ## [0.1.14] - 2026-04-22
 ### Added
 - `Governance#review_transition` method — API expected by lex-extinction for containment governance gate

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

@@ -79,10 +79,14 @@ module Legion
               end
 
               def promote_partner_knowledge(**)
+                return { success: true, skipped: :shutting_down } if shutting_down?
                 return { success: true, skipped: :local_unavailable } unless apollo_local_available?
 
                 total = 0
                 Helpers::Constants::PROMOTABLE_TAGS.each do |tags|
+                  return { success: true, promoted: total, stopped: :shutting_down } if shutting_down?
+                  return { success: true, promoted: total, stopped: :local_unavailable } unless apollo_local_available?
+
                   result = Legion::Apollo::Local.promote_to_global(tags: tags, min_confidence: Helpers::Constants::PROMOTION_MIN_CONFIDENCE)
                   total += result[:promoted] if result[:success]
                 end
@@ -112,6 +116,14 @@ module Legion
                 defined?(Legion::Apollo::Local) && Legion::Apollo::Local.started?
               end
 
+              def shutting_down?
+                return Legion.shutting_down? if defined?(Legion) && Legion.respond_to?(:shutting_down?)
+
+                defined?(Legion::Settings) && Legion::Settings.dig(:client, :shutting_down) == true
+              rescue StandardError => _e
+                false
+              end
+
               def retrieve_interaction_traces
                 traces = retrieve_from_memory
                 return traces if traces.any?
@@ -182,14 +194,17 @@ module Legion
 
                 base_tags = %w[partner preference llm_inference]
                 preferences.each do |pref|
+                  domain = pref[:domain] || pref['domain']
+                  value = pref[:value] || pref['value']
+                  confidence = pref[:confidence] || pref['confidence'] || 0.65
                   content = Legion::JSON.dump({
-                                                'domain'     => pref['domain'],
-                                                'value'      => pref['value'],
+                                                'domain'     => domain,
+                                                'value'      => value,
                                                 'source'     => 'llm_inference',
-                                                'confidence' => pref['confidence'] || 0.65
+                                                'confidence' => confidence
                                               })
-                  tags = base_tags + ["preference:#{pref['domain']}"]
-                  Legion::Apollo::Local.upsert(content: content, tags: tags, confidence: pref['confidence'] || 0.65)
+                  tags = base_tags + ["preference:#{domain}"]
+                  Legion::Apollo::Local.upsert(content: content, tags: tags, confidence: confidence)
                 end
               end
             end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'time'
+
 module Legion
   module Extensions
     module Agentic
@@ -70,12 +72,12 @@ module Legion
 
               def check_stale_conflicts(**)
                 active = conflict_log.active_conflicts
-                stale  = active.select { |c| Time.now.utc - c[:created_at] > Helpers::Severity::STALE_CONFLICT_TIMEOUT }
+                stale  = active.select { |c| conflict_age_seconds(c) > Helpers::Severity::STALE_CONFLICT_TIMEOUT }
                 stale.each do |c|
                   message = 'conflict marked stale — no resolution after 24h'
 
                   if Helpers::LlmEnhancer.available?
-                    age_hours = (Time.now.utc - c[:created_at]) / 3600.0
+                    age_hours = conflict_age_seconds(c) / 3600.0
                     analysis  = Helpers::LlmEnhancer.analyze_stale_conflict(
                       description:    c[:description],
                       severity:       c[:severity],
@@ -103,6 +105,12 @@ module Legion
               def conflict_log
                 @conflict_log ||= Helpers::ConflictLog.new
               end
+
+              def conflict_age_seconds(conflict)
+                created_at = conflict[:created_at]
+                created_at = Time.parse(created_at) if created_at.is_a?(String)
+                Time.now.utc - created_at
+              end
             end
           end
         end

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

@@ -170,14 +170,14 @@ module Legion
                     []
                   end
 
-                  @domains[key] = {
+                  @domains[key].merge!(
                     tier:            row[:tier].to_sym,
                     success_count:   row[:success_count].to_i,
                     failure_count:   row[:failure_count].to_i,
                     total_actions:   row[:total_actions].to_i,
                     last_changed_at: row[:last_changed_at],
                     history:         history
-                  }
+                  )
                 end
               rescue StandardError => e
                 Legion::Logging.warn "[consent] load_from_local failed: #{e.message}"

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

@@ -14,7 +14,8 @@ module Legion
                 unregistered = installed - registered
                 { installed: installed.size, registered: registered.size, unregistered: unregistered }
               rescue StandardError => e
-                { installed: 0, registered: 0, unregistered: [], error: e.message }
+                Legion::Logging.warn("[governance:shadow_ai] extension scan failed: #{e.message}")
+                { installed: 0, registered: 0, unregistered: [], scan_failed: true, error: e.message }
               end
 
               def check_llm_bypass_indicators(**)
@@ -47,7 +48,8 @@ module Legion
                 bypass = check_llm_bypass_indicators
                 compliance = check_airb_compliance
 
-                has_issues = extensions[:unregistered]&.any? || bypass[:bypassed] || compliance[:non_compliant]&.any?
+                has_issues = extensions[:scan_failed] || extensions[:unregistered]&.any? ||
+                             bypass[:bypassed] || compliance[:non_compliant]&.any?
                 emit_shadow_event(extensions, bypass, compliance) if has_issues
 
                 { extensions: extensions, bypass: bypass, compliance: compliance, issues_found: has_issues }

data/lib/legion/extensions/agentic/social/moral_reasoning/helpers/moral_engine.rb

@@ -117,7 +117,7 @@ module Legion
                 return { success: false, reason: :invalid_option } unless chosen
 
                 dilemma.resolve(option_id: option_id, reasoning: reasoning, framework: framework)
-                reinforce_chosen_foundations(chosen)
+                reinforce_chosen_foundations(chosen, severity: dilemma.severity)
                 weaken_unchosen_foundations(dilemma.options, option_id)
                 add_history(type: :resolution, dilemma_id: dilemma_id, option_id: option_id,
                             framework: framework, severity: dilemma.severity)
@@ -210,9 +210,9 @@ module Legion
                 end
               end
 
-              def reinforce_chosen_foundations(chosen_option)
+              def reinforce_chosen_foundations(chosen_option, severity:)
                 chosen_option.fetch(:foundations, []).each do |fid|
-                  @foundations[fid]&.reinforce(amount: chosen_option.fetch(:severity, 1.0))
+                  @foundations[fid]&.reinforce(amount: severity)
                 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.14'
+        VERSION = '0.1.16'
       end
     end
   end

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

@@ -70,6 +70,24 @@ RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Runners::Calibr
       result = client.extract_preferences_via_llm
       expect(result[:skipped]).to eq(:llm_unavailable)
     end
+
+    it 'stores symbol-keyed parsed preferences with domain and value intact' 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(:upsert)
+
+      client.send(:store_llm_preferences, [{ domain: 'tone', value: 'concise', confidence: 0.8 }])
+
+      expect(mock_local).to have_received(:upsert) do |args|
+        content = Legion::JSON.load(args[:content])
+        expect(content[:domain]).to eq('tone')
+        expect(content[:value]).to eq('concise')
+        expect(args[:tags]).to include('preference:tone')
+        expect(args[:confidence]).to eq(0.8)
+      end
+    end
   end
 
   describe '#retrieve_from_memory' do
@@ -146,6 +164,32 @@ RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Runners::Calibr
       result = client.promote_partner_knowledge
       expect(result[:skipped]).to eq(:local_unavailable)
     end
+
+    it 'skips when Legion is shutting down' do
+      allow(Legion::Settings).to receive(:dig).with(:client, :shutting_down).and_return(true)
+
+      result = client.promote_partner_knowledge
+      expect(result[:skipped]).to eq(:shutting_down)
+    end
+
+    it 'stops when Apollo Local becomes unavailable between tag groups' do
+      mock_local = double('apollo_local')
+      stub_const('Legion::Apollo', Module.new)
+      stub_const('Legion::Apollo::Local', mock_local)
+      allow(Legion::Settings).to receive(:dig).with(:client, :shutting_down).and_return(false)
+      allow(mock_local).to receive(:started?).and_return(true, true, false)
+      expect(mock_local).to receive(:promote_to_global)
+        .with(
+          tags:           Legion::Extensions::Agentic::Social::Calibration::Helpers::Constants::PROMOTABLE_TAGS.first,
+          min_confidence: Legion::Extensions::Agentic::Social::Calibration::Helpers::Constants::PROMOTION_MIN_CONFIDENCE
+        )
+        .once
+        .and_return({ success: true, promoted: 2 })
+
+      result = client.promote_partner_knowledge
+      expect(result[:promoted]).to eq(2)
+      expect(result[:stopped]).to eq(:local_unavailable)
+    end
   end
 
   describe '#sync_partner_knowledge' do

data/spec/legion/extensions/agentic/social/conflict/runners/conflict_spec.rb

@@ -78,6 +78,17 @@ RSpec.describe Legion::Extensions::Agentic::Social::Conflict::Runners::Conflict
       expect(result[:stale_ids]).to include(c[:conflict_id])
     end
 
+    it 'detects stale conflicts restored with string created_at values' do
+      c = client.register_conflict(parties: %w[a b], severity: :medium, description: 'old')
+      conflict = client.instance_variable_get(:@conflict_log).conflicts[c[:conflict_id]]
+      conflict[:created_at] = (Time.now.utc - (Legion::Extensions::Agentic::Social::Conflict::Helpers::Severity::STALE_CONFLICT_TIMEOUT + 1)).iso8601
+
+      result = client.check_stale_conflicts
+
+      expect(result[:stale_count]).to eq(1)
+      expect(result[:stale_ids]).to include(c[:conflict_id])
+    end
+
     it 'does not include resolved conflicts in stale check' do
       c = client.register_conflict(parties: %w[a b], severity: :low, description: 'resolved')
       conflict = client.instance_variable_get(:@conflict_log).conflicts[c[:conflict_id]]

data/spec/legion/extensions/agentic/social/consent/local_persistence_spec.rb

@@ -122,6 +122,25 @@ RSpec.describe 'lex-consent local SQLite persistence' do
       expect(map.domains['email'][:total_actions]).to eq(6)
     end
 
+    it 'restores pending fields with default nil values' do
+      db[:consent_domains].insert(
+        domain_key:    'email',
+        tier:          'consult',
+        success_count: 1,
+        failure_count: 0,
+        total_actions: 1,
+        history:       '[]'
+      )
+
+      map = Legion::Extensions::Agentic::Social::Consent::Helpers::ConsentMap.new
+      expect(map.pending?('email')).to be false
+      expect(map.domains['email']).to include(
+        pending_tier:         nil,
+        pending_since:        nil,
+        pending_requested_by: nil
+      )
+    end
+
     it 'restores history as an array of hashes with symbol keys' do
       history_json = JSON.generate([{ 'from' => 'consult', 'to' => 'act_notify', 'at' => Time.now.utc.to_s }])
       db[:consent_domains].insert(

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

@@ -75,5 +75,20 @@ RSpec.describe Legion::Extensions::Agentic::Social::Governance::Runners::ShadowA
       expect(result[:issues_found]).to be_falsey
       expect(result[:extensions][:installed]).to eq(5)
     end
+
+    it 'treats extension scan failure as an issue' do
+      allow(host).to receive(:scan_unregistered_extensions).and_return(
+        { installed: 0, registered: 0, unregistered: [], scan_failed: true, error: 'Gemfile not found' }
+      )
+      allow(host).to receive(:check_llm_bypass_indicators).and_return(
+        { indicators: [], bypassed: false }
+      )
+      allow(host).to receive(:check_airb_compliance).and_return(
+        { checked: 0, source: :unavailable }
+      )
+
+      result = host.full_scan
+      expect(result[:issues_found]).to be true
+    end
   end
 end

data/spec/legion/extensions/agentic/social/moral_reasoning/helpers/moral_engine_spec.rb

@@ -89,6 +89,25 @@ RSpec.describe Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Mor
       expect(result[:dilemma][:resolved]).to be true
     end
 
+    it 'uses the dilemma severity when reinforcing chosen foundations' do
+      dilemma_id = engine.pose_dilemma(
+        description: 'Low severity',
+        options:     options,
+        severity:    0.2
+      )[:dilemma][:id]
+      before_weight = engine.foundation_profile[:care][:weight]
+
+      engine.resolve_dilemma(
+        dilemma_id: dilemma_id,
+        option_id:  'opt_a',
+        reasoning:  'Least harm',
+        framework:  :care_ethics
+      )
+
+      after_weight = engine.foundation_profile[:care][:weight]
+      expect(after_weight - before_weight).to be_within(0.001).of(0.02)
+    end
+
     it 'returns failure for unknown dilemma_id' do
       result = engine.resolve_dilemma(
         dilemma_id: 'nonexistent', option_id: 'opt_a',

metadata

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