lex-agentic-affect 0.1.0

data/lib/legion/extensions/agentic/affect/emotion.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/emotion/version'
+require 'legion/extensions/agentic/affect/emotion/helpers/valence'
+require 'legion/extensions/agentic/affect/emotion/helpers/baseline'
+require 'legion/extensions/agentic/affect/emotion/helpers/momentum'
+require 'legion/extensions/agentic/affect/emotion/runners/valence'
+require 'legion/extensions/agentic/affect/emotion/runners/gut'
+require 'legion/extensions/agentic/affect/emotion/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Emotion
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/empathy/client.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Empathy
+          class Client
+            include Runners::Empathy
+
+            attr_reader :model_store
+
+            def initialize(model_store: nil, **)
+              @model_store = model_store || Helpers::ModelStore.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/empathy/helpers/constants.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Empathy
+          module Helpers
+            module Constants
+              # Mental state dimensions tracked per agent
+              MENTAL_STATE_DIMENSIONS = %i[
+                believed_goal
+                emotional_state
+                attention_focus
+                confidence_level
+                cooperation_stance
+              ].freeze
+
+              # How quickly mental models update (EMA alpha)
+              MODEL_UPDATE_ALPHA = 0.2
+
+              # How long before a mental model is considered stale (seconds)
+              MODEL_STALENESS_THRESHOLD = 300
+
+              # Maximum number of tracked agents
+              MAX_TRACKED_AGENTS = 100
+
+              # Maximum interaction history per agent
+              MAX_INTERACTION_HISTORY = 50
+
+              # Prediction confidence thresholds
+              PREDICTION_CONFIDENT   = 0.7
+              PREDICTION_UNCERTAIN   = 0.4
+
+              # Cooperation stance values
+              COOPERATION_STANCES = %i[cooperative neutral competitive unknown].freeze
+
+              # Emotional state labels for other agents
+              INFERRED_EMOTIONS = %i[
+                calm focused stressed frustrated curious cautious enthusiastic unknown
+              ].freeze
+
+              # Perspective-taking accuracy tracking window
+              ACCURACY_WINDOW = 20
+
+              # Mental model decay rate (per decay cycle)
+              MODEL_DECAY_RATE = 0.01
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/empathy/helpers/mental_model.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Empathy
+          module Helpers
+            class MentalModel
+              attr_reader :agent_id, :believed_goal, :emotional_state, :attention_focus,
+                          :confidence_level, :cooperation_stance, :interaction_history,
+                          :predictions, :created_at, :updated_at
+
+              def initialize(agent_id:)
+                @agent_id = agent_id
+                @believed_goal = nil
+                @emotional_state = :unknown
+                @attention_focus = nil
+                @confidence_level = 0.5
+                @cooperation_stance = :unknown
+                @interaction_history = []
+                @predictions = []
+                @prediction_outcomes = []
+                @created_at = Time.now.utc
+                @updated_at = @created_at
+              end
+
+              def update_from_observation(observation)
+                @updated_at = Time.now.utc
+
+                update_believed_goal(observation[:goal]) if observation[:goal]
+                update_emotional_state(observation[:emotion]) if observation[:emotion]
+                update_attention(observation[:attention]) if observation[:attention]
+                update_cooperation(observation[:cooperation]) if observation[:cooperation]
+                update_confidence(observation)
+
+                record_interaction(observation)
+              end
+
+              def predict_reaction(scenario)
+                prediction = {
+                  prediction_id:     SecureRandom.uuid,
+                  scenario:          scenario,
+                  predicted_at:      Time.now.utc,
+                  likely_response:   infer_response(scenario),
+                  emotional_shift:   infer_emotional_shift(scenario),
+                  cooperation_shift: infer_cooperation_shift(scenario),
+                  confidence:        prediction_confidence
+                }
+
+                @predictions << prediction
+                @predictions = @predictions.last(Constants::MAX_INTERACTION_HISTORY)
+                prediction
+              end
+
+              def record_prediction_outcome(prediction_id:, actual_response:, accurate:)
+                pred = @predictions.find { |p| p[:prediction_id] == prediction_id }
+                return nil unless pred
+
+                pred[:actual_response] = actual_response
+                pred[:accurate] = accurate
+
+                @prediction_outcomes << { prediction_id: prediction_id, accurate: accurate, at: Time.now.utc }
+                @prediction_outcomes = @prediction_outcomes.last(Constants::ACCURACY_WINDOW)
+                accurate
+              end
+
+              def prediction_accuracy
+                return nil if @prediction_outcomes.empty?
+
+                correct = @prediction_outcomes.count { |o| o[:accurate] }
+                correct.to_f / @prediction_outcomes.size
+              end
+
+              def stale?
+                (Time.now.utc - @updated_at) > Constants::MODEL_STALENESS_THRESHOLD
+              end
+
+              def decay
+                @confidence_level = [(@confidence_level - Constants::MODEL_DECAY_RATE), 0.1].max
+              end
+
+              def to_h
+                {
+                  agent_id:            @agent_id,
+                  believed_goal:       @believed_goal,
+                  emotional_state:     @emotional_state,
+                  attention_focus:     @attention_focus,
+                  confidence_level:    @confidence_level,
+                  cooperation_stance:  @cooperation_stance,
+                  interactions:        @interaction_history.size,
+                  predictions_made:    @predictions.size,
+                  prediction_accuracy: prediction_accuracy,
+                  stale:               stale?,
+                  created_at:          @created_at,
+                  updated_at:          @updated_at
+                }
+              end
+
+              private
+
+              def update_believed_goal(goal)
+                @believed_goal = goal
+              end
+
+              def update_emotional_state(emotion)
+                sym = emotion.to_sym
+                @emotional_state = Constants::INFERRED_EMOTIONS.include?(sym) ? sym : :unknown
+              end
+
+              def update_attention(attention)
+                @attention_focus = attention
+              end
+
+              def update_cooperation(cooperation)
+                sym = cooperation.to_sym
+                @cooperation_stance = Constants::COOPERATION_STANCES.include?(sym) ? sym : :unknown
+              end
+
+              def update_confidence(observation)
+                evidence_strength = observation[:evidence_strength] || 0.5
+                alpha = Constants::MODEL_UPDATE_ALPHA
+                @confidence_level = (@confidence_level * (1 - alpha)) + (evidence_strength * alpha)
+                @confidence_level = @confidence_level.clamp(0.0, 1.0)
+              end
+
+              def record_interaction(observation)
+                @interaction_history << {
+                  type:    observation[:interaction_type] || :observation,
+                  summary: observation[:summary],
+                  at:      Time.now.utc
+                }
+                @interaction_history = @interaction_history.last(Constants::MAX_INTERACTION_HISTORY)
+              end
+
+              def infer_response(scenario)
+                case @cooperation_stance
+                when :cooperative
+                  scenario[:cooperative_option] || :likely_agree
+                when :competitive
+                  scenario[:competitive_option] || :likely_resist
+                when :neutral
+                  @confidence_level > 0.5 ? :likely_consider : :unpredictable
+                else
+                  :unpredictable
+                end
+              end
+
+              def infer_emotional_shift(scenario)
+                impact = scenario[:emotional_impact] || :neutral
+                case impact
+                when :positive
+                  :likely_positive
+                when :negative
+                  stressed_states = %i[stressed frustrated cautious]
+                  stressed_states.include?(@emotional_state) ? :likely_escalate : :likely_negative
+                else
+                  :likely_stable
+                end
+              end
+
+              def infer_cooperation_shift(scenario)
+                return :stable if scenario[:impact_on_agent].nil?
+
+                case scenario[:impact_on_agent]
+                when :beneficial then :likely_more_cooperative
+                when :harmful then :likely_less_cooperative
+                else :stable
+                end
+              end
+
+              def prediction_confidence
+                base = @confidence_level
+                staleness_penalty = stale? ? 0.2 : 0.0
+                history_bonus = [@interaction_history.size / 20.0, 0.2].min
+
+                (base - staleness_penalty + history_bonus).clamp(0.1, 0.9)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/empathy/helpers/model_store.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Empathy
+          module Helpers
+            class ModelStore
+              attr_reader :models
+
+              def initialize
+                @models = {}
+              end
+
+              def get(agent_id)
+                @models[agent_id.to_s]
+              end
+
+              def get_or_create(agent_id)
+                key = agent_id.to_s
+                @models[key] ||= MentalModel.new(agent_id: key)
+              end
+
+              def update(agent_id, observation)
+                model = get_or_create(agent_id)
+                model.update_from_observation(observation)
+                evict_if_needed
+                model
+              end
+
+              def predict(agent_id, scenario)
+                model = get(agent_id)
+                return nil unless model
+
+                model.predict_reaction(scenario)
+              end
+
+              def decay_all
+                count = 0
+                @models.each_value do |model|
+                  model.decay
+                  count += 1
+                end
+                count
+              end
+
+              def remove_stale
+                stale_keys = @models.select { |_, m| m.stale? && m.interaction_history.empty? }.keys
+                stale_keys.each { |k| @models.delete(k) }
+                stale_keys.size
+              end
+
+              def all_models
+                @models.values
+              end
+
+              def by_cooperation(stance)
+                @models.values.select { |m| m.cooperation_stance == stance }
+              end
+
+              def by_emotion(emotion)
+                @models.values.select { |m| m.emotional_state == emotion }
+              end
+
+              def size
+                @models.size
+              end
+
+              def clear
+                @models.clear
+              end
+
+              private
+
+              def evict_if_needed
+                return unless @models.size > Constants::MAX_TRACKED_AGENTS
+
+                oldest = @models.min_by { |_, m| m.updated_at }
+                @models.delete(oldest[0]) if oldest
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/empathy/runners/empathy.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Empathy
+          module Runners
+            module Empathy
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def observe_agent(agent_id:, observation: {}, **)
+                model = model_store.update(agent_id, observation)
+                Legion::Logging.debug "[empathy] observed: agent=#{agent_id} emotion=#{model.emotional_state} " \
+                                      "cooperation=#{model.cooperation_stance}"
+
+                {
+                  agent_id:           agent_id,
+                  emotional_state:    model.emotional_state,
+                  cooperation_stance: model.cooperation_stance,
+                  believed_goal:      model.believed_goal,
+                  confidence:         model.confidence_level
+                }
+              end
+
+              def predict_reaction(agent_id:, scenario: {}, **)
+                prediction = model_store.predict(agent_id, scenario)
+
+                if prediction
+                  Legion::Logging.debug "[empathy] prediction: agent=#{agent_id} response=#{prediction[:likely_response]} " \
+                                        "confidence=#{prediction[:confidence].round(2)}"
+                  prediction
+                else
+                  Legion::Logging.debug "[empathy] no model for agent=#{agent_id}"
+                  { error: :no_model, agent_id: agent_id }
+                end
+              end
+
+              def record_outcome(agent_id:, prediction_id:, actual_response:, accurate:, **)
+                model = model_store.get(agent_id)
+                return { error: :no_model } unless model
+
+                result = model.record_prediction_outcome(
+                  prediction_id:   prediction_id,
+                  actual_response: actual_response,
+                  accurate:        accurate
+                )
+
+                if result.nil?
+                  { error: :prediction_not_found }
+                else
+                  Legion::Logging.info "[empathy] outcome recorded: agent=#{agent_id} accurate=#{accurate} " \
+                                       "accuracy=#{model.prediction_accuracy&.round(2)}"
+                  { agent_id: agent_id, accurate: accurate, current_accuracy: model.prediction_accuracy }
+                end
+              end
+
+              def perspective_take(agent_id:, **)
+                model = model_store.get(agent_id)
+                return { error: :no_model, agent_id: agent_id } unless model
+
+                narrative = build_perspective_narrative(model)
+                Legion::Logging.debug "[empathy] perspective: agent=#{agent_id}"
+
+                {
+                  agent_id:  agent_id,
+                  narrative: narrative,
+                  model:     model.to_h
+                }
+              end
+
+              def social_landscape(**)
+                models = model_store.all_models
+                cooperative = model_store.by_cooperation(:cooperative).size
+                competitive = model_store.by_cooperation(:competitive).size
+                stressed = model_store.by_emotion(:stressed).size + model_store.by_emotion(:frustrated).size
+
+                Legion::Logging.debug "[empathy] landscape: agents=#{models.size} cooperative=#{cooperative} " \
+                                      "competitive=#{competitive} stressed=#{stressed}"
+
+                {
+                  tracked_agents:    models.size,
+                  cooperative_count: cooperative,
+                  competitive_count: competitive,
+                  stressed_count:    stressed,
+                  stances:           stance_distribution(models),
+                  emotions:          emotion_distribution(models),
+                  overall_climate:   assess_climate(cooperative, competitive, stressed, models.size)
+                }
+              end
+
+              def decay_models(**)
+                decayed = model_store.decay_all
+                removed = model_store.remove_stale
+                Legion::Logging.debug "[empathy] decay: updated=#{decayed} stale_removed=#{removed}"
+                { decayed: decayed, stale_removed: removed }
+              end
+
+              def empathy_stats(**)
+                models = model_store.all_models
+                accuracies = models.filter_map(&:prediction_accuracy)
+
+                {
+                  tracked_agents:      model_store.size,
+                  total_predictions:   models.sum { |m| m.predictions.size },
+                  avg_accuracy:        accuracies.empty? ? nil : (accuracies.sum / accuracies.size).round(3),
+                  stale_models:        models.count(&:stale?),
+                  cooperation_stances: stance_distribution(models)
+                }
+              end
+
+              private
+
+              def model_store
+                @model_store ||= Helpers::ModelStore.new
+              end
+
+              def build_perspective_narrative(model)
+                parts = []
+                parts << "Agent #{model.agent_id}"
+
+                parts << if model.believed_goal
+                           "appears to be pursuing #{model.believed_goal}"
+                         else
+                           'has no clearly observed goal'
+                         end
+
+                parts << "and seems #{model.emotional_state}" unless model.emotional_state == :unknown
+                parts << "with a #{model.cooperation_stance} stance" unless model.cooperation_stance == :unknown
+
+                parts << "(model is stale — last updated #{((Time.now.utc - model.updated_at) / 60).round(1)} minutes ago)" if model.stale?
+
+                parts << "— prediction accuracy: #{(model.prediction_accuracy * 100).round(1)}%" if model.prediction_accuracy
+
+                parts.join(' ')
+              end
+
+              def stance_distribution(models)
+                dist = Hash.new(0)
+                models.each { |m| dist[m.cooperation_stance] += 1 }
+                dist
+              end
+
+              def emotion_distribution(models)
+                dist = Hash.new(0)
+                models.each { |m| dist[m.emotional_state] += 1 }
+                dist
+              end
+
+              def assess_climate(cooperative, competitive, stressed, total)
+                return :empty if total.zero?
+
+                coop_ratio = cooperative.to_f / total
+                stress_ratio = stressed.to_f / total
+
+                if coop_ratio > 0.6
+                  :harmonious
+                elsif stress_ratio > 0.4
+                  :tense
+                elsif competitive > cooperative
+                  :adversarial
+                else
+                  :neutral
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/empathy/version.rb

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

