lex-agentic-social 0.1.0

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MirrorSystem
+          module Helpers
+            module Constants
+              # Maximum observed behaviors to store
+              MAX_OBSERVATIONS = 200
+
+              # Maximum imitation candidates per domain
+              MAX_IMITATIONS = 50
+
+              # How quickly observed behaviors are internalized
+              MIRROR_ALPHA = 0.15
+
+              # Default resonance strength for new observations
+              DEFAULT_RESONANCE = 0.3
+
+              # Minimum resonance to keep an observation
+              RESONANCE_FLOOR = 0.05
+
+              # Resonance decay per tick
+              RESONANCE_DECAY = 0.01
+
+              # Boost when observation matches own repertoire
+              FAMILIARITY_BOOST = 0.2
+
+              # Boost from repeated observation of same behavior
+              REPETITION_BOOST = 0.1
+
+              # Maximum resonance value
+              MAX_RESONANCE = 1.0
+
+              # Imitation fidelity: how accurately behaviors are copied (0..1)
+              DEFAULT_FIDELITY = 0.7
+
+              # Fidelity improvement per successful imitation
+              FIDELITY_LEARNING_RATE = 0.05
+
+              # Maximum agents to mirror simultaneously
+              MAX_MIRRORED_AGENTS = 20
+
+              # Maximum behaviors in own repertoire
+              MAX_REPERTOIRE = 100
+
+              RESONANCE_LABELS = {
+                (0.8..)     => :strong_mirror,
+                (0.6...0.8) => :resonating,
+                (0.4...0.6) => :echoing,
+                (0.2...0.4) => :faint,
+                (..0.2)     => :silent
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/mirror_system/helpers/mirror_system.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MirrorSystem
+          module Helpers
+            class MirrorSystem
+              include Constants
+
+              attr_reader :observations, :repertoire, :fidelity_scores, :imitation_history
+
+              def initialize
+                @observations     = {}
+                @repertoire       = {}
+                @fidelity_scores  = {}
+                @imitation_history = []
+              end
+
+              def observe(agent_id:, action:, domain:, context: nil, outcome: nil)
+                key = observation_key(agent_id, action, domain)
+                if @observations.key?(key)
+                  @observations[key].observe_again
+                  @observations[key]
+                else
+                  ensure_observation_capacity
+                  obs = ObservedBehavior.new(
+                    agent_id: agent_id,
+                    action:   action,
+                    domain:   domain,
+                    context:  context,
+                    outcome:  outcome
+                  )
+                  obs.boost_familiarity if repertoire_includes?(action, domain)
+                  @observations[key] = obs
+                end
+              end
+
+              def imitate(action:, domain:, source_agent: nil)
+                candidates = if source_agent
+                               observations_for_agent(source_agent).select { |o| o.action == action && o.domain == domain }
+                             else
+                               @observations.values.select { |o| o.action == action && o.domain == domain }
+                             end
+                return nil if candidates.empty?
+
+                best = candidates.max_by(&:resonance)
+                fidelity = fidelity_for(action, domain)
+                add_to_repertoire(action, domain, fidelity)
+                record_imitation(action, domain, source_agent, fidelity)
+                { observation: best, fidelity: fidelity }
+              end
+
+              def add_to_repertoire(action, domain, fidelity = DEFAULT_FIDELITY)
+                key = repertoire_key(action, domain)
+                if @repertoire.key?(key)
+                  old = @repertoire[key][:fidelity]
+                  @repertoire[key][:fidelity] = ema(old, fidelity, MIRROR_ALPHA)
+                  @repertoire[key][:practice_count] += 1
+                else
+                  trim_repertoire if @repertoire.size >= MAX_REPERTOIRE
+                  @repertoire[key] = { action: action, domain: domain, fidelity: fidelity, practice_count: 1 }
+                end
+              end
+
+              def update_fidelity(action:, domain:, success:)
+                key = repertoire_key(action, domain)
+                @fidelity_scores[key] ||= DEFAULT_FIDELITY
+                delta = success ? FIDELITY_LEARNING_RATE : -FIDELITY_LEARNING_RATE
+                @fidelity_scores[key] = (@fidelity_scores[key] + delta).clamp(0.0, 1.0)
+              end
+
+              def fidelity_for(action, domain)
+                @fidelity_scores.fetch(repertoire_key(action, domain), DEFAULT_FIDELITY)
+              end
+
+              def observations_for_agent(agent_id)
+                @observations.values.select { |o| o.agent_id == agent_id }
+              end
+
+              def observations_in_domain(domain)
+                @observations.values.select { |o| o.domain == domain }
+              end
+
+              def strongest_mirrors(count = 5)
+                @observations.values.sort_by { |o| -o.resonance }.first(count)
+              end
+
+              def repertoire_includes?(action, domain)
+                @repertoire.key?(repertoire_key(action, domain))
+              end
+
+              def decay_all
+                @observations.each_value(&:decay)
+                @observations.reject! { |_, o| o.faded? }
+              end
+
+              def observation_count
+                @observations.size
+              end
+
+              def repertoire_size
+                @repertoire.size
+              end
+
+              def mirrored_agents
+                @observations.values.map(&:agent_id).uniq
+              end
+
+              def to_h
+                {
+                  observations:    observation_count,
+                  repertoire_size: repertoire_size,
+                  mirrored_agents: mirrored_agents.size,
+                  history_size:    @imitation_history.size
+                }
+              end
+
+              private
+
+              def observation_key(agent_id, action, domain)
+                :"#{agent_id}:#{action}:#{domain}"
+              end
+
+              def repertoire_key(action, domain)
+                :"#{action}:#{domain}"
+              end
+
+              def ema(old_val, new_val, alpha)
+                old_val + (alpha * (new_val - old_val))
+              end
+
+              def ensure_observation_capacity
+                return if @observations.size < MAX_OBSERVATIONS
+
+                weakest = @observations.min_by { |_, o| o.resonance }
+                @observations.delete(weakest.first) if weakest
+              end
+
+              def trim_repertoire
+                weakest = @repertoire.min_by { |_, r| r[:fidelity] }
+                @repertoire.delete(weakest.first) if weakest
+              end
+
+              def record_imitation(action, domain, source_agent, fidelity)
+                @imitation_history << {
+                  action:       action,
+                  domain:       domain,
+                  source_agent: source_agent,
+                  fidelity:     fidelity,
+                  at:           Time.now.utc
+                }
+                @imitation_history.shift while @imitation_history.size > MAX_OBSERVATIONS
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/mirror_system/helpers/observed_behavior.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MirrorSystem
+          module Helpers
+            class ObservedBehavior
+              attr_reader :id, :agent_id, :action, :domain, :context, :outcome, :created_at
+              attr_accessor :resonance, :observation_count
+
+              def initialize(agent_id:, action:, domain:, context: nil, outcome: nil, resonance: nil)
+                @id                = SecureRandom.uuid
+                @agent_id          = agent_id
+                @action            = action
+                @domain            = domain
+                @context           = context
+                @outcome           = outcome
+                @resonance         = (resonance || Constants::DEFAULT_RESONANCE).clamp(0.0, Constants::MAX_RESONANCE)
+                @observation_count = 1
+                @created_at        = Time.now.utc
+              end
+
+              def observe_again
+                @observation_count += 1
+                @resonance = [@resonance + Constants::REPETITION_BOOST, Constants::MAX_RESONANCE].min
+              end
+
+              def boost_familiarity
+                @resonance = [@resonance + Constants::FAMILIARITY_BOOST, Constants::MAX_RESONANCE].min
+              end
+
+              def decay
+                @resonance = [@resonance - Constants::RESONANCE_DECAY, Constants::RESONANCE_FLOOR].max
+              end
+
+              def faded?
+                @resonance <= Constants::RESONANCE_FLOOR
+              end
+
+              def label
+                Constants::RESONANCE_LABELS.each { |range, lbl| return lbl if range.cover?(@resonance) }
+                :silent
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  agent_id:          @agent_id,
+                  action:            @action,
+                  domain:            @domain,
+                  context:           @context,
+                  outcome:           @outcome,
+                  resonance:         @resonance,
+                  observation_count: @observation_count,
+                  label:             label,
+                  created_at:        @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/mirror_system/runners/mirror.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MirrorSystem
+          module Runners
+            module Mirror
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def observe_behavior(agent_id:, action:, domain:, context: nil, outcome: nil, **)
+                obs = mirror_system.observe(agent_id: agent_id, action: action, domain: domain, context: context, outcome: outcome)
+                Legion::Logging.debug "[mirror] observe: agent=#{agent_id} action=#{action} domain=#{domain} " \
+                                      "resonance=#{obs.resonance.round(3)} count=#{obs.observation_count}"
+                { success: true, observation: obs.to_h }
+              end
+
+              def imitate_behavior(action:, domain:, source_agent: nil, **)
+                result = mirror_system.imitate(action: action, domain: domain, source_agent: source_agent)
+                if result
+                  Legion::Logging.debug "[mirror] imitate: action=#{action} domain=#{domain} " \
+                                        "fidelity=#{result[:fidelity].round(3)}"
+                  {
+                    success:   true,
+                    imitated:  true,
+                    action:    action,
+                    domain:    domain,
+                    fidelity:  result[:fidelity].round(4),
+                    source:    result[:observation].agent_id,
+                    resonance: result[:observation].resonance.round(4)
+                  }
+                else
+                  Legion::Logging.debug "[mirror] imitate: action=#{action} domain=#{domain} no_observation"
+                  { success: true, imitated: false, action: action, domain: domain }
+                end
+              end
+
+              def report_imitation_outcome(action:, domain:, success_flag:, **)
+                mirror_system.update_fidelity(action: action, domain: domain, success: success_flag)
+                fidelity = mirror_system.fidelity_for(action, domain)
+                Legion::Logging.debug "[mirror] outcome: action=#{action} domain=#{domain} " \
+                                      "success=#{success_flag} fidelity=#{fidelity.round(3)}"
+                { success: true, action: action, domain: domain, fidelity: fidelity.round(4) }
+              end
+
+              def strongest_mirrors(count: 5, **)
+                mirrors = mirror_system.strongest_mirrors(count)
+                Legion::Logging.debug "[mirror] strongest: count=#{mirrors.size}"
+                { success: true, mirrors: mirrors.map(&:to_h), count: mirrors.size }
+              end
+
+              def observations_for(agent_id:, **)
+                observations = mirror_system.observations_for_agent(agent_id)
+                Legion::Logging.debug "[mirror] observations_for: agent=#{agent_id} count=#{observations.size}"
+                { success: true, agent_id: agent_id, observations: observations.map(&:to_h), count: observations.size }
+              end
+
+              def observations_in(domain:, **)
+                observations = mirror_system.observations_in_domain(domain)
+                Legion::Logging.debug "[mirror] observations_in: domain=#{domain} count=#{observations.size}"
+                { success: true, domain: domain, observations: observations.map(&:to_h), count: observations.size }
+              end
+
+              def repertoire_status(**)
+                rep = mirror_system.repertoire
+                Legion::Logging.debug "[mirror] repertoire: size=#{rep.size}"
+                { success: true, repertoire: rep.values, size: rep.size }
+              end
+
+              def update_mirror(**)
+                mirror_system.decay_all
+                Legion::Logging.debug "[mirror] tick: observations=#{mirror_system.observation_count} " \
+                                      "repertoire=#{mirror_system.repertoire_size} agents=#{mirror_system.mirrored_agents.size}"
+                {
+                  success:      true,
+                  observations: mirror_system.observation_count,
+                  repertoire:   mirror_system.repertoire_size,
+                  agents:       mirror_system.mirrored_agents.size
+                }
+              end
+
+              def mirror_stats(**)
+                { success: true, stats: mirror_system.to_h }
+              end
+
+              private
+
+              def mirror_system
+                @mirror_system ||= Helpers::MirrorSystem.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'legion/extensions/agentic/social/mirror_system/version'
+require 'legion/extensions/agentic/social/mirror_system/helpers/constants'
+require 'legion/extensions/agentic/social/mirror_system/helpers/observed_behavior'
+require 'legion/extensions/agentic/social/mirror_system/helpers/mirror_system'
+require 'legion/extensions/agentic/social/mirror_system/runners/mirror'
+require 'legion/extensions/agentic/social/mirror_system/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MirrorSystem
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'runners/moral_reasoning'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MoralReasoning
+          class Client
+            include Runners::MoralReasoning
+
+            def initialize(**); end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MoralReasoning
+          module Helpers
+            module Constants
+              MAX_DILEMMAS = 100
+              MAX_PRINCIPLES = 50
+              MAX_HISTORY = 300
+
+              DEFAULT_WEIGHT    = 0.5
+              WEIGHT_FLOOR      = 0.1
+              WEIGHT_CEILING    = 1.0
+              REINFORCEMENT_RATE = 0.1
+              DECAY_RATE        = 0.01
+
+              # Haidt's 6 Moral Foundations
+              MORAL_FOUNDATIONS = %i[care fairness loyalty authority sanctity liberty].freeze
+
+              # Kohlberg's 6 Stages (grouped into 3 levels)
+              KOHLBERG_STAGES = %i[obedience self_interest conformity law_and_order social_contract universal_ethics].freeze
+
+              KOHLBERG_LEVELS = {
+                preconventional:  %i[obedience self_interest],
+                conventional:     %i[conformity law_and_order],
+                postconventional: %i[social_contract universal_ethics]
+              }.freeze
+
+              # Ethical frameworks for dilemma resolution
+              ETHICAL_FRAMEWORKS = %i[utilitarian deontological virtue care justice rights].freeze
+
+              # Dilemma severity labels keyed by endless/beginless ranges
+              SEVERITY_LABELS = {
+                (0.8..)     => :critical,
+                (0.6...0.8) => :serious,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :minor,
+                (..0.2)     => :trivial
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/moral_reasoning/helpers/dilemma.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MoralReasoning
+          module Helpers
+            class Dilemma
+              include Constants
+
+              attr_reader :id, :description, :domain, :severity, :options,
+                          :chosen_option, :reasoning, :framework_used,
+                          :created_at, :resolved_at
+
+              def initialize(id:, description:, options:, domain: :general, severity: 0.5)
+                @id           = id
+                @description  = description
+                @domain       = domain
+                @severity     = severity.clamp(0.0, 1.0)
+                @options      = options
+                @chosen_option = nil
+                @reasoning = nil
+                @framework_used = nil
+                @resolved     = false
+                @created_at   = Time.now.utc
+                @resolved_at  = nil
+              end
+
+              def severity_label
+                SEVERITY_LABELS.find { |range, _| range.cover?(@severity) }&.last
+              end
+
+              def resolve(option_id:, reasoning:, framework:)
+                @chosen_option  = option_id
+                @reasoning      = reasoning
+                @framework_used = framework
+                @resolved       = true
+                @resolved_at    = Time.now.utc
+              end
+
+              def resolved?
+                @resolved
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  description:    @description,
+                  domain:         @domain,
+                  severity:       @severity,
+                  severity_label: severity_label,
+                  options:        @options,
+                  chosen_option:  @chosen_option,
+                  reasoning:      @reasoning,
+                  framework_used: @framework_used,
+                  resolved:       @resolved,
+                  created_at:     @created_at,
+                  resolved_at:    @resolved_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end