lex-agentic-social 0.1.15 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ae718ace3eafb04ea8f811bb5cf0d9ef384e6b63887f1423c8461b04269a524
-  data.tar.gz: 84e78ce21707ba78c4f90dc5168a99ca494fa4610d12cc609a72f5664cf43bee
+  metadata.gz: 2fc82cf70d0df9c909097bbed4d53fc58e64e2ca8904a49c6d7abf030fc3b2c6
+  data.tar.gz: 41e0f3966d50d002ccd5cf3a96d488b7bb1d2208cc4f36b931a5fd311786c80a
 SHA512:
-  metadata.gz: 14f3884ae4814a76e9872081d132cd4b9b3fbf5a3dcf247541a67e5cf6c4d3a152e071753de8fc45a50a99cdb83df78dc2a8019f1fb949dea1f628a4da7870af
-  data.tar.gz: 3f991289c88888c67ddb146e094ea07f39f7fd79698c35c1b8b4bbb01cf29c74e6b256238c4b0f6b2c411eab6a070893db5350a99c8c1f0e7775461eca2c0ce4
+  metadata.gz: e013c357c5281df840b02a4ec06d16fee47d63af742b97ae1a6fe132612b66f6c8464b0316b1d564e6cc3927da03b8b21629500fc52685206af0ef28649865f6
+  data.tar.gz: 01a2eb7ebda54716bfb68542f22622aedf96525b98809a84d758f1fd2c8fc44d7eb6e5a02cfbf1354da466cbfebe786b99fed33212d537df1bb9cc1963bb7eb2

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.1.17] - 2026-05-15
+### Fixed
+- Social LLM enhancers now send explicit system and user messages to native `Legion::LLM.chat` dispatch instead of opening legacy nil-input chat sessions.
+- Calibration LLM preference upsert now passes `access_scope: 'private'` and `identity_principal_id: nil` to prevent daemon process identity injection on personal data writes.
+
+## [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

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

@@ -194,14 +194,20 @@ 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,
+                                               access_scope: 'private',
+                                               identity_principal_id: nil)
                 end
               end
             end

data/lib/legion/extensions/agentic/social/conflict/helpers/llm_enhancer.rb

@@ -57,9 +57,14 @@ module Legion
                   content = response&.message&.dig(:content)
                   ::Struct.new(:content).new(content) if content
                 else
-                  chat = Legion::LLM.chat
-                  chat.with_instructions(SYSTEM_PROMPT)
-                  chat.ask(prompt)
+                  response = Legion::LLM.chat(
+                    message: [
+                      { role: 'system', content: SYSTEM_PROMPT },
+                      { role: 'user', content: prompt }
+                    ],
+                    caller:  { extension: 'lex-agentic-social', mode: :conflict }
+                  )
+                  response.respond_to?(:content) ? response : response.ask(prompt)
                 end
               end
               private_class_method :llm_ask

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/llm_enhancer.rb

@@ -50,9 +50,14 @@ module Legion
                   content = response&.message&.dig(:content)
                   ::Struct.new(:content).new(content) if content
                 else
-                  chat = Legion::LLM.chat
-                  chat.with_instructions(SYSTEM_PROMPT)
-                  chat.ask(prompt)
+                  response = Legion::LLM.chat(
+                    message: [
+                      { role: 'system', content: SYSTEM_PROMPT },
+                      { role: 'user', content: prompt }
+                    ],
+                    caller:  { extension: 'lex-agentic-social', mode: :moral_reasoning }
+                  )
+                  response.respond_to?(:content) ? response : response.ask(prompt)
                 end
               end
               private_class_method :llm_ask

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.15'
+        VERSION = '0.1.17'
       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
@@ -182,4 +200,52 @@ RSpec.describe Legion::Extensions::Agentic::Social::Calibration::Runners::Calibr
       expect(result[:results]).to have_key(:promotion)
     end
   end
