lex-agentic-social 0.1.0

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Consent
+          module Runners
+            module Consent
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def check_consent(domain:, _action_type: :general, **)
+                tier = consent_map.get_tier(domain)
+                Legion::Logging.debug "[consent] check: domain=#{domain} tier=#{tier} allowed=#{tier == :autonomous}"
+
+                {
+                  domain:        domain,
+                  tier:          tier,
+                  allowed:       tier == :autonomous,
+                  needs_notify:  tier == :act_notify,
+                  needs_consult: tier == :consult,
+                  human_only:    tier == :human_only
+                }
+              end
+
+              def record_action(domain:, success:, **)
+                consent_map.record_outcome(domain, success: success)
+                rate = consent_map.success_rate(domain)
+                total = consent_map.domains[domain][:total_actions]
+                Legion::Logging.info "[consent] action recorded: domain=#{domain} success=#{success} rate=#{rate.round(2)} total=#{total}"
+
+                {
+                  domain:       domain,
+                  success:      success,
+                  success_rate: rate,
+                  total:        total
+                }
+              end
+
+              def evaluate_tier_change(domain:, **)
+                recommendation = consent_map.evaluate_promotion(domain)
+                current = consent_map.get_tier(domain)
+
+                result = {
+                  domain:         domain,
+                  current_tier:   current,
+                  recommendation: recommendation,
+                  success_rate:   consent_map.success_rate(domain)
+                }
+
+                case recommendation
+                when :promote
+                  result[:proposed_tier] = Helpers::Tiers.promote(current)
+                  Legion::Logging.info "[consent] tier change: domain=#{domain} recommend=promote from=#{current} to=#{result[:proposed_tier]}"
+                when :demote
+                  result[:proposed_tier] = Helpers::Tiers.demote(current)
+                  Legion::Logging.warn "[consent] tier change: domain=#{domain} recommend=demote from=#{current} to=#{result[:proposed_tier]}"
+                else
+                  Legion::Logging.debug "[consent] tier eval: domain=#{domain} current=#{current} recommendation=#{recommendation}"
+                end
+
+                result
+              end
+
+              def apply_tier_change(domain:, new_tier:, **)
+                return { error: :invalid_tier, valid_tiers: Helpers::Tiers::TIERS } unless Helpers::Tiers.valid_tier?(new_tier)
+
+                old_tier = consent_map.get_tier(domain)
+                consent_map.set_tier(domain, new_tier)
+                changed = old_tier != new_tier
+                Legion::Logging.info "[consent] tier applied: domain=#{domain} old=#{old_tier} new=#{new_tier} changed=#{changed}"
+                { domain: domain, old_tier: old_tier, new_tier: new_tier, changed: changed }
+              end
+
+              def evaluate_all_tiers(**)
+                promotions = []
+                demotions = []
+
+                consent_map.domains.each_key do |domain|
+                  result = consent_map.evaluate_promotion(domain)
+                  promotions << domain if result == :promote
+                  demotions << domain if result == :demote
+                end
+
+                evaluated = consent_map.domain_count
+                Legion::Logging.debug "[consent] tier evaluation sweep: domains=#{evaluated} " \
+                                      "promotions=#{promotions.size} demotions=#{demotions.size}"
+
+                { evaluated: evaluated, promotions: promotions, demotions: demotions }
+              end
+
+              def request_autonomous_approval(domain:, **)
+                map = consent_map
+                current_tier = map.get_tier(domain)
+
+                return { requested: false, error: 'already_autonomous' } if current_tier == :autonomous
+                return { requested: false, error: 'already_pending' } if map.pending?(domain)
+
+                map.set_pending(domain, proposed_tier: :autonomous, requested_by: 'tier_evaluation')
+
+                if defined?(Legion::Events)
+                  rate = map.success_rate(domain)
+                  total = map.domains[domain][:total_actions]
+                  Legion::Events.emit('consent.approval_required', {
+                                        domain:        domain,
+                                        current_tier:  current_tier,
+                                        proposed_tier: :autonomous,
+                                        success_rate:  rate,
+                                        total_actions: total,
+                                        requested_at:  Time.now.utc
+                                      })
+                end
+
+                { requested: true, domain: domain, current_tier: current_tier, proposed_tier: :autonomous }
+              end
+
+              def approve_promotion(domain:, approved_by:, **)
+                map = consent_map
+                return { approved: false, error: 'no_pending_approval' } unless map.pending?(domain)
+
+                pending_tier = map.domains[domain][:pending_tier]
+                old_tier = map.get_tier(domain)
+                map.clear_pending(domain)
+                map.set_tier(domain, pending_tier)
+
+                if defined?(Legion::Events)
+                  Legion::Events.emit('consent.promotion_approved', {
+                                        domain: domain, old_tier: old_tier, new_tier: pending_tier,
+                                        approved_by: approved_by, at: Time.now.utc
+                                      })
+                end
+
+                { approved: true, domain: domain, old_tier: old_tier, new_tier: pending_tier, approved_by: approved_by }
+              end
+
+              def reject_promotion(domain:, rejected_by:, reason: nil, **)
+                map = consent_map
+                return { rejected: false, error: 'no_pending_approval' } unless map.pending?(domain)
+
+                map.clear_pending(domain)
+
+                if defined?(Legion::Events)
+                  Legion::Events.emit('consent.promotion_rejected', {
+                                        domain: domain, rejected_by: rejected_by, reason: reason, at: Time.now.utc
+                                      })
+                end
+
+                { rejected: true, domain: domain, rejected_by: rejected_by, reason: reason }
+              end
+
+              def expire_pending_approvals(timeout: Helpers::ConsentMap::APPROVAL_TIMEOUT, **)
+                map = consent_map
+                expired = 0
+
+                map.domains.each_key do |domain|
+                  next unless map.pending?(domain)
+                  next unless map.pending_expired?(domain, timeout: timeout)
+
+                  map.clear_pending(domain)
+                  expired += 1
+                end
+
+                { expired: expired }
+              end
+
+              def evaluate_and_apply_tiers(**)
+                candidates = evaluate_all_tiers
+                applied_promotions = 0
+                applied_demotions = 0
+                approval_requests = 0
+
+                Array(candidates[:promotions]).each do |domain|
+                  current = consent_map.get_tier(domain)
+                  proposed = Helpers::Tiers.promote(current)
+
+                  if proposed == :autonomous
+                    result = request_autonomous_approval(domain: domain)
+                    approval_requests += 1 if result[:requested]
+                  else
+                    apply_tier_change(domain: domain, new_tier: proposed)
+                    applied_promotions += 1
+                  end
+                end
+
+                Array(candidates[:demotions]).each do |domain|
+                  current = consent_map.get_tier(domain)
+                  proposed = Helpers::Tiers.demote(current)
+                  apply_tier_change(domain: domain, new_tier: proposed)
+                  applied_demotions += 1
+                end
+
+                expired = expire_pending_approvals
+
+                { evaluated: candidates[:evaluated], applied_promotions: applied_promotions,
+                  applied_demotions: applied_demotions, approval_requests: approval_requests,
+                  expired_approvals: expired[:expired] }
+              end
+
+              def consent_status(domain: nil, **)
+                if domain
+                  entry = consent_map.domains[domain]
+                  Legion::Logging.debug "[consent] status: domain=#{domain} tier=#{entry[:tier]} total=#{entry[:total_actions]}"
+                  {
+                    domain:       domain,
+                    tier:         entry[:tier],
+                    success_rate: consent_map.success_rate(domain),
+                    total:        entry[:total_actions],
+                    eligible:     consent_map.eligible_for_change?(domain)
+                  }
+                else
+                  Legion::Logging.debug "[consent] status: domains=#{consent_map.domain_count}"
+                  { domains: consent_map.to_h, count: consent_map.domain_count }
+                end
+              end
+
+              private
+
+              def consent_map
+                @consent_map ||= Helpers::ConsentMap.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/consent/version'
+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'
+require 'legion/extensions/agentic/social/consent/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Consent
+        end
+      end
+    end
+
+    if defined?(Legion::Data::Local)
+      Legion::Data::Local.register_migrations(
+        name: :consent,
+        path: File.join(__dir__, 'consent', 'local_migrations')
+      )
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Entrainment
+          class Client
+            include Runners::CognitiveEntrainment
+
+            def initialize(engine: nil)
+              @engine = engine || Helpers::EntrainmentEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/entrainment/helpers/constants.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Entrainment
+          module Helpers
+            module Constants
+              MAX_PAIRINGS = 200
+              MAX_SIGNALS = 500
+              MAX_HISTORY = 300
+
+              DEFAULT_SYNC = 0.0
+              SYNC_FLOOR = 0.0
+              SYNC_CEILING = 1.0
+
+              COUPLING_RATE = 0.1
+              DECOUPLING_RATE = 0.05
+              NATURAL_DRIFT = 0.02
+
+              ENTRAINED_THRESHOLD = 0.7
+              PARTIAL_THRESHOLD = 0.4
+
+              SYNC_LABELS = {
+                (0.8..)     => :locked,
+                (0.6...0.8) => :entrained,
+                (0.4...0.6) => :partial,
+                (0.2...0.4) => :drifting,
+                (..0.2)     => :independent
+              }.freeze
+
+              SIGNAL_TYPES = %i[rhythm timing phase amplitude].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/entrainment/helpers/entrainment_engine.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Entrainment
+          module Helpers
+            class EntrainmentEngine
+              include Constants
+
+              attr_reader :history
+
+              def initialize
+                @pairings = {}
+                @history  = []
+              end
+
+              def create_pairing(agent_a:, agent_b:, domain:)
+                evict_oldest if @pairings.size >= MAX_PAIRINGS
+
+                existing = find_pairing(agent_a: agent_a, agent_b: agent_b, domain: domain)
+                return existing if existing
+
+                pairing = Pairing.new(agent_a: agent_a, agent_b: agent_b, domain: domain)
+                @pairings[pairing.id] = pairing
+                record_history(:created, pairing.id)
+                pairing
+              end
+
+              def record_interaction(pairing_id:, aligned:)
+                pairing = @pairings[pairing_id]
+                return { success: false, reason: :not_found } unless pairing
+
+                pairing.interact!(aligned: aligned)
+                record_history(:interacted, pairing_id)
+                {
+                  success:    true,
+                  synchrony:  pairing.synchrony,
+                  entrained:  pairing.entrained?,
+                  sync_label: pairing.sync_label
+                }
+              end
+
+              def pairings_for(agent_id:)
+                @pairings.values.select { |p| p.involves?(agent_id) }
+              end
+
+              def entrained_pairings
+                @pairings.values.select(&:entrained?)
+              end
+
+              def entrained_partners(agent_id:)
+                pairings_for(agent_id: agent_id)
+                  .select(&:entrained?)
+                  .map { |p| p.partner_of(agent_id) }
+              end
+
+              def strongest_pairings(limit: 5)
+                @pairings.values.sort_by { |p| -p.synchrony }.first(limit)
+              end
+
+              def by_domain(domain:)
+                @pairings.values.select { |p| p.domain == domain }
+              end
+
+              def overall_entrainment
+                return 0.0 if @pairings.empty?
+
+                @pairings.values.sum(&:synchrony) / @pairings.size
+              end
+
+              def drift_all
+                @pairings.each_value(&:drift!)
+              end
+
+              def prune_independent
+                ids = @pairings.select { |_id, p| p.synchrony <= 0.02 }.keys
+                ids.each { |id| @pairings.delete(id) }
+                ids.size
+              end
+
+              def to_h
+                {
+                  total_pairings:  @pairings.size,
+                  entrained_count: entrained_pairings.size,
+                  overall_sync:    overall_entrainment,
+                  history_count:   @history.size
+                }
+              end
+
+              private
+
+              def find_pairing(agent_a:, agent_b:, domain:)
+                @pairings.values.find do |p|
+                  p.domain == domain && pair_match?(p, agent_a, agent_b)
+                end
+              end
+
+              def pair_match?(pairing, agent_a, agent_b)
+                (pairing.agent_a == agent_a && pairing.agent_b == agent_b) ||
+                  (pairing.agent_a == agent_b && pairing.agent_b == agent_a)
+              end
+
+              def evict_oldest
+                oldest_id = @pairings.min_by { |_id, p| p.last_interaction_at }&.first
+                @pairings.delete(oldest_id) if oldest_id
+              end
+
+              def record_history(event, pairing_id)
+                @history << { event: event, pairing_id: pairing_id, at: Time.now.utc }
+                @history.shift while @history.size > MAX_HISTORY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/entrainment/helpers/pairing.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Entrainment
+          module Helpers
+            class Pairing
+              include Constants
+
+              attr_reader :id, :agent_a, :agent_b, :domain, :synchrony,
+                          :interaction_count, :created_at, :last_interaction_at
+
+              def initialize(agent_a:, agent_b:, domain:)
+                @id                 = SecureRandom.uuid
+                @agent_a            = agent_a
+                @agent_b            = agent_b
+                @domain             = domain
+                @synchrony          = DEFAULT_SYNC
+                @interaction_count  = 0
+                @created_at         = Time.now.utc
+                @last_interaction_at = @created_at
+              end
+
+              def interact!(aligned:)
+                @interaction_count  += 1
+                @last_interaction_at = Time.now.utc
+
+                @synchrony = if aligned
+                               (@synchrony + COUPLING_RATE).clamp(SYNC_FLOOR, SYNC_CEILING)
+                             else
+                               (@synchrony - DECOUPLING_RATE).clamp(SYNC_FLOOR, SYNC_CEILING)
+                             end
+              end
+
+              def drift!
+                @synchrony = (@synchrony - NATURAL_DRIFT).clamp(SYNC_FLOOR, SYNC_CEILING)
+              end
+
+              def entrained?
+                @synchrony >= ENTRAINED_THRESHOLD
+              end
+
+              def partially_entrained?
+                @synchrony >= PARTIAL_THRESHOLD && @synchrony < ENTRAINED_THRESHOLD
+              end
+
+              def sync_label
+                SYNC_LABELS.find { |range, _| range.cover?(@synchrony) }&.last || :unknown
+              end
+
+              def involves?(agent_id)
+                [@agent_a, @agent_b].include?(agent_id)
+              end
+
+              def partner_of(agent_id)
+                return @agent_b if @agent_a == agent_id
+                return @agent_a if @agent_b == agent_id
+
+                nil
+              end
+
+              def to_h
+                {
+                  id:                  @id,
+                  agent_a:             @agent_a,
+                  agent_b:             @agent_b,
+                  domain:              @domain,
+                  synchrony:           @synchrony,
+                  sync_label:          sync_label,
+                  entrained:           entrained?,
+                  interaction_count:   @interaction_count,
+                  created_at:          @created_at,
+                  last_interaction_at: @last_interaction_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Entrainment
+          module Runners
+            module CognitiveEntrainment
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def create_entrainment_pairing(agent_a:, agent_b:, domain:, **)
+                pairing = engine.create_pairing(agent_a: agent_a, agent_b: agent_b, domain: domain)
+                Legion::Logging.debug '[cognitive_entrainment] pairing ' \
+                                      "#{agent_a}<->#{agent_b} domain=#{domain} id=#{pairing.id[0..7]}"
+                { success: true, pairing_id: pairing.id, agent_a: agent_a,
+                  agent_b: agent_b, domain: domain, synchrony: pairing.synchrony }
+              end
+
+              def record_entrainment_interaction(pairing_id:, aligned:, **)
+                result = engine.record_interaction(pairing_id: pairing_id, aligned: aligned)
+                Legion::Logging.debug '[cognitive_entrainment] interaction ' \
+                                      "id=#{pairing_id[0..7]} aligned=#{aligned}"
+                result
+              end
+
+              def pairings_for_agent(agent_id:, **)
+                pairings = engine.pairings_for(agent_id: agent_id)
+                Legion::Logging.debug '[cognitive_entrainment] pairings_for ' \
+                                      "agent=#{agent_id} count=#{pairings.size}"
+                { success: true, agent_id: agent_id,
+                  pairings: pairings.map(&:to_h), count: pairings.size }
+              end
+
+              def entrained_partners(agent_id:, **)
+                partners = engine.entrained_partners(agent_id: agent_id)
+                Legion::Logging.debug '[cognitive_entrainment] entrained_partners ' \
+                                      "agent=#{agent_id} count=#{partners.size}"
+                { success: true, agent_id: agent_id, partners: partners, count: partners.size }
+              end
+
+              def strongest_entrainment_pairings(limit: 5, **)
+                pairings = engine.strongest_pairings(limit: limit)
+                Legion::Logging.debug "[cognitive_entrainment] strongest count=#{pairings.size}"
+                { success: true, pairings: pairings.map(&:to_h), count: pairings.size }
+              end
+
+              def domain_entrainment(domain:, **)
+                pairings = engine.by_domain(domain: domain)
+                Legion::Logging.debug "[cognitive_entrainment] domain=#{domain} " \
+                                      "count=#{pairings.size}"
+                { success: true, domain: domain,
+                  pairings: pairings.map(&:to_h), count: pairings.size }
+              end
+
+              def overall_entrainment_level(**)
+                sync = engine.overall_entrainment
+                Legion::Logging.debug "[cognitive_entrainment] overall_sync=#{sync.round(3)}"
+                { success: true, overall_synchrony: sync,
+                  entrained_count: engine.entrained_pairings.size }
+              end
+
+              def update_cognitive_entrainment(**)
+                engine.drift_all
+                pruned = engine.prune_independent
+                Legion::Logging.debug "[cognitive_entrainment] drift+prune pruned=#{pruned}"
+                { success: true, pruned: pruned }
+              end
+
+              def cognitive_entrainment_stats(**)
+                stats = engine.to_h
+                Legion::Logging.debug '[cognitive_entrainment] stats ' \
+                                      "total=#{stats[:total_pairings]}"
+                { success: true }.merge(stats)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::EntrainmentEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/entrainment/version'
+require 'legion/extensions/agentic/social/entrainment/helpers/constants'
+require 'legion/extensions/agentic/social/entrainment/helpers/pairing'
+require 'legion/extensions/agentic/social/entrainment/helpers/entrainment_engine'
+require 'legion/extensions/agentic/social/entrainment/runners/cognitive_entrainment'
+require 'legion/extensions/agentic/social/entrainment/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Entrainment
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/governance/actors/shadow_ai_scan.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Governance
+          module Actors
+            class ShadowAiScan < Legion::Extensions::Actors::Every
+              def runner_class = Runners::ShadowAi
+              def runner_function = 'full_scan'
+              def time = 86_400
+            end
+          end
+        end
+      end
+    end
+  end
+end