lex-agentic-social 0.1.0

data/lib/legion/extensions/agentic/social/conscience/helpers/moral_store.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Conscience
+          module Helpers
+            class MoralStore
+              attr_reader :evaluator, :history, :dilemmas, :sensitivity_snapshots
+
+              def initialize(evaluator: nil)
+                @evaluator            = evaluator || MoralEvaluator.new
+                @history              = []
+                @dilemmas             = []
+                @sensitivity_snapshots = []
+                @followed_count       = 0
+                @overridden_count     = 0
+              end
+
+              # Store a completed moral evaluation result
+              def record_evaluation(result)
+                @history << result
+                @history.shift while @history.size > Constants::MAX_MORAL_HISTORY
+
+                @dilemmas << result[:dilemma] if result[:dilemma]
+
+                snapshot_sensitivities(result[:verdict])
+
+                result
+              end
+
+              # Record whether the agent followed its moral verdict or overrode it.
+              # outcome: :followed | :overridden
+              def record_follow_through(verdict, outcome)
+                if outcome == :followed
+                  @followed_count += 1
+                else
+                  @overridden_count += 1
+                end
+
+                # Feed back into evaluator sensitivities
+                foundation_feedback(verdict, outcome)
+              end
+
+              # Ratio of evaluations where the agent followed its moral verdict
+              def consistency_score
+                total = @followed_count + @overridden_count
+                return 1.0 if total.zero?
+
+                (@followed_count.to_f / total).round(4)
+              end
+
+              # Current foundation sensitivities from the evaluator
+              def foundation_sensitivities
+                @evaluator.sensitivities.transform_values { |s| s.round(4) }
+              end
+
+              # Recent evaluations, newest last
+              def recent_evaluations(limit = 20)
+                @history.last(limit)
+              end
+
+              # Open dilemmas (not yet resolved)
+              def open_dilemmas
+                @dilemmas.last(20)
+              end
+
+              # Aggregate stats across all evaluations
+              def aggregate_stats
+                verdict_counts = Hash.new(0)
+                @history.each { |e| verdict_counts[e[:verdict]] += 1 }
+
+                {
+                  total_evaluations:        @history.size,
+                  verdict_counts:           verdict_counts,
+                  dilemma_count:            @dilemmas.size,
+                  consistency_score:        consistency_score,
+                  followed_count:           @followed_count,
+                  overridden_count:         @overridden_count,
+                  foundation_sensitivities: foundation_sensitivities
+                }
+              end
+
+              private
+
+              def snapshot_sensitivities(verdict)
+                @sensitivity_snapshots << {
+                  verdict:       verdict,
+                  sensitivities: @evaluator.sensitivities.dup,
+                  at:            Time.now.utc
+                }
+                @sensitivity_snapshots.shift while @sensitivity_snapshots.size > Constants::MAX_MORAL_HISTORY
+              end
+
+              def foundation_feedback(verdict, outcome)
+                # When an agent overrides a prohibited verdict, desensitize authority/sanctity
+                # When an agent follows a cautioned verdict, sensitize care/fairness
+                case [verdict, outcome]
+                when %i[prohibited overridden]
+                  @evaluator.update_sensitivity(:care, -0.5)
+                  @evaluator.update_sensitivity(:sanctity, -0.3)
+                when %i[cautioned followed]
+                  @evaluator.update_sensitivity(:care, 0.8)
+                  @evaluator.update_sensitivity(:fairness, 0.6)
+                when %i[permitted followed]
+                  @evaluator.update_sensitivity(:liberty, 0.7)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Conscience
+          module Runners
+            module Conscience
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              # Full moral assessment of a proposed action.
+              # action: string or symbol describing what is about to happen
+              # context: hash of moral context signals (harm_to_others, consent_present, etc.)
+              def moral_evaluate(action:, context: {}, **)
+                result = moral_store.evaluator.evaluate(action: action, context: context)
+                moral_store.record_evaluation(result)
+
+                Legion::Logging.debug "[conscience] action=#{action} verdict=#{result[:verdict]} " \
+                                      "score=#{result[:weighted_score]} dilemma=#{result[:dilemma]&.dig(:type)}"
+
+                result
+              end
+
+              # Current moral sensitivities and consistency score
+              def moral_status(**)
+                stats = moral_store.aggregate_stats
+                sensitivities = moral_store.foundation_sensitivities
+
+                Legion::Logging.debug "[conscience] consistency=#{stats[:consistency_score]} " \
+                                      "evaluations=#{stats[:total_evaluations]}"
+
+                {
+                  sensitivities: sensitivities,
+                  consistency:   stats[:consistency_score],
+                  stats:         stats
+                }
+              end
+
+              # Recent moral evaluation history
+              def moral_history(limit: 20, **)
+                recent = moral_store.recent_evaluations(limit)
+                Legion::Logging.debug "[conscience] history: #{recent.size} entries"
+
+                {
+                  history: recent,
+                  total:   moral_store.history.size,
+                  limit:   limit
+                }
+              end
+
+              # Record whether the agent actually followed or overrode its moral verdict.
+              # outcome: :followed | :overridden
+              def update_moral_outcome(action:, outcome:, verdict: nil, **)
+                effective_verdict = verdict || infer_last_verdict(action)
+
+                moral_store.record_follow_through(effective_verdict, outcome)
+
+                Legion::Logging.debug "[conscience] follow_through action=#{action} " \
+                                      "verdict=#{effective_verdict} outcome=#{outcome} " \
+                                      "consistency=#{moral_store.consistency_score}"
+
+                {
+                  action:      action,
+                  verdict:     effective_verdict,
+                  outcome:     outcome,
+                  consistency: moral_store.consistency_score
+                }
+              end
+
+              # List unresolved moral dilemmas (cases where foundations strongly disagreed)
+              def moral_dilemmas(**)
+                open = moral_store.open_dilemmas
+                Legion::Logging.debug "[conscience] dilemmas: #{open.size} open"
+
+                {
+                  dilemmas: open,
+                  count:    open.size
+                }
+              end
+
+              # Aggregate moral reasoning stats
+              def conscience_stats(**)
+                stats = moral_store.aggregate_stats
+                Legion::Logging.debug '[conscience] stats'
+
+                stats.merge(
+                  verdict_distribution: verdict_distribution(stats[:verdict_counts]),
+                  foundation_weights:   Helpers::Constants::MORAL_FOUNDATIONS.transform_values { |v| v[:weight] }
+                )
+              end
+
+              private
+
+              def moral_store
+                @moral_store ||= Helpers::MoralStore.new
+              end
+
+              def infer_last_verdict(action)
+                last = moral_store.history.reverse.find { |e| e[:action] == action }
+                last ? last[:verdict] : :permitted
+              end
+
+              def verdict_distribution(verdict_counts)
+                total = verdict_counts.values.sum.to_f
+                return {} if total.zero?
+
+                verdict_counts.transform_values { |count| (count / total).round(4) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Conscience
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/conscience/version'
+require 'legion/extensions/agentic/social/conscience/helpers/constants'
+require 'legion/extensions/agentic/social/conscience/helpers/moral_evaluator'
+require 'legion/extensions/agentic/social/conscience/helpers/moral_store'
+require 'legion/extensions/agentic/social/conscience/runners/conscience'
+require 'legion/extensions/agentic/social/conscience/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Conscience
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/consent/actors/tier_evaluation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Consent
+          module Actor
+            class TierEvaluation < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Social::Consent::Runners::Consent
+              end
+
+              def runner_function
+                'evaluate_and_apply_tiers'
+              end
+
+              def time
+                3600
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/consent/client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/consent/helpers/tiers'
+require 'legion/extensions/agentic/social/consent/helpers/consent_map'
+require 'legion/extensions/agentic/social/consent/runners/consent'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Consent
+          class Client
+            include Runners::Consent
+
+            def initialize(**)
+              @consent_map = Helpers::ConsentMap.new
+            end
+
+            private
+
+            attr_reader :consent_map
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Consent
+          module Helpers
+            class ConsentMap
+              APPROVAL_TIMEOUT = 259_200 # 72 hours
+
+              attr_reader :domains
+
+              def initialize
+                @domains = Hash.new do |h, k|
+                  h[k] = {
+                    tier:                 Tiers::DEFAULT_TIER,
+                    success_count:        0,
+                    failure_count:        0,
+                    total_actions:        0,
+                    last_changed_at:      nil,
+                    history:              [],
+                    pending_tier:         nil,
+                    pending_since:        nil,
+                    pending_requested_by: nil
+                  }
+                end
+                load_from_local
+              end
+
+              def get_tier(domain)
+                @domains[domain][:tier]
+              end
+
+              def set_tier(domain, tier)
+                return unless Tiers.valid_tier?(tier)
+
+                entry = @domains[domain]
+                old_tier = entry[:tier]
+                entry[:tier] = tier
+                entry[:last_changed_at] = Time.now.utc
+                entry[:history] << { from: old_tier, to: tier, at: Time.now.utc }
+                entry[:history].shift while entry[:history].size > 50
+              end
+
+              def record_outcome(domain, success:)
+                entry = @domains[domain]
+                entry[:total_actions] += 1
+                if success
+                  entry[:success_count] += 1
+                else
+                  entry[:failure_count] += 1
+                end
+              end
+
+              def success_rate(domain)
+                entry = @domains[domain]
+                return 0.0 if entry[:total_actions].zero?
+
+                entry[:success_count].to_f / entry[:total_actions]
+              end
+
+              def eligible_for_change?(domain)
+                entry = @domains[domain]
+                return false if entry[:total_actions] < Tiers::MIN_ACTIONS_TO_PROMOTE
+
+                if entry[:last_changed_at]
+                  (Time.now.utc - entry[:last_changed_at]) >= Tiers::PROMOTION_COOLDOWN
+                else
+                  true
+                end
+              end
+
+              def evaluate_promotion(domain)
+                return :ineligible unless eligible_for_change?(domain)
+
+                rate = success_rate(domain)
+                current = get_tier(domain)
+
+                if rate >= Tiers::PROMOTION_THRESHOLD
+                  promoted = Tiers.promote(current)
+                  return :already_max if promoted == current
+
+                  :promote
+                elsif rate < Tiers::DEMOTION_THRESHOLD
+                  demoted = Tiers.demote(current)
+                  return :already_min if demoted == current
+
+                  :demote
+                else
+                  :maintain
+                end
+              end
+
+              def domain_count
+                @domains.size
+              end
+
+              def to_h
+                @domains.transform_values do |v|
+                  { tier: v[:tier], success_rate: success_rate_from(v), total_actions: v[:total_actions],
+                    pending_tier: v[:pending_tier], pending_since: v[:pending_since] }
+                end
+              end
+
+              def set_pending(domain, proposed_tier:, requested_by: 'system')
+                entry = @domains[domain]
+                entry[:pending_tier] = proposed_tier
+                entry[:pending_since] = Time.now
+                entry[:pending_requested_by] = requested_by
+                entry
+              end
+
+              def clear_pending(domain)
+                entry = @domains[domain]
+                entry[:pending_tier] = nil
+                entry[:pending_since] = nil
+                entry[:pending_requested_by] = nil
+                entry
+              end
+
+              def pending?(domain)
+                !@domains[domain][:pending_tier].nil?
+              end
+
+              def pending_expired?(domain, timeout: APPROVAL_TIMEOUT)
+                entry = @domains[domain]
+                return false unless entry[:pending_since]
+
+                Time.now - entry[:pending_since] > timeout
+              end
+
+              def save_to_local
+                return unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
+
+                dataset = Legion::Data::Local.connection[:consent_domains]
+                @domains.each do |domain_key, entry|
+                  row = {
+                    domain_key:      domain_key,
+                    tier:            entry[:tier].to_s,
+                    success_count:   entry[:success_count],
+                    failure_count:   entry[:failure_count],
+                    total_actions:   entry[:total_actions],
+                    last_changed_at: entry[:last_changed_at],
+                    history:         ::JSON.generate(entry[:history].map { |h| h.transform_values(&:to_s) })
+                  }
+                  existing = dataset.where(domain_key: domain_key).first
+                  if existing
+                    dataset.where(domain_key: domain_key).update(row.except(:domain_key))
+                  else
+                    dataset.insert(row)
+                  end
+                end
+              rescue StandardError => e
+                Legion::Logging.warn "[consent] save_to_local failed: #{e.message}" if defined?(Legion::Logging)
+              end
+
+              def load_from_local
+                return unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
+
+                Legion::Data::Local.connection[:consent_domains].each do |row|
+                  key = row[:domain_key]
+                  history = begin
+                    ::JSON.parse(row[:history] || '[]', symbolize_names: false).map do |h|
+                      { from: h['from'].to_sym, to: h['to'].to_sym, at: h['at'] }
+                    end
+                  rescue StandardError
+                    []
+                  end
+
+                  @domains[key] = {
+                    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}" if defined?(Legion::Logging)
+              end
+
+              private
+
+              def success_rate_from(entry)
+                return 0.0 if entry[:total_actions].zero?
+
+                entry[:success_count].to_f / entry[:total_actions]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Consent
+          module Helpers
+            module Tiers
+              # Four consent tiers (spec: consent-gradient-spec.md)
+              TIERS = %i[autonomous act_notify consult human_only].freeze
+
+              # Default starting tier for new domains
+              DEFAULT_TIER = :consult
+
+              # Thresholds for tier promotion/demotion
+              PROMOTION_THRESHOLD   = 0.8  # success rate needed to promote
+              DEMOTION_THRESHOLD    = 0.5  # success rate below which demotion occurs
+              MIN_ACTIONS_TO_PROMOTE = 10  # minimum actions before tier change
+              PROMOTION_COOLDOWN = 86_400 # seconds between tier changes (24h)
+
+              # Tier ordering (lower index = more autonomy)
+              TIER_ORDER = { autonomous: 0, act_notify: 1, consult: 2, human_only: 3 }.freeze
+
+              module_function
+
+              def valid_tier?(tier)
+                TIERS.include?(tier)
+              end
+
+              def more_autonomous?(tier_a, tier_b)
+                TIER_ORDER.fetch(tier_a, 99) < TIER_ORDER.fetch(tier_b, 99)
+              end
+
+              def promote(current_tier)
+                idx = TIER_ORDER.fetch(current_tier, 2)
+                return current_tier if idx.zero?
+
+                TIER_ORDER.key(idx - 1) || current_tier
+              end
+
+              def demote(current_tier)
+                idx = TIER_ORDER.fetch(current_tier, 2)
+                return current_tier if idx >= 3
+
+                TIER_ORDER.key(idx + 1) || current_tier
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/consent/local_migrations/20260316000010_create_consent_domains.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table(:consent_domains) do
+      primary_key :id
+      String :domain_key, null: false, unique: true, index: true
+      String :tier, null: false, default: 'consult'
+      Integer :success_count, default: 0
+      Integer :failure_count, default: 0
+      Integer :total_actions, default: 0
+      DateTime :last_changed_at
+      String :history, text: true
+    end
+  end
+end