+
+  describe '#store_llm_preferences' do
+    let(:preferences) do
+      [{ 'domain' => 'communication', 'value' => 'direct', 'confidence' => 0.8 }]
+    end
+
+    before 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).and_return({ success: true })
+    end
+
+    it 'passes access_scope: private to Apollo::Local.upsert' do
+      mock_local = Legion::Apollo::Local
+      client.send(:store_llm_preferences, preferences)
+      expect(mock_local).to have_received(:upsert).with(
+        hash_including(access_scope: 'private')
+      )
+    end
+
+    it 'passes content and tags to Apollo::Local.upsert' do
+      mock_local = Legion::Apollo::Local
+      client.send(:store_llm_preferences, preferences)
+      expect(mock_local).to have_received(:upsert).with(
+        hash_including(
+          content: a_string_including('direct'),
+          tags:    array_including('preference', 'preference:communication')
+        )
+      )
+    end
+
+    it 'does not inject process identity as the owner' do
+      stub_const('Legion::Identity::Process', Module.new do
+        extend self
+
+        define_method(:identity_hash) do
+          { canonical_name: 'daemon', db_principal_id: 999, db_identity_id: 888 }
+        end
+      end)
+      mock_local = Legion::Apollo::Local
+      client.send(:store_llm_preferences, preferences)
+      expect(mock_local).to have_received(:upsert).with(
+        hash_including(identity_principal_id: nil)
+      )
+    end
+  end
 end

data/spec/legion/extensions/agentic/social/conflict/helpers/llm_enhancer_spec.rb

@@ -112,6 +112,53 @@ RSpec.describe Legion::Extensions::Agentic::Social::Conflict::Helpers::LlmEnhanc
         expect(result).to be_nil
       end
     end
+
+    context 'when LLM returns a native content response (direct dispatch path)' do
+      let(:native_response) do
+        double(content: "OUTCOME: resolved\nNOTES: Native dispatch resolved the conflict directly.")
+      end
+
+      before do
+        allow(Legion::LLM).to receive(:chat).and_return(native_response)
+      end
+
+      it 'calls Legion::LLM.chat with system and user messages' do
+        expect(Legion::LLM).to receive(:chat).with(
+          hash_including(
+            message: array_including(
+              hash_including(role: 'system'),
+              hash_including(role: 'user')
+            )
+          )
+        ).and_return(native_response)
+        described_class.suggest_resolution(
+          description: 'Agent and human disagree',
+          severity:    :medium,
+          exchanges:   []
+        )
+      end
+
+      it 'calls Legion::LLM.chat with caller metadata' do
+        expect(Legion::LLM).to receive(:chat).with(
+          hash_including(caller: { extension: 'lex-agentic-social', mode: :conflict })
+        ).and_return(native_response)
+        described_class.suggest_resolution(
+          description: 'Agent and human disagree',
+          severity:    :medium,
+          exchanges:   []
+        )
+      end
+
+      it 'uses the content directly without calling ask' do
+        expect(native_response).not_to receive(:ask)
+        result = described_class.suggest_resolution(
+          description: 'Agent and human disagree',
+          severity:    :medium,
+          exchanges:   []
+        )
+        expect(result[:suggested_outcome]).to eq(:resolved)
+      end
+    end
   end
 
   describe '.analyze_stale_conflict' do
@@ -185,5 +232,46 @@ RSpec.describe Legion::Extensions::Agentic::Social::Conflict::Helpers::LlmEnhanc
         expect(result).to be_nil
       end
     end
+
+    context 'when LLM returns a native content response (direct dispatch path)' do
+      let(:native_response) do
+        double(content: "RECOMMENDATION: escalate\nANALYSIS: Native dispatch recommends escalation.")
+      end
+
+      before do
+        allow(Legion::LLM).to receive(:chat).and_return(native_response)
+      end
+
+      it 'calls Legion::LLM.chat with system and user messages' do
+        expect(Legion::LLM).to receive(:chat).with(
+          hash_including(
+            message: array_including(
+              hash_including(role: 'system'),
+              hash_including(role: 'user')
+            )
+          )
+        ).and_return(native_response)
+        described_class.analyze_stale_conflict(
+          description: 'Stale safety concern', severity: :high, age_hours: 40.0, exchange_count: 1
+        )
+      end
+
+      it 'calls Legion::LLM.chat with caller metadata' do
+        expect(Legion::LLM).to receive(:chat).with(
+          hash_including(caller: { extension: 'lex-agentic-social', mode: :conflict })
+        ).and_return(native_response)
+        described_class.analyze_stale_conflict(
+          description: 'Stale safety concern', severity: :high, age_hours: 40.0, exchange_count: 1
+        )
+      end
+
+      it 'uses the content directly without calling ask' do
+        expect(native_response).not_to receive(:ask)
+        result = described_class.analyze_stale_conflict(
+          description: 'Stale safety concern', severity: :high, age_hours: 40.0, exchange_count: 1
+        )
+        expect(result[:recommendation]).to eq(:escalate)
+      end
+    end
   end
 end

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/llm_enhancer_spec.rb

