lex-agentic-social 0.1.0

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

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Conscience::Helpers::MoralStore do
+  subject(:store) { described_class.new }
+
+  let(:permitted_result) do
+    {
+      action:         :deploy_patch,
+      scores:         { care: 0.5, fairness: 0.4, loyalty: 0.3, authority: 0.2, sanctity: 0.4, liberty: 0.3 },
+      weighted_score: 0.38,
+      verdict:        :permitted,
+      dilemma:        nil,
+      sensitivities:  { care: 1.0, fairness: 1.0, loyalty: 1.0, authority: 1.0, sanctity: 1.0, liberty: 1.0 },
+      evaluated_at:   Time.now.utc
+    }
+  end
+
+  let(:cautioned_result) do
+    {
+      action:         :access_logs,
+      scores:         { care: -0.2, fairness: -0.1, loyalty: 0.1, authority: 0.2, sanctity: 0.0, liberty: -0.3 },
+      weighted_score: -0.06,
+      verdict:        :cautioned,
+      dilemma:        nil,
+      sensitivities:  { care: 1.0, fairness: 1.0, loyalty: 1.0, authority: 1.0, sanctity: 1.0, liberty: 1.0 },
+      evaluated_at:   Time.now.utc
+    }
+  end
+
+  let(:prohibited_result) do
+    {
+      action:         :delete_user_data,
+      scores:         { care: -0.9, fairness: -0.8, loyalty: -0.5, authority: -0.4, sanctity: -0.7, liberty: -0.6 },
+      weighted_score: -0.67,
+      verdict:        :prohibited,
+      dilemma:        nil,
+      sensitivities:  { care: 1.0, fairness: 1.0, loyalty: 1.0, authority: 1.0, sanctity: 1.0, liberty: 1.0 },
+      evaluated_at:   Time.now.utc
+    }
+  end
+
+  let(:dilemma_result) do
+    {
+      action:         :trade_off_action,
+      scores:         { care: 0.8, fairness: -0.7, loyalty: 0.1, authority: 0.0, sanctity: 0.0, liberty: 0.0 },
+      weighted_score: 0.06,
+      verdict:        :permitted,
+      dilemma:        {
+        type:            :utilitarian,
+        approving:       [:care],
+        opposing:        [:fairness],
+        tension:         0.8,
+        counter_tension: 0.7,
+        detected_at:     Time.now.utc
+      },
+      sensitivities:  { care: 1.0, fairness: 1.0, loyalty: 1.0, authority: 1.0, sanctity: 1.0, liberty: 1.0 },
+      evaluated_at:   Time.now.utc
+    }
+  end
+
+  describe '#initialize' do
+    it 'creates a default evaluator' do
+      expect(store.evaluator).to be_a(Legion::Extensions::Agentic::Social::Conscience::Helpers::MoralEvaluator)
+    end
+
+    it 'accepts an injected evaluator' do
+      custom_evaluator = Legion::Extensions::Agentic::Social::Conscience::Helpers::MoralEvaluator.new
+      s = described_class.new(evaluator: custom_evaluator)
+      expect(s.evaluator).to be(custom_evaluator)
+    end
+
+    it 'starts with empty history' do
+      expect(store.history).to be_empty
+    end
+
+    it 'starts with empty dilemmas' do
+      expect(store.dilemmas).to be_empty
+    end
+  end
+
+  describe '#record_evaluation' do
+    it 'adds to history' do
+      store.record_evaluation(permitted_result)
+      expect(store.history.size).to eq(1)
+    end
+
+    it 'returns the result unchanged' do
+      result = store.record_evaluation(permitted_result)
+      expect(result[:verdict]).to eq(:permitted)
+    end
+
+    it 'records dilemma when present' do
+      store.record_evaluation(dilemma_result)
+      expect(store.dilemmas.size).to eq(1)
+    end
+
+    it 'does not record dilemma when nil' do
+      store.record_evaluation(permitted_result)
+      expect(store.dilemmas).to be_empty
+    end
+
+    it 'caps history at MAX_MORAL_HISTORY' do
+      (Legion::Extensions::Agentic::Social::Conscience::Helpers::Constants::MAX_MORAL_HISTORY + 10).times { store.record_evaluation(permitted_result) }
+      expect(store.history.size).to eq(Legion::Extensions::Agentic::Social::Conscience::Helpers::Constants::MAX_MORAL_HISTORY)
+    end
+  end
+
+  describe '#record_follow_through' do
+    it 'increments followed_count on :followed outcome' do
+      store.record_follow_through(:permitted, :followed)
+      stats = store.aggregate_stats
+      expect(stats[:followed_count]).to eq(1)
+    end
+
+    it 'increments overridden_count on :overridden outcome' do
+      store.record_follow_through(:permitted, :overridden)
+      stats = store.aggregate_stats
+      expect(stats[:overridden_count]).to eq(1)
+    end
+
+    it 'calls update_sensitivity on the evaluator' do
+      expect(store.evaluator).to receive(:update_sensitivity).at_least(:once)
+      store.record_follow_through(:prohibited, :overridden)
+    end
+  end
+
+  describe '#consistency_score' do
+    it 'returns 1.0 with no history' do
+      expect(store.consistency_score).to eq(1.0)
+    end
+
+    it 'returns 1.0 when all verdicts are followed' do
+      3.times { store.record_follow_through(:permitted, :followed) }
+      expect(store.consistency_score).to eq(1.0)
+    end
+
+    it 'returns 0.5 when half are followed and half overridden' do
+      2.times { store.record_follow_through(:permitted, :followed) }
+      2.times { store.record_follow_through(:prohibited, :overridden) }
+      expect(store.consistency_score).to eq(0.5)
+    end
+
+    it 'returns a float between 0.0 and 1.0' do
+      5.times { store.record_follow_through(:permitted, :followed) }
+      3.times { store.record_follow_through(:cautioned, :overridden) }
+      expect(store.consistency_score).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#foundation_sensitivities' do
+    it 'returns sensitivities for all 6 foundations' do
+      expect(store.foundation_sensitivities.keys).to contain_exactly(
+        :care, :fairness, :loyalty, :authority, :sanctity, :liberty
+      )
+    end
+
+    it 'returns rounded float values' do
+      store.foundation_sensitivities.each_value do |s|
+        expect(s).to be_a(Float)
+      end
+    end
+  end
+
+  describe '#recent_evaluations' do
+    it 'returns empty array initially' do
+      expect(store.recent_evaluations).to be_empty
+    end
+
+    it 'returns most recent evaluations up to limit' do
+      5.times { store.record_evaluation(permitted_result) }
+      store.record_evaluation(cautioned_result)
+      recent = store.recent_evaluations(3)
+      expect(recent.size).to eq(3)
+    end
+
+    it 'returns the most recent entries when over limit' do
+      5.times { store.record_evaluation(permitted_result) }
+      2.times { store.record_evaluation(prohibited_result) }
+      recent = store.recent_evaluations(2)
+      expect(recent.all? { |e| e[:verdict] == :prohibited }).to be true
+    end
+  end
+
+  describe '#open_dilemmas' do
+    it 'returns empty when no dilemmas exist' do
+      store.record_evaluation(permitted_result)
+      expect(store.open_dilemmas).to be_empty
+    end
+
+    it 'returns dilemmas when they exist' do
+      store.record_evaluation(dilemma_result)
+      expect(store.open_dilemmas.size).to eq(1)
+    end
+  end
+
+  describe '#aggregate_stats' do
+    it 'returns empty stats structure when no history' do
+      stats = store.aggregate_stats
+      expect(stats[:total_evaluations]).to eq(0)
+      expect(stats[:consistency_score]).to eq(1.0)
+    end
+
+    it 'counts evaluations' do
+      3.times { store.record_evaluation(permitted_result) }
+      expect(store.aggregate_stats[:total_evaluations]).to eq(3)
+    end
+
+    it 'counts verdicts by type' do
+      2.times { store.record_evaluation(permitted_result) }
+      store.record_evaluation(cautioned_result)
+      store.record_evaluation(prohibited_result)
+      counts = store.aggregate_stats[:verdict_counts]
+      expect(counts[:permitted]).to eq(2)
+      expect(counts[:cautioned]).to eq(1)
+      expect(counts[:prohibited]).to eq(1)
+    end
+
+    it 'includes dilemma count' do
+      store.record_evaluation(dilemma_result)
+      expect(store.aggregate_stats[:dilemma_count]).to eq(1)
+    end
+
+    it 'includes foundation_sensitivities' do
+      stats = store.aggregate_stats
+      expect(stats[:foundation_sensitivities]).to include(:care, :fairness)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/conscience/runners/conscience_spec.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Conscience::Runners::Conscience do
+  let(:client) { Legion::Extensions::Agentic::Social::Conscience::Client.new }
+
+  let(:benign_context) do
+    {
+      harm_to_others:                  0.0,
+      benefit_to_others:               0.8,
+      vulnerable_affected:             false,
+      distributional_justice:          0.6,
+      reciprocity:                     0.5,
+      proportionality:                 0.4,
+      alignment_with_group_norms:      0.5,
+      trust_preservation:              0.6,
+      legitimate_authority_compliance: 0.4,
+      hierarchy_respect:               0.3,
+      system_integrity:                0.7,
+      degradation_prevention:          0.6,
+      autonomy_preservation:           0.5,
+      consent_present:                 true
+    }
+  end
+
+  let(:harmful_context) do
+    {
+      harm_to_others:                  0.9,
+      benefit_to_others:               0.0,
+      vulnerable_affected:             true,
+      distributional_justice:          -0.7,
+      reciprocity:                     -0.6,
+      proportionality:                 -0.5,
+      alignment_with_group_norms:      -0.4,
+      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:                 false
+    }
+  end
+
+  describe '#moral_evaluate' do
+    it 'returns a hash with required keys' do
+      result = client.moral_evaluate(action: :deploy_patch, context: benign_context)
+      expect(result).to include(:action, :scores, :weighted_score, :verdict, :dilemma, :sensitivities, :evaluated_at)
+    end
+
+    it 'returns :permitted for benign action' do
+      result = client.moral_evaluate(action: :deploy_patch, context: benign_context)
+      expect(result[:verdict]).to eq(:permitted)
+    end
+
+    it 'returns :prohibited for harmful action' do
+      result = client.moral_evaluate(action: :delete_user_data, context: harmful_context)
+      expect(result[:verdict]).to eq(:prohibited)
+    end
+
+    it 'records evaluation in moral store history' do
+      client.moral_evaluate(action: :test_action, context: benign_context)
+      expect(client.moral_store.history.size).to eq(1)
+    end
+
+    it 'handles empty context without error' do
+      expect { client.moral_evaluate(action: :test) }.not_to raise_error
+    end
+
+    it 'accepts extra kwargs via ** splat' do
+      expect { client.moral_evaluate(action: :test, context: {}, extra_param: true) }.not_to raise_error
+    end
+
+    it 'returns all 6 foundation scores' do
+      result = client.moral_evaluate(action: :test, context: {})
+      expect(result[:scores].keys).to contain_exactly(:care, :fairness, :loyalty, :authority, :sanctity, :liberty)
+    end
+  end
+
+  describe '#moral_status' do
+    it 'returns status with required keys' do
+      status = client.moral_status
+      expect(status).to include(:sensitivities, :consistency, :stats)
+    end
+
+    it 'includes all 6 foundation sensitivities' do
+      status = client.moral_status
+      expect(status[:sensitivities].keys).to contain_exactly(
+        :care, :fairness, :loyalty, :authority, :sanctity, :liberty
+      )
+    end
+
+    it 'includes consistency score of 1.0 initially' do
+      status = client.moral_status
+      expect(status[:consistency]).to eq(1.0)
+    end
+
+    it 'accepts extra kwargs via ** splat' do
+      expect { client.moral_status(extra: true) }.not_to raise_error
+    end
+  end
+
+  describe '#moral_history' do
+    it 'returns empty history initially' do
+      result = client.moral_history
+      expect(result[:history]).to be_empty
+      expect(result[:total]).to eq(0)
+    end
+
+    it 'returns history after evaluations' do
+      3.times { client.moral_evaluate(action: :test, context: benign_context) }
+      result = client.moral_history
+      expect(result[:history].size).to eq(3)
+      expect(result[:total]).to eq(3)
+    end
+
+    it 'respects limit parameter' do
+      10.times { client.moral_evaluate(action: :test, context: benign_context) }
+      result = client.moral_history(limit: 4)
+      expect(result[:history].size).to eq(4)
+    end
+
+    it 'includes limit in response' do
+      result = client.moral_history(limit: 5)
+      expect(result[:limit]).to eq(5)
+    end
+
+    it 'accepts extra kwargs via ** splat' do
+      expect { client.moral_history(limit: 5, extra: true) }.not_to raise_error
+    end
+  end
+
+  describe '#update_moral_outcome' do
+    before do
+      client.moral_evaluate(action: :deploy_patch, context: benign_context)
+    end
+
+    it 'returns a hash with required keys' do
+      result = client.update_moral_outcome(action: :deploy_patch, outcome: :followed)
+      expect(result).to include(:action, :verdict, :outcome, :consistency)
+    end
+
+    it 'records followed outcome correctly' do
+      client.update_moral_outcome(action: :deploy_patch, outcome: :followed)
+      expect(client.moral_store.consistency_score).to eq(1.0)
+    end
+
+    it 'records overridden outcome correctly' do
+      client.moral_evaluate(action: :delete_data, context: harmful_context)
+      client.update_moral_outcome(action: :delete_data, verdict: :prohibited, outcome: :overridden)
+      stats = client.moral_store.aggregate_stats
+      expect(stats[:overridden_count]).to eq(1)
+    end
+
+    it 'accepts explicit verdict override' do
+      result = client.update_moral_outcome(action: :any, outcome: :followed, verdict: :cautioned)
+      expect(result[:verdict]).to eq(:cautioned)
+    end
+
+    it 'accepts extra kwargs via ** splat' do
+      expect { client.update_moral_outcome(action: :test, outcome: :followed, meta: 'ok') }.not_to raise_error
+    end
+  end
+
+  describe '#moral_dilemmas' do
+    it 'returns empty dilemmas initially' do
+      result = client.moral_dilemmas
+      expect(result[:dilemmas]).to be_empty
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns dilemmas when foundations conflict strongly' do
+      # Force a dilemma by evaluating a context where care strongly approves but fairness strongly disapproves
+      conflicted = {
+        harm_to_others:         0.0,
+        benefit_to_others:      1.0,    # care +
+        distributional_justice: -0.9,   # fairness -
+        reciprocity:            -0.9,
+        proportionality:        -0.9
+      }
+      client.moral_evaluate(action: :conflicted_action, context: conflicted)
+      result = client.moral_dilemmas
+      # May or may not produce a dilemma depending on computed scores; just verify structure
+      expect(result).to include(:dilemmas, :count)
+    end
+
+    it 'accepts extra kwargs via ** splat' do
+      expect { client.moral_dilemmas(extra: true) }.not_to raise_error
+    end
+  end
+
+  describe '#conscience_stats' do
+    it 'returns aggregate stats with required keys' do
+      client.moral_evaluate(action: :test, context: benign_context)
+      stats = client.conscience_stats
+      expect(stats).to include(:total_evaluations, :verdict_counts, :dilemma_count,
+                               :consistency_score, :verdict_distribution, :foundation_weights)
+    end
+
+    it 'includes foundation weights matching constants' do
+      stats = client.conscience_stats
+      expected_weights = Legion::Extensions::Agentic::Social::Conscience::Helpers::Constants::MORAL_FOUNDATIONS.transform_values { |v| v[:weight] }
+      expect(stats[:foundation_weights]).to eq(expected_weights)
+    end
+
+    it 'verdict_distribution sums to 1.0 when evaluations exist' do
+      3.times { client.moral_evaluate(action: :test, context: benign_context) }
+      stats = client.conscience_stats
+      total = stats[:verdict_distribution].values.sum
+      expect(total).to be_within(0.001).of(1.0)
+    end
+
+    it 'verdict_distribution is empty when no evaluations' do
+      stats = client.conscience_stats
+      expect(stats[:verdict_distribution]).to be_empty
+    end
+
+    it 'accepts extra kwargs via ** splat' do
+      expect { client.conscience_stats(extra: true) }.not_to raise_error
+    end
+  end
+
+  describe 'moral consistency tracking' do
+    it 'consistency decreases when prohibited verdicts are overridden' do
+      client.moral_evaluate(action: :bad_action, context: harmful_context)
+      client.update_moral_outcome(action: :bad_action, verdict: :prohibited, outcome: :overridden)
+      expect(client.moral_status[:consistency]).to be < 1.0
+    end
+
+    it 'consistency stays at 1.0 when all verdicts are followed' do
+      5.times do
+        client.moral_evaluate(action: :good_action, context: benign_context)
+        client.update_moral_outcome(action: :good_action, outcome: :followed)
+      end
+      expect(client.moral_status[:consistency]).to eq(1.0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/consent/actors/tier_evaluation_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Stub the base class before loading the actor
+module Legion
+  module Extensions
+    module Actors
+      class Every; end # rubocop:disable Lint/EmptyClass
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require_relative '../../../../../../../lib/legion/extensions/agentic/social/consent/actors/tier_evaluation'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Consent::Actor::TierEvaluation do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it { expect(actor.runner_class).to eq Legion::Extensions::Agentic::Social::Consent::Runners::Consent }
+  end
+
+  describe '#runner_function' do
+    it { expect(actor.runner_function).to eq 'evaluate_and_apply_tiers' }
+  end
+
+  describe '#time' do
+    it { expect(actor.time).to eq 3600 }
+  end
+
+  describe '#run_now?' do
+    it { expect(actor.run_now?).to be false }
+  end
+
+  describe '#use_runner?' do
+    it { expect(actor.use_runner?).to be false }
+  end
+
+  describe '#check_subtask?' do
+    it { expect(actor.check_subtask?).to be false }
+  end
+
+  describe '#generate_task?' do
+    it { expect(actor.generate_task?).to be false }
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/consent/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Consent::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to consent runner methods' do
+    expect(client).to respond_to(:check_consent)
+    expect(client).to respond_to(:record_action)
+    expect(client).to respond_to(:evaluate_tier_change)
+    expect(client).to respond_to(:apply_tier_change)
+    expect(client).to respond_to(:consent_status)
+  end
+
+  it 'round-trips earned autonomy lifecycle' do
+    # Start with consult
+    check = client.check_consent(domain: 'scheduling')
+    expect(check[:tier]).to eq(:consult)
+
+    # Build track record
+    12.times { client.record_action(domain: 'scheduling', success: true) }
+
+    # Evaluate
+    eval_result = client.evaluate_tier_change(domain: 'scheduling')
+    expect(eval_result[:recommendation]).to eq(:promote)
+
+    # Apply
+    client.apply_tier_change(domain: 'scheduling', new_tier: eval_result[:proposed_tier])
+    check = client.check_consent(domain: 'scheduling')
+    expect(check[:tier]).to eq(:act_notify)
+  end
+end

data/spec/legion/extensions/agentic/social/consent/helpers/tiers_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Consent::Helpers::Tiers do
+  describe '.valid_tier?' do
+    it 'accepts valid tiers' do
+      %i[autonomous act_notify consult human_only].each do |tier|
+        expect(described_class.valid_tier?(tier)).to be true
+      end
+    end
+
+    it 'rejects invalid tiers' do
+      expect(described_class.valid_tier?(:invalid)).to be false
+    end
+  end
+
+  describe '.promote' do
+    it 'promotes consult to act_notify' do
+      expect(described_class.promote(:consult)).to eq(:act_notify)
+    end
+
+    it 'promotes act_notify to autonomous' do
+      expect(described_class.promote(:act_notify)).to eq(:autonomous)
+    end
+
+    it 'cannot promote beyond autonomous' do
+      expect(described_class.promote(:autonomous)).to eq(:autonomous)
+    end
+  end
+
+  describe '.demote' do
+    it 'demotes consult to human_only' do
+      expect(described_class.demote(:consult)).to eq(:human_only)
+    end
+
+    it 'cannot demote beyond human_only' do
+      expect(described_class.demote(:human_only)).to eq(:human_only)
+    end
+  end
+
+  describe '.more_autonomous?' do
+    it 'returns true when first tier is more autonomous' do
+      expect(described_class.more_autonomous?(:autonomous, :consult)).to be true
+    end
+
+    it 'returns false when second tier is more autonomous' do
+      expect(described_class.more_autonomous?(:human_only, :consult)).to be false
+    end
+  end
+end