lex-agentic-social 0.1.0

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'legion/extensions/agentic/social/mentalizing/version'
+require 'legion/extensions/agentic/social/mentalizing/helpers/constants'
+require 'legion/extensions/agentic/social/mentalizing/helpers/belief_attribution'
+require 'legion/extensions/agentic/social/mentalizing/helpers/mental_model'
+require 'legion/extensions/agentic/social/mentalizing/runners/mentalizing'
+require 'legion/extensions/agentic/social/mentalizing/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mentalizing
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/mirror/helpers/constants'
+require 'legion/extensions/agentic/social/mirror/helpers/mirror_event'
+require 'legion/extensions/agentic/social/mirror/helpers/simulation'
+require 'legion/extensions/agentic/social/mirror/helpers/mirror_engine'
+require 'legion/extensions/agentic/social/mirror/runners/observe'
+require 'legion/extensions/agentic/social/mirror/runners/simulate'
+require 'legion/extensions/agentic/social/mirror/runners/resonance'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mirror
+          class Client
+            include Runners::Observe
+            include Runners::Simulate
+            include Runners::Resonance
+
+            def initialize(**)
+              @mirror_engine = Helpers::MirrorEngine.new
+            end
+
+            private
+
+            attr_reader :mirror_engine
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mirror
+          module Helpers
+            module Constants
+              MAX_EVENTS              = 500
+              MAX_SIMULATIONS         = 300
+              DEFAULT_RESONANCE       = 0.5
+              RESONANCE_BOOST         = 0.1
+              RESONANCE_DECAY         = 0.03
+              SIMULATION_CONFIDENCE_DEFAULT = 0.5
+
+              ACTION_TYPES = %i[
+                movement
+                communication
+                decision
+                emotional_expression
+                creative_act
+                analytical_task
+                social_interaction
+                unknown
+              ].freeze
+
+              RESONANCE_LABELS = {
+                (0.0..0.2) => :minimal,
+                (0.2..0.4) => :low,
+                (0.4..0.6) => :moderate,
+                (0.6..0.8) => :high,
+                (0.8..1.0) => :deep
+              }.freeze
+
+              CONFIDENCE_LABELS = {
+                (0.0..0.2) => :uncertain,
+                (0.2..0.4) => :tentative,
+                (0.4..0.6) => :plausible,
+                (0.6..0.8) => :confident,
+                (0.8..1.0) => :certain
+              }.freeze
+
+              EMPATHY_LABELS = {
+                (0.0..0.2) => :detached,
+                (0.2..0.4) => :aware,
+                (0.4..0.6) => :attuned,
+                (0.6..0.8) => :resonant,
+                (0.8..1.0) => :immersed
+              }.freeze
+
+              def self.label_for(labels_hash, value)
+                clamped = value.clamp(0.0, 1.0)
+                labels_hash.each do |range, label|
+                  return label if range.cover?(clamped)
+                end
+                labels_hash.values.last
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/mirror/helpers/mirror_engine.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mirror
+          module Helpers
+            class MirrorEngine
+              INTENT_MAP = {
+                communication:        :inform_or_persuade,
+                decision:             :resolve_uncertainty,
+                emotional_expression: :signal_internal_state,
+                creative_act:         :generate_novelty,
+                analytical_task:      :reduce_uncertainty,
+                social_interaction:   :build_relationship,
+                movement:             :change_position
+              }.freeze
+
+              attr_reader :events, :simulations, :resonance_map
+
+              def initialize
+                @events        = []
+                @simulations   = []
+                @resonance_map = Hash.new(Constants::DEFAULT_RESONANCE)
+              end
+
+              def observe(agent_id:, action_type:, context: {}, emotional_valence: 0.0)
+                event = MirrorEvent.new(
+                  agent_id:          agent_id,
+                  action_type:       action_type,
+                  context:           context,
+                  emotional_valence: emotional_valence
+                )
+                @events << event
+                @events.shift while @events.size > Constants::MAX_EVENTS
+                event
+              end
+
+              def simulate(event, confidence: Constants::SIMULATION_CONFIDENCE_DEFAULT)
+                resonance = compute_resonance_for(event)
+                outcome   = derive_outcome(event)
+
+                sim = Simulation.new(
+                  event_id:            event.id,
+                  simulated_outcome:   outcome,
+                  confidence:          confidence,
+                  emotional_resonance: resonance
+                )
+                @simulations << sim
+                @simulations.shift while @simulations.size > Constants::MAX_SIMULATIONS
+                sim
+              end
+
+              def record_accuracy(simulation_id, accuracy)
+                sim = @simulations.find { |s| s.id == simulation_id }
+                return false unless sim
+
+                sim.accuracy_score = accuracy.to_f.clamp(0.0, 1.0)
+                true
+              end
+
+              def empathic_resonance(agent_id)
+                @resonance_map[agent_id].clamp(0.0, 1.0)
+              end
+
+              def boost_resonance(agent_id)
+                current = @resonance_map[agent_id]
+                @resonance_map[agent_id] = (current + Constants::RESONANCE_BOOST).round(10).clamp(0.0, 1.0)
+              end
+
+              def decay_resonance(agent_id)
+                current = @resonance_map[agent_id]
+                @resonance_map[agent_id] = (current - Constants::RESONANCE_DECAY).round(10).clamp(0.0, 1.0)
+              end
+
+              def decay_all_resonances
+                @resonance_map.each_key { |agent_id| decay_resonance(agent_id) }
+              end
+
+              def simulation_accuracy_for(agent_id)
+                scored = simulations_for(agent_id).reject { |s| s.accuracy_score.nil? }
+                return nil if scored.empty?
+
+                scored.sum(&:accuracy_score) / scored.size.to_f
+              end
+
+              def simulations_for(agent_id)
+                event_ids = events_for(agent_id).map(&:id)
+                @simulations.select { |s| event_ids.include?(s.event_id) }
+              end
+
+              def events_for(agent_id)
+                @events.select { |e| e.agent_id == agent_id }
+              end
+
+              def simulation_history(limit: 20)
+                @simulations.last(limit).map(&:to_h)
+              end
+
+              def known_agents
+                @resonance_map.keys
+              end
+
+              private
+
+              def compute_resonance_for(event)
+                base      = @resonance_map[event.agent_id]
+                valence   = event.emotional_valence.abs
+                resonance = (base + (valence * Constants::RESONANCE_BOOST)).round(10)
+                resonance.clamp(0.0, 1.0)
+              end
+
+              def derive_outcome(event)
+                {
+                  action_type:      event.action_type,
+                  predicted_intent: infer_intent(event),
+                  emotional_echo:   event.emotional_valence,
+                  context_keys:     event.context.keys
+                }
+              end
+
+              def infer_intent(event)
+                INTENT_MAP.fetch(event.action_type, :unknown_intent)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/mirror/helpers/mirror_event.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mirror
+          module Helpers
+            class MirrorEvent
+              attr_reader :id, :agent_id, :action_type, :context, :emotional_valence, :observed_at
+
+              def initialize(agent_id:, action_type:, context: {}, emotional_valence: 0.0)
+                @id               = SecureRandom.uuid
+                @agent_id         = agent_id
+                @action_type      = normalize_action_type(action_type)
+                @context          = context.is_a?(Hash) ? context : {}
+                @emotional_valence = emotional_valence.to_f.clamp(-1.0, 1.0)
+                @observed_at = Time.now.utc
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  agent_id:          @agent_id,
+                  action_type:       @action_type,
+                  context:           @context,
+                  emotional_valence: @emotional_valence,
+                  observed_at:       @observed_at
+                }
+              end
+
+              private
+
+              def normalize_action_type(action_type)
+                sym = action_type.to_sym
+                Constants::ACTION_TYPES.include?(sym) ? sym : :unknown
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/social/mirror/helpers/simulation.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mirror
+          module Helpers
+            class Simulation
+              attr_reader :id, :event_id, :simulated_outcome, :confidence, :emotional_resonance, :simulated_at
+              attr_accessor :accuracy_score
+
+              def initialize(event_id:, simulated_outcome:, confidence: Constants::SIMULATION_CONFIDENCE_DEFAULT,
+                             emotional_resonance: Constants::DEFAULT_RESONANCE)
+                @id                  = SecureRandom.uuid
+                @event_id            = event_id
+                @simulated_outcome   = simulated_outcome
+                @confidence          = confidence.to_f.clamp(0.0, 1.0)
+                @emotional_resonance = emotional_resonance.to_f.clamp(0.0, 1.0)
+                @simulated_at        = Time.now.utc
+                @accuracy_score      = nil
+              end
+
+              def to_h
+                {
+                  id:                  @id,
+                  event_id:            @event_id,
+                  simulated_outcome:   @simulated_outcome,
+                  confidence:          @confidence,
+                  emotional_resonance: @emotional_resonance,
+                  simulated_at:        @simulated_at,
+                  accuracy_score:      @accuracy_score
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mirror
+          module Runners
+            module Observe
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def observe_action(agent_id:, action_type:, context: {}, emotional_valence: 0.0, engine: nil, **)
+                eng = engine || mirror_engine
+
+                unless Helpers::Constants::ACTION_TYPES.include?(action_type.to_sym)
+                  Legion::Logging.debug "[cognitive_mirror] unknown action_type=#{action_type}, mapping to :unknown"
+                end
+
+                event = eng.observe(
+                  agent_id:          agent_id,
+                  action_type:       action_type,
+                  context:           context,
+                  emotional_valence: emotional_valence
+                )
+
+                resonance_label = Helpers::Constants.label_for(Helpers::Constants::RESONANCE_LABELS,
+                                                               eng.empathic_resonance(agent_id))
+                Legion::Logging.debug "[cognitive_mirror] observed action=#{event.action_type} " \
+                                      "agent=#{agent_id} resonance_tier=#{resonance_label}"
+
+                { success: true, event: event.to_h, resonance_tier: resonance_label }
+              end
+
+              def list_events(agent_id: nil, engine: nil, **)
+                eng = engine || mirror_engine
+                events = agent_id ? eng.events_for(agent_id) : eng.events
+                { success: true, events: events.map(&:to_h), count: events.size }
+              end
+
+              private
+
+              def mirror_engine
+                @mirror_engine ||= Helpers::MirrorEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mirror
+          module Runners
+            module Resonance
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def empathic_resonance(agent_id:, engine: nil, **)
+                eng = engine || mirror_engine
+                value = eng.empathic_resonance(agent_id)
+                accuracy = eng.simulation_accuracy_for(agent_id)
+
+                empathy_label   = Helpers::Constants.label_for(Helpers::Constants::EMPATHY_LABELS, value)
+                resonance_label = Helpers::Constants.label_for(Helpers::Constants::RESONANCE_LABELS, value)
+
+                Legion::Logging.debug "[cognitive_mirror] resonance agent=#{agent_id} " \
+                                      "value=#{value.round(3)} empathy=#{empathy_label}"
+
+                {
+                  success:          true,
+                  agent_id:         agent_id,
+                  resonance:        value,
+                  resonance_label:  resonance_label,
+                  empathy_label:    empathy_label,
+                  accuracy:         accuracy,
+                  event_count:      eng.events_for(agent_id).size,
+                  simulation_count: eng.simulations_for(agent_id).size
+                }
+              end
+
+              def decay_resonances(agent_id: nil, engine: nil, **)
+                eng = engine || mirror_engine
+
+                if agent_id
+                  eng.decay_resonance(agent_id)
+                  after = eng.empathic_resonance(agent_id)
+                  Legion::Logging.debug "[cognitive_mirror] resonance decayed agent=#{agent_id} after=#{after.round(3)}"
+                  { success: true, agent_id: agent_id, resonance_after: after }
+                else
+                  eng.decay_all_resonances
+                  summary = eng.known_agents.to_h { |id| [id, eng.empathic_resonance(id)] }
+                  Legion::Logging.debug "[cognitive_mirror] global resonance decay agents=#{summary.size}"
+                  { success: true, agents_decayed: summary.size, resonances: summary }
+                end
+              end
+
+              def resonance_summary(engine: nil, **)
+                eng = engine || mirror_engine
+                agents = eng.known_agents
+
+                summary = agents.map do |id|
+                  value = eng.empathic_resonance(id)
+                  {
+                    agent_id:      id,
+                    resonance:     value,
+                    empathy_label: Helpers::Constants.label_for(Helpers::Constants::EMPATHY_LABELS, value)
+                  }
+                end
+
+                { success: true, agents: summary, total: agents.size }
+              end
+
+              private
+
+              def mirror_engine
+                @mirror_engine ||= Helpers::MirrorEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mirror
+          module Runners
+            module Simulate
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def simulate_action(event_id:, confidence: Helpers::Constants::SIMULATION_CONFIDENCE_DEFAULT,
+                                  engine: nil, **)
+                eng = engine || mirror_engine
+
+                event = eng.events.find { |e| e.id == event_id }
+                unless event
+                  Legion::Logging.debug "[cognitive_mirror] simulate_action: event_id=#{event_id} not found"
+                  return { success: false, error: 'event not found', event_id: event_id }
+                end
+
+                sim = eng.simulate(event, confidence: confidence)
+                eng.boost_resonance(event.agent_id)
+
+                confidence_label = Helpers::Constants.label_for(Helpers::Constants::CONFIDENCE_LABELS, sim.confidence)
+                Legion::Logging.debug "[cognitive_mirror] simulated event=#{event_id} " \
+                                      "confidence_tier=#{confidence_label} resonance=#{sim.emotional_resonance.round(3)}"
+
+                { success: true, simulation: sim.to_h, confidence_tier: confidence_label }
+              end
+
+              def record_simulation_accuracy(simulation_id:, accuracy:, engine: nil, **)
+                eng = engine || mirror_engine
+                recorded = eng.record_accuracy(simulation_id, accuracy)
+
+                unless recorded
+                  Legion::Logging.debug "[cognitive_mirror] record_accuracy: simulation_id=#{simulation_id} not found"
+                  return { success: false, error: 'simulation not found', simulation_id: simulation_id }
+                end
+
+                Legion::Logging.debug "[cognitive_mirror] accuracy recorded simulation=#{simulation_id} score=#{accuracy}"
+                { success: true, simulation_id: simulation_id, accuracy: accuracy.to_f.clamp(0.0, 1.0) }
+              end
+
+              def simulation_history(limit: 20, engine: nil, **)
+                eng = engine || mirror_engine
+                history = eng.simulation_history(limit: limit)
+                { success: true, simulations: history, count: history.size }
+              end
+
+              private
+
+              def mirror_engine
+                @mirror_engine ||= Helpers::MirrorEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/mirror/version'
+require 'legion/extensions/agentic/social/mirror/helpers/constants'
+require 'legion/extensions/agentic/social/mirror/helpers/mirror_event'
+require 'legion/extensions/agentic/social/mirror/helpers/simulation'
+require 'legion/extensions/agentic/social/mirror/helpers/mirror_engine'
+require 'legion/extensions/agentic/social/mirror/runners/observe'
+require 'legion/extensions/agentic/social/mirror/runners/simulate'
+require 'legion/extensions/agentic/social/mirror/runners/resonance'
+require 'legion/extensions/agentic/social/mirror/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module Mirror
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MirrorSystem
+          module Actor
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Social::MirrorSystem::Runners::Mirror
+              end
+
+              def runner_function
+                'update_mirror'
+              end
+
+              def time
+                120
+              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/mirror_system/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+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'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Social
+        module MirrorSystem
+          class Client
+            include Runners::Mirror
+
+            def initialize(mirror_system: nil, **)
+              @mirror_system = mirror_system || Helpers::MirrorSystem.new
+            end
+
+            private
+
+            attr_reader :mirror_system
+          end
+        end
+      end
+    end
+  end
+end