lex-agentic-social 0.1.0

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/conflict/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Conflict::Runners::Conflict do
+  let(:client) { Legion::Extensions::Agentic::Social::Conflict::Client.new }
+
+  describe '#register_conflict' do
+    it 'creates a conflict with recommended posture' do
+      result = client.register_conflict(parties: %w[agent human], severity: :high, description: 'disagreement')
+      expect(result[:conflict_id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:posture]).to eq(:persistent_engagement)
+    end
+
+    it 'recommends stubborn_presence for critical' do
+      result = client.register_conflict(parties: %w[agent human], severity: :critical, description: 'safety issue')
+      expect(result[:posture]).to eq(:stubborn_presence)
+    end
+
+    it 'rejects invalid severity' do
+      result = client.register_conflict(parties: [], severity: :invalid, description: 'test')
+      expect(result[:error]).to eq(:invalid_severity)
+    end
+  end
+
+  describe '#add_exchange' do
+    it 'records an exchange' do
+      c = client.register_conflict(parties: %w[a b], severity: :medium, description: 'test')
+      result = client.add_exchange(conflict_id: c[:conflict_id], speaker: 'a', message: 'I disagree')
+      expect(result[:recorded]).to be true
+    end
+  end
+
+  describe '#resolve_conflict' do
+    it 'resolves a conflict' do
+      c = client.register_conflict(parties: %w[a b], severity: :low, description: 'test')
+      result = client.resolve_conflict(conflict_id: c[:conflict_id], outcome: :compromise)
+      expect(result[:resolved]).to be true
+    end
+  end
+
+  describe '#active_conflicts' do
+    it 'lists active conflicts' do
+      client.register_conflict(parties: %w[a b], severity: :low, description: 'test')
+      result = client.active_conflicts
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#recommended_posture' do
+    it 'returns posture for severity' do
+      result = client.recommended_posture(severity: :critical)
+      expect(result[:posture]).to eq(:stubborn_presence)
+    end
+  end
+
+  describe '#check_stale_conflicts' do
+    it 'returns zero stale when no conflicts exist' do
+      result = client.check_stale_conflicts
+      expect(result[:checked]).to eq(0)
+      expect(result[:stale_count]).to eq(0)
+      expect(result[:stale_ids]).to eq([])
+    end
+
+    it 'returns zero stale for recently created conflicts' do
+      client.register_conflict(parties: %w[a b], severity: :low, description: 'fresh')
+      result = client.check_stale_conflicts
+      expect(result[:stale_count]).to eq(0)
+    end
+
+    it 'detects stale conflicts older than STALE_CONFLICT_TIMEOUT' do
+      c = client.register_conflict(parties: %w[a b], severity: :medium, description: 'old')
+      # Backdate the created_at timestamp
+      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)
+      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]]
+      conflict[:created_at] = Time.now.utc - (Legion::Extensions::Agentic::Social::Conflict::Helpers::Severity::STALE_CONFLICT_TIMEOUT + 1)
+      client.resolve_conflict(conflict_id: c[:conflict_id], outcome: :closed)
+      result = client.check_stale_conflicts
+      expect(result[:stale_count]).to eq(0)
+    end
+
+    context 'with LLM available' do
+      let(:fake_chat) { double }
+      let(:fake_analysis_response) do
+        double(content: "RECOMMENDATION: escalate\nANALYSIS: The conflict has stalled and needs governance intervention.")
+      end
+
+      before do
+        stub_const('Legion::LLM', double(respond_to?: true, started?: true))
+        allow(Legion::LLM).to receive(:chat).and_return(fake_chat)
+        allow(fake_chat).to receive(:with_instructions)
+        allow(fake_chat).to receive(:ask).and_return(fake_analysis_response)
+      end
+
+      it 'includes LLM analysis in the stale system exchange message' do
+        c = client.register_conflict(parties: %w[a b], severity: :high, description: 'ongoing issue')
+        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)
+
+        client.check_stale_conflicts
+
+        exchanges = client.instance_variable_get(:@conflict_log).conflicts[c[:conflict_id]][:exchanges]
+        expect(exchanges).not_to be_empty
+        system_msg = exchanges.find { |e| e[:speaker] == :system }
+        expect(system_msg).not_to be_nil
+        expect(system_msg[:message]).to include('governance intervention')
+      end
+    end
+  end
+
+  describe '#resolve_conflict with LLM' do
+    let(:fake_chat) { double }
+    let(:fake_resolution_response) do
+      double(content: <<~TEXT)
+        OUTCOME: resolved
+        NOTES: Both parties reached a compromise after reviewing the evidence. Next steps include documenting the outcome and monitoring for recurrence.
+      TEXT
+    end
+
+    before do
+      stub_const('Legion::LLM', double(respond_to?: true, started?: true))
+      allow(Legion::LLM).to receive(:chat).and_return(fake_chat)
+      allow(fake_chat).to receive(:with_instructions)
+      allow(fake_chat).to receive(:ask).and_return(fake_resolution_response)
+    end
+
+    it 'uses LLM-generated notes when no resolution_notes provided' do
+      c = client.register_conflict(parties: %w[a b], severity: :medium, description: 'test conflict')
+      client.resolve_conflict(conflict_id: c[:conflict_id], outcome: :compromise)
+
+      conflict = client.instance_variable_get(:@conflict_log).conflicts[c[:conflict_id]]
+      expect(conflict[:resolution_notes]).to include('compromise')
+    end
+
+    it 'preserves caller-provided resolution_notes over LLM' do
+      c = client.register_conflict(parties: %w[a b], severity: :medium, description: 'test conflict')
+      client.resolve_conflict(conflict_id: c[:conflict_id], outcome: :compromise, resolution_notes: 'manual notes')
+
+      conflict = client.instance_variable_get(:@conflict_log).conflicts[c[:conflict_id]]
+      expect(conflict[:resolution_notes]).to eq('manual notes')
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/conscience/client_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Conscience::Client do
+  describe '#initialize' do
+    it 'creates a default moral store' do
+      client = described_class.new
+      expect(client.moral_store).to be_a(Legion::Extensions::Agentic::Social::Conscience::Helpers::MoralStore)
+    end
+
+    it 'accepts an injected moral store' do
+      store = Legion::Extensions::Agentic::Social::Conscience::Helpers::MoralStore.new
+      client = described_class.new(moral_store: store)
+      expect(client.moral_store).to be(store)
+    end
+
+    it 'ignores unknown kwargs' do
+      expect { described_class.new(unknown: true, other: 42) }.not_to raise_error
+    end
+  end
+
+  describe 'runner integration' do
+    let(:client) { described_class.new }
+
+    it { expect(client).to respond_to(:moral_evaluate) }
+    it { expect(client).to respond_to(:moral_status) }
+    it { expect(client).to respond_to(:moral_history) }
+    it { expect(client).to respond_to(:update_moral_outcome) }
+    it { expect(client).to respond_to(:moral_dilemmas) }
+    it { expect(client).to respond_to(:conscience_stats) }
+  end
+
+  describe 'shared state' do
+    it 'accumulates evaluations across multiple calls' do
+      client = described_class.new
+      context = { benefit_to_others: 0.5, harm_to_others: 0.0, consent_present: true }
+      7.times { client.moral_evaluate(action: :test, context: context) }
+      expect(client.moral_history[:total]).to eq(7)
+    end
+
+    it 'uses the same moral store for evaluations and status' do
+      client = described_class.new
+      client.moral_evaluate(action: :test, context: { benefit_to_others: 0.5 })
+      status = client.moral_status
+      expect(status[:stats][:total_evaluations]).to eq(1)
+    end
+  end
+
+  describe 'injected store passthrough' do
+    it 'uses the injected store for evaluations' do
+      store = Legion::Extensions::Agentic::Social::Conscience::Helpers::MoralStore.new
+      client = described_class.new(moral_store: store)
+      client.moral_evaluate(action: :test, context: {})
+      expect(store.history.size).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Conscience::Helpers::Constants do
+  describe 'MORAL_FOUNDATIONS' do
+    it 'defines 6 foundations' do
+      expect(described_class::MORAL_FOUNDATIONS.size).to eq(6)
+    end
+
+    it 'has weights summing to 1.0' do
+      total = described_class::MORAL_FOUNDATIONS.values.sum { |v| v[:weight] }
+      expect(total).to be_within(0.001).of(1.0)
+    end
+
+    it 'includes all 6 Haidt foundations' do
+      expect(described_class::MORAL_FOUNDATIONS.keys).to contain_exactly(
+        :care, :fairness, :loyalty, :authority, :sanctity, :liberty
+      )
+    end
+
+    it 'gives care the highest weight (0.25)' do
+      expect(described_class::MORAL_FOUNDATIONS[:care][:weight]).to eq(0.25)
+    end
+
+    it 'gives fairness the second highest weight (0.20)' do
+      expect(described_class::MORAL_FOUNDATIONS[:fairness][:weight]).to eq(0.20)
+    end
+
+    it 'gives liberty the lowest weight (0.10)' do
+      expect(described_class::MORAL_FOUNDATIONS[:liberty][:weight]).to eq(0.10)
+    end
+
+    it 'is frozen' do
+      expect(described_class::MORAL_FOUNDATIONS).to be_frozen
+    end
+
+    it 'each foundation has a description' do
+      described_class::MORAL_FOUNDATIONS.each_value do |config|
+        expect(config[:description]).to be_a(String)
+        expect(config[:description]).not_to be_empty
+      end
+    end
+  end
+
+  describe 'MORAL_VERDICTS' do
+    it 'defines 4 verdicts' do
+      expect(described_class::MORAL_VERDICTS.size).to eq(4)
+    end
+
+    it 'includes permitted, cautioned, conflicted, prohibited' do
+      expect(described_class::MORAL_VERDICTS).to include(:permitted, :cautioned, :conflicted, :prohibited)
+    end
+
+    it 'is frozen' do
+      expect(described_class::MORAL_VERDICTS).to be_frozen
+    end
+  end
+
+  describe 'FOUNDATION_ALPHA' do
+    it 'is 0.05 (very slow adaptation)' do
+      expect(described_class::FOUNDATION_ALPHA).to eq(0.05)
+    end
+
+    it 'is less than 0.1' do
+      expect(described_class::FOUNDATION_ALPHA).to be < 0.1
+    end
+  end
+
+  describe 'CONFLICT_THRESHOLD' do
+    it 'is 0.3' do
+      expect(described_class::CONFLICT_THRESHOLD).to eq(0.3)
+    end
+  end
+
+  describe 'PROHIBITION_THRESHOLD' do
+    it 'is -0.5' do
+      expect(described_class::PROHIBITION_THRESHOLD).to eq(-0.5)
+    end
+  end
+
+  describe 'CAUTION_THRESHOLD' do
+    it 'is -0.1' do
+      expect(described_class::CAUTION_THRESHOLD).to eq(-0.1)
+    end
+
+    it 'is greater than PROHIBITION_THRESHOLD' do
+      expect(described_class::CAUTION_THRESHOLD).to be > described_class::PROHIBITION_THRESHOLD
+    end
+  end
+
+  describe 'MAX_MORAL_HISTORY' do
+    it 'caps at 100' do
+      expect(described_class::MAX_MORAL_HISTORY).to eq(100)
+    end
+  end
+
+  describe 'DILEMMA_TYPES' do
+    it 'defines 3 dilemma types' do
+      expect(described_class::DILEMMA_TYPES.size).to eq(3)
+    end
+
+    it 'includes utilitarian, deontological, virtue_ethics' do
+      expect(described_class::DILEMMA_TYPES).to include(:utilitarian, :deontological, :virtue_ethics)
+    end
+
+    it 'is frozen' do
+      expect(described_class::DILEMMA_TYPES).to be_frozen
+    end
+  end
+
+  describe 'INITIAL_SENSITIVITY' do
+    it 'is 1.0 (fully sensitive at boot, decays through experience)' do
+      expect(described_class::INITIAL_SENSITIVITY).to eq(1.0)
+    end
+  end
+
+  describe 'MORAL_SCORE_RANGE' do
+    it 'spans -1.0 to 1.0' do
+      expect(described_class::MORAL_SCORE_RANGE[:min]).to eq(-1.0)
+      expect(described_class::MORAL_SCORE_RANGE[:max]).to eq(1.0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/conscience/helpers/moral_evaluator_spec.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Conscience::Helpers::MoralEvaluator do
+  subject(:evaluator) { described_class.new }
+
+  let(:benign_context) do
+    {
+      harm_to_others:                  0.0,
+      benefit_to_others:               0.8,
+      vulnerable_affected:             false,
+      distributional_justice:          0.7,
+      reciprocity:                     0.6,
+      proportionality:                 0.5,
+      alignment_with_group_norms:      0.6,
+      trust_preservation:              0.7,
+      legitimate_authority_compliance: 0.5,
+      hierarchy_respect:               0.4,
+      system_integrity:                0.8,
+      degradation_prevention:          0.7,
+      autonomy_preservation:           0.6,
+      consent_present:                 true
+    }
+  end
+
+  let(:harmful_context) do
+    {
+      harm_to_others:                  0.9,
+      benefit_to_others:               0.0,
+      vulnerable_affected:             true,
+      distributional_justice:          -0.8,
+      reciprocity:                     -0.7,
+      proportionality:                 -0.6,
+      alignment_with_group_norms:      -0.5,
+      trust_preservation:              -0.8,
+      legitimate_authority_compliance: -0.6,
+      hierarchy_respect:               -0.5,
+      system_integrity:                -0.9,
+      degradation_prevention:          -0.8,
+      autonomy_preservation:           -0.7,
+      consent_present:                 false
+    }
+  end
+
+  let(:conflicted_context) do
+    {
+      # Care says yes (benefit present, low harm)
+      harm_to_others:                  0.0,
+      benefit_to_others:               0.8,
+      # Fairness says no (unjust distribution)
+      distributional_justice:          -0.7,
+      reciprocity:                     -0.6,
+      proportionality:                 -0.5,
+      # Authority says no (violates hierarchy)
+      legitimate_authority_compliance: -0.8,
+      hierarchy_respect:               -0.6
+    }
+  end
+
+  describe '#initialize' do
+    it 'sets initial sensitivity to 1.0 for all foundations' do
+      evaluator.sensitivities.each_value do |s|
+        expect(s).to eq(1.0)
+      end
+    end
+
+    it 'has a sensitivity for each of the 6 foundations' do
+      expect(evaluator.sensitivities.keys).to contain_exactly(
+        :care, :fairness, :loyalty, :authority, :sanctity, :liberty
+      )
+    end
+  end
+
+  describe '#evaluate' do
+    it 'returns a hash with required keys' do
+      result = evaluator.evaluate(action: :deploy_patch, context: benign_context)
+      expect(result).to include(:action, :scores, :weighted_score, :verdict, :dilemma, :sensitivities, :evaluated_at)
+    end
+
+    it 'returns per-foundation scores for all 6 foundations' do
+      result = evaluator.evaluate(action: :deploy_patch, context: benign_context)
+      expect(result[:scores].keys).to contain_exactly(:care, :fairness, :loyalty, :authority, :sanctity, :liberty)
+    end
+
+    it 'gives a positive weighted_score for benign context' do
+      result = evaluator.evaluate(action: :deploy_patch, context: benign_context)
+      expect(result[:weighted_score]).to be > 0.0
+    end
+
+    it 'gives a negative weighted_score for harmful context' do
+      result = evaluator.evaluate(action: :delete_data, context: harmful_context)
+      expect(result[:weighted_score]).to be < 0.0
+    end
+
+    it 'returns :permitted verdict for benign context' do
+      result = evaluator.evaluate(action: :deploy_patch, context: benign_context)
+      expect(result[:verdict]).to eq(:permitted)
+    end
+
+    it 'returns :prohibited verdict for harmful context' do
+      result = evaluator.evaluate(action: :delete_data, context: harmful_context)
+      expect(result[:verdict]).to eq(:prohibited)
+    end
+
+    it 'weighted_score is within [-1.0, 1.0]' do
+      result = evaluator.evaluate(action: :anything, context: harmful_context)
+      expect(result[:weighted_score]).to be_between(-1.0, 1.0)
+    end
+
+    it 'includes evaluated_at timestamp' do
+      result = evaluator.evaluate(action: :test, context: {})
+      expect(result[:evaluated_at]).to be_a(Time)
+    end
+
+    it 'handles empty context without error' do
+      expect { evaluator.evaluate(action: :test, context: {}) }.not_to raise_error
+    end
+  end
+
+  describe '#weighted_score' do
+    it 'returns a float in [-1.0, 1.0]' do
+      scores = { care: 0.5, fairness: 0.3, loyalty: 0.2, authority: 0.1, sanctity: 0.4, liberty: 0.6 }
+      score = evaluator.weighted_score(scores)
+      expect(score).to be_a(Float)
+      expect(score).to be_between(-1.0, 1.0)
+    end
+
+    it 'returns 0.0 for all-zero scores' do
+      scores = { care: 0.0, fairness: 0.0, loyalty: 0.0, authority: 0.0, sanctity: 0.0, liberty: 0.0 }
+      expect(evaluator.weighted_score(scores)).to eq(0.0)
+    end
+
+    it 'returns a positive value when all scores are positive' do
+      scores = { care: 1.0, fairness: 1.0, loyalty: 1.0, authority: 1.0, sanctity: 1.0, liberty: 1.0 }
+      expect(evaluator.weighted_score(scores)).to be > 0.0
+    end
+  end
+
+  describe '#verdict' do
+    it 'returns :prohibited for score below -0.5' do
+      expect(evaluator.verdict(-0.6)).to eq(:prohibited)
+    end
+
+    it 'returns :prohibited for score at exactly -0.5' do
+      expect(evaluator.verdict(-0.5)).to eq(:prohibited)
+    end
+
+    it 'returns :cautioned for score between -0.5 and -0.1' do
+      expect(evaluator.verdict(-0.3)).to eq(:cautioned)
+    end
+
+    it 'returns :permitted for score above -0.1' do
+      expect(evaluator.verdict(0.0)).to eq(:permitted)
+    end
+
+    it 'returns :permitted for positive scores' do
+      expect(evaluator.verdict(0.5)).to eq(:permitted)
+    end
+  end
+
+  describe '#detect_dilemma' do
+    it 'returns nil when no conflict present' do
+      scores = { care: 0.5, fairness: 0.4, loyalty: 0.3, authority: 0.2, sanctity: 0.3, liberty: 0.4 }
+      expect(evaluator.detect_dilemma(scores)).to be_nil
+    end
+
+    it 'returns nil when all foundations agree negatively' do
+      scores = { care: -0.8, fairness: -0.7, loyalty: -0.6, authority: -0.5, sanctity: -0.6, liberty: -0.5 }
+      expect(evaluator.detect_dilemma(scores)).to be_nil
+    end
+
+    it 'returns a dilemma hash when care and fairness strongly disagree' do
+      scores = { care: 0.9, fairness: -0.8, loyalty: 0.1, authority: 0.1, sanctity: 0.1, liberty: 0.1 }
+      dilemma = evaluator.detect_dilemma(scores)
+      expect(dilemma).not_to be_nil
+      expect(dilemma).to include(:type, :approving, :opposing, :tension, :counter_tension, :detected_at)
+    end
+
+    it 'classifies care vs fairness conflict as :utilitarian' do
+      scores = { care: 0.9, fairness: -0.8, loyalty: 0.0, authority: 0.0, sanctity: 0.0, liberty: 0.0 }
+      dilemma = evaluator.detect_dilemma(scores)
+      expect(dilemma[:type]).to eq(:utilitarian)
+    end
+
+    it 'classifies authority conflict as :deontological' do
+      scores = { care: 0.0, fairness: 0.0, loyalty: 0.5, authority: -0.8, sanctity: 0.5, liberty: 0.0 }
+      dilemma = evaluator.detect_dilemma(scores)
+      expect(dilemma[:type]).to eq(:deontological)
+    end
+
+    it 'classifies loyalty vs sanctity conflict as :virtue_ethics' do
+      scores = { care: 0.0, fairness: 0.0, loyalty: 0.8, authority: 0.0, sanctity: -0.7, liberty: 0.0 }
+      dilemma = evaluator.detect_dilemma(scores)
+      expect(dilemma[:type]).to eq(:virtue_ethics)
+    end
+
+    it 'lists approving and opposing foundations' do
+      scores = { care: 0.9, fairness: -0.8, loyalty: 0.0, authority: 0.0, sanctity: 0.0, liberty: 0.0 }
+      dilemma = evaluator.detect_dilemma(scores)
+      expect(dilemma[:approving]).to include(:care)
+      expect(dilemma[:opposing]).to include(:fairness)
+    end
+  end
+
+  describe '#update_sensitivity' do
+    it 'adjusts sensitivity for a known foundation' do
+      original = evaluator.sensitivities[:care]
+      evaluator.update_sensitivity(:care, 0.9)
+      expect(evaluator.sensitivities[:care]).not_to eq(original)
+    end
+
+    it 'changes sensitivity by a small amount (slow EMA)' do
+      original = evaluator.sensitivities[:care]
+      evaluator.update_sensitivity(:care, 1.0)
+      diff = (evaluator.sensitivities[:care] - original).abs
+      expect(diff).to be <= Legion::Extensions::Agentic::Social::Conscience::Helpers::Constants::FOUNDATION_ALPHA + 0.001
+    end
+
+    it 'ignores unknown foundations without error' do
+      expect { evaluator.update_sensitivity(:unknown_foundation, 0.5) }.not_to raise_error
+    end
+
+    it 'clamps outcome magnitude to [0.0, 1.0] when updating' do
+      expect { evaluator.update_sensitivity(:care, 5.0) }.not_to raise_error
+      expect(evaluator.sensitivities[:care]).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe 'foundation-specific evaluation' do
+    it 'scores care positively when benefit_to_others is high' do
+      result = evaluator.evaluate(action: :help, context: { benefit_to_others: 1.0, harm_to_others: 0.0 })
+      expect(result[:scores][:care]).to be > 0.0
+    end
+
+    it 'scores care negatively when harm_to_others is high' do
+      result = evaluator.evaluate(action: :harm, context: { harm_to_others: 1.0, benefit_to_others: 0.0 })
+      expect(result[:scores][:care]).to be < 0.0
+    end
+
+    it 'penalizes care further when vulnerable_affected is true' do
+      without_vuln = evaluator.evaluate(action: :act, context: { harm_to_others: 0.5, vulnerable_affected: false })
+      with_vuln    = evaluator.evaluate(action: :act, context: { harm_to_others: 0.5, vulnerable_affected: true })
+      expect(with_vuln[:scores][:care]).to be < without_vuln[:scores][:care]
+    end
+
+    it 'scores liberty positively when consent_present is true' do
+      with_consent    = evaluator.evaluate(action: :act, context: { consent_present: true, autonomy_preservation: 0.5 })
+      without_consent = evaluator.evaluate(action: :act, context: { consent_present: false, autonomy_preservation: 0.5 })
+      expect(with_consent[:scores][:liberty]).to be > without_consent[:scores][:liberty]
+    end
+  end
+end