@@ -150,6 +150,57 @@ RSpec.describe Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Llm
         expect(result).to be_nil
       end
     end
+
+    context 'when LLM returns a native content response (direct dispatch path)' do
+      let(:native_response) do
+        content = <<~TEXT
+          REASONING: Native dispatch evaluated this action as broadly positive.
+          IMPACT: care=0.4 | fairness=0.3 | loyalty=0.1 | authority=0.0 | sanctity=0.2 | liberty=0.1
+        TEXT
+        double('native_response', content: content)
+      end
+
+      before do
+        allow(Legion::LLM).to receive(:chat).and_return(native_response)
+      end
+
+      it 'calls Legion::LLM.chat with system and user messages' do
+        expect(Legion::LLM).to receive(:chat).with(
+          hash_including(
+            message: array_including(
+              hash_including(role: 'system'),
+              hash_including(role: 'user')
+            )
+          )
+        ).and_return(native_response)
+        enhancer.evaluate_action(
+          action:      :help_stranger,
+          description: 'Helping someone in need',
+          foundations: foundations
+        )
+      end
+
+      it 'calls Legion::LLM.chat with caller metadata' do
+        expect(Legion::LLM).to receive(:chat).with(
+          hash_including(caller: { extension: 'lex-agentic-social', mode: :moral_reasoning })
+        ).and_return(native_response)
+        enhancer.evaluate_action(
+          action:      :help_stranger,
+          description: 'Helping someone in need',
+          foundations: foundations
+        )
+      end
+
+      it 'uses the content directly without calling ask' do
+        expect(native_response).not_to receive(:ask)
+        result = enhancer.evaluate_action(
+          action:      :help_stranger,
+          description: 'Helping someone in need',
+          foundations: foundations
+        )
+        expect(result[:foundation_impacts]).to include(:care, :fairness)
+      end
+    end
   end
 
   describe '.resolve_dilemma' do
@@ -228,5 +279,58 @@ RSpec.describe Legion::Extensions::Agentic::Social::MoralReasoning::Helpers::Llm
         expect(result).to be_nil
       end
     end
+
+    context 'when LLM returns a native content response (direct dispatch path)' do
+      let(:native_response) do
+        content = <<~TEXT
+          CHOSEN: opt_b
+          CONFIDENCE: 0.75
+          REASONING: Native dispatch selected option b based on deontological constraints.
+        TEXT
+        double('native_response', content: content)
+      end
+
+      before do
+        allow(Legion::LLM).to receive(:chat).and_return(native_response)
+      end
+
+      it 'calls Legion::LLM.chat with system and user messages' do
+        expect(Legion::LLM).to receive(:chat).with(
+          hash_including(
+            message: array_including(
+              hash_including(role: 'system'),
+              hash_including(role: 'user')
+            )
+          )
+        ).and_return(native_response)
+        enhancer.resolve_dilemma(
+          dilemma_description: 'Should the agent reveal sensitive information?',
+          options:             options,
+          framework:           :deontological
+        )
+      end
+
+      it 'calls Legion::LLM.chat with caller metadata' do
+        expect(Legion::LLM).to receive(:chat).with(
+          hash_including(caller: { extension: 'lex-agentic-social', mode: :moral_reasoning })
+        ).and_return(native_response)
+        enhancer.resolve_dilemma(
+          dilemma_description: 'Should the agent reveal sensitive information?',
+          options:             options,
+          framework:           :deontological
+        )
+      end
+
+      it 'uses the content directly without calling ask' do
+        expect(native_response).not_to receive(:ask)
+        result = enhancer.resolve_dilemma(
+          dilemma_description: 'Should the agent reveal sensitive information?',
+          options:             options,
+          framework:           :deontological
+        )
+        expect(result[:chosen_option]).to eq('opt_b')
+        expect(result[:confidence]).to eq(0.75)
+      end
+    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.15
+  version: 0.1.17
 platform: ruby
 authors:
 - Esity