data/lib/legion/extensions/agentic/affect/empathy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'legion/extensions/agentic/affect/empathy/version'
+require 'legion/extensions/agentic/affect/empathy/helpers/constants'
+require 'legion/extensions/agentic/affect/empathy/helpers/mental_model'
+require 'legion/extensions/agentic/affect/empathy/helpers/model_store'
+require 'legion/extensions/agentic/affect/empathy/runners/empathy'
+require 'legion/extensions/agentic/affect/empathy/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Empathy
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/fatigue/client.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/fatigue/helpers/constants'
+require 'legion/extensions/agentic/affect/fatigue/helpers/energy_model'
+require 'legion/extensions/agentic/affect/fatigue/helpers/fatigue_store'
+require 'legion/extensions/agentic/affect/fatigue/runners/fatigue'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Fatigue
+          class Client
+            include Runners::Fatigue
+
+            attr_reader :fatigue_store
+
+            def initialize(fatigue_store: nil, **)
+              @fatigue_store = fatigue_store || Helpers::FatigueStore.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/fatigue/helpers/constants.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Fatigue
+          module Helpers
+            module Constants
+              MAX_ENERGY = 1.0
+              MIN_ENERGY = 0.0
+
+              RESTING_RECOVERY_RATE       = 0.02
+              ACTIVE_DRAIN_RATE           = 0.01
+              COGNITIVE_DRAIN_MULTIPLIER  = 1.5
+              EMOTIONAL_DRAIN_MULTIPLIER  = 1.3
+
+              FATIGUE_LEVELS = {
+                fresh:     0.8,
+                alert:     0.6,
+                tired:     0.4,
+                exhausted: 0.2,
+                depleted:  0.0
+              }.freeze
+
+              PERFORMANCE_DEGRADATION = {
+                fresh:     1.0,
+                alert:     0.95,
+                tired:     0.8,
+                exhausted: 0.6,
+                depleted:  0.3
+              }.freeze
+
+              RECOVERY_MODES = %i[active_rest light_duty full_rest sleep].freeze
+
+              RECOVERY_RATES = {
+                active_rest: 0.005,
+                light_duty:  0.01,
+                full_rest:   0.02,
+                sleep:       0.05
+              }.freeze
+
+              REST_THRESHOLD      = 0.3
+              CRITICAL_THRESHOLD  = 0.15
+              SECOND_WIND_CHANCE  = 0.05
+              BURNOUT_THRESHOLD   = 50
+              MAX_HISTORY         = 100
+            end
+          end
+        end
+      end
+    end
+  end
+end