lex-agentic-affect 0.1.0

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Interoception
+          module Runners
+            module Interoception
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def report_vital(channel:, value:, **)
+                smoothed = body_budget.report_vital(channel: channel, value: value.to_f)
+                deviation = body_budget.deviation_for(channel)
+                Legion::Logging.debug "[interoception] vital: channel=#{channel} raw=#{value} " \
+                                      "smoothed=#{smoothed.round(3)} deviation=#{deviation.round(3)}"
+                {
+                  success:   true,
+                  channel:   channel,
+                  smoothed:  smoothed.round(4),
+                  deviation: deviation.round(4),
+                  label:     body_budget.vital_label(channel)
+                }
+              end
+
+              def create_somatic_marker(action:, domain:, valence:, strength: 1.0, **)
+                marker = body_budget.create_marker(action: action, domain: domain, valence: valence.to_f, strength: strength.to_f)
+                Legion::Logging.debug "[interoception] marker: action=#{action} domain=#{domain} " \
+                                      "valence=#{marker.valence.round(2)} label=#{marker.label}"
+                { success: true, marker: marker.to_h }
+              end
+
+              def query_bias(action:, domain: nil, **)
+                bias = body_budget.bias_for_action(action: action, domain: domain)
+                label = if bias > Helpers::Constants::MARKER_POSITIVE_THRESHOLD * Helpers::Constants::MARKER_INFLUENCE
+                          :approach
+                        elsif bias < Helpers::Constants::MARKER_NEGATIVE_THRESHOLD * Helpers::Constants::MARKER_INFLUENCE
+                          :avoid
+                        else
+                          :neutral
+                        end
+                Legion::Logging.debug "[interoception] bias: action=#{action} domain=#{domain} bias=#{bias.round(3)} label=#{label}"
+                { success: true, action: action, domain: domain, bias: bias.round(4), label: label }
+              end
+
+              def reinforce_somatic(action:, domain: nil, amount: 0.1, **)
+                body_budget.reinforce_markers(action: action, domain: domain, amount: amount.to_f)
+                Legion::Logging.debug "[interoception] reinforce: action=#{action} domain=#{domain} amount=#{amount}"
+                { success: true, action: action, domain: domain }
+              end
+
+              def deviating_vitals(**)
+                deviations = body_budget.deviating_channels
+                Legion::Logging.debug "[interoception] deviating: count=#{deviations.size}"
+                { success: true, deviations: deviations, count: deviations.size }
+              end
+
+              def body_status(**)
+                health = body_budget.overall_health
+                label = body_budget.body_budget_label
+                Legion::Logging.debug "[interoception] status: health=#{health.round(3)} label=#{label}"
+                {
+                  success:  true,
+                  health:   health.round(4),
+                  label:    label,
+                  channels: body_budget.channel_count,
+                  markers:  body_budget.marker_count
+                }
+              end
+
+              def update_interoception(**)
+                body_budget.decay_markers
+                health = body_budget.overall_health
+                Legion::Logging.debug "[interoception] tick: health=#{health.round(3)} " \
+                                      "channels=#{body_budget.channel_count} markers=#{body_budget.marker_count}"
+                {
+                  success:  true,
+                  health:   health.round(4),
+                  label:    body_budget.body_budget_label,
+                  channels: body_budget.channel_count,
+                  markers:  body_budget.marker_count
+                }
+              end
+
+              def interoception_stats(**)
+                { success: true, stats: body_budget.to_h }
+              end
+
+              private
+
+              def body_budget
+                @body_budget ||= Helpers::BodyBudget.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'legion/extensions/agentic/affect/interoception/version'
+require 'legion/extensions/agentic/affect/interoception/helpers/constants'
+require 'legion/extensions/agentic/affect/interoception/helpers/somatic_marker'
+require 'legion/extensions/agentic/affect/interoception/helpers/body_budget'
+require 'legion/extensions/agentic/affect/interoception/runners/interoception'
+require 'legion/extensions/agentic/affect/interoception/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Interoception
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Mood
+          module Helpers
+            module Constants
+              # Mood states (valence x arousal quadrants + neutral)
+              MOOD_STATES = %i[
+                serene
+                content
+                curious
+                energized
+                anxious
+                frustrated
+                melancholic
+                flat
+                neutral
+              ].freeze
+
+              # Mood dimensions
+              DIMENSIONS = %i[valence arousal energy stability].freeze
+
+              # EMA alpha for mood updates (slow — mood is resistant to change)
+              MOOD_ALPHA = 0.1
+
+              # How many ticks before mood recalculates
+              UPDATE_INTERVAL = 5
+
+              # Mood history capacity
+              MAX_MOOD_HISTORY = 200
+
+              # Dimension ranges for mood classification
+              MOOD_CLASSIFICATION = {
+                serene:      { valence: (0.3..), arousal: (..0.3), energy: (0.3..) },
+                content:     { valence: (0.3..), arousal: (0.3..0.6) },
+                curious:     { valence: (0.1..), arousal: (0.4..0.7), energy: (0.4..) },
+                energized:   { valence: (0.2..), arousal: (0.7..) },
+                anxious:     { valence: (..0.3), arousal: (0.6..) },
+                frustrated:  { valence: (..-0.1), arousal: (0.4..0.8) },
+                melancholic: { valence: (..-0.1), arousal: (..0.4) },
+                flat:        { valence: (-0.2..0.2), arousal: (..0.3), energy: (..0.3) }
+              }.freeze
+
+              # Modulation effects: how each mood biases cognitive processing
+              MOOD_MODULATIONS = {
+                serene:      { attention_threshold: -0.1, risk_tolerance: 0.1, curiosity_boost: 0.0 },
+                content:     { attention_threshold: 0.0, risk_tolerance: 0.05, curiosity_boost: 0.05 },
+                curious:     { attention_threshold: -0.15, risk_tolerance: 0.1, curiosity_boost: 0.2 },
+                energized:   { attention_threshold: -0.05, risk_tolerance: 0.15, curiosity_boost: 0.1 },
+                anxious:     { attention_threshold: -0.2, risk_tolerance: -0.2, curiosity_boost: -0.1 },
+                frustrated:  { attention_threshold: 0.1, risk_tolerance: -0.1, curiosity_boost: -0.15 },
+                melancholic: { attention_threshold: 0.15, risk_tolerance: -0.15, curiosity_boost: -0.2 },
+                flat:        { attention_threshold: 0.2, risk_tolerance: 0.0, curiosity_boost: -0.1 },
+                neutral:     { attention_threshold: 0.0, risk_tolerance: 0.0, curiosity_boost: 0.0 }
+              }.freeze
+
+              # Mood inertia — how resistant each mood is to change
+              MOOD_INERTIA = {
+                serene:      0.7,
+                content:     0.6,
+                curious:     0.4,
+                energized:   0.3,
+                anxious:     0.5,
+                frustrated:  0.5,
+                melancholic: 0.8,
+                flat:        0.9,
+                neutral:     0.2
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/mood/helpers/mood_state.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Mood
+          module Helpers
+            class MoodState
+              attr_reader :current_mood, :valence, :arousal, :energy, :stability, :history, :tick_counter
+
+              def initialize
+                @valence = 0.5
+                @arousal = 0.3
+                @energy = 0.5
+                @stability = 0.8
+                @current_mood = :neutral
+                @history = []
+                @tick_counter = 0
+              end
+
+              def update(inputs)
+                @tick_counter += 1
+                return @current_mood unless (@tick_counter % Constants::UPDATE_INTERVAL).zero?
+
+                alpha = effective_alpha
+                @valence = ema(@valence, inputs[:valence] || @valence, alpha)
+                @arousal = ema(@arousal, inputs[:arousal] || @arousal, alpha)
+                @energy = ema(@energy, inputs[:energy] || @energy, alpha)
+
+                compute_stability
+                classify_mood
+                record_history
+
+                @current_mood
+              end
+
+              def modulations
+                Constants::MOOD_MODULATIONS.fetch(@current_mood, Constants::MOOD_MODULATIONS[:neutral])
+              end
+
+              def inertia
+                Constants::MOOD_INERTIA.fetch(@current_mood, 0.5)
+              end
+
+              def duration_in_current_mood
+                return 0 if @history.empty?
+
+                consecutive = 0
+                @history.reverse_each do |entry|
+                  break unless entry[:mood] == @current_mood
+
+                  consecutive += 1
+                end
+                consecutive * Constants::UPDATE_INTERVAL
+              end
+
+              def mood_trend(window: 20)
+                recent = @history.last(window)
+                return :insufficient_data if recent.size < 3
+
+                valences = recent.map { |h| h[:valence] }
+                avg_first = valences[0...(valences.size / 2)].sum / (valences.size / 2).to_f
+                avg_second = valences[(valences.size / 2)..].sum / (valences.size - (valences.size / 2)).to_f
+
+                delta = avg_second - avg_first
+                if delta > 0.05
+                  :improving
+                elsif delta < -0.05
+                  :declining
+                else
+                  :stable
+                end
+              end
+
+              def to_h
+                {
+                  current_mood: @current_mood,
+                  valence:      @valence.round(3),
+                  arousal:      @arousal.round(3),
+                  energy:       @energy.round(3),
+                  stability:    @stability.round(3),
+                  modulations:  modulations,
+                  inertia:      inertia,
+                  duration:     duration_in_current_mood,
+                  trend:        mood_trend,
+                  history_size: @history.size
+                }
+              end
+
+              private
+
+              def effective_alpha
+                base_alpha = Constants::MOOD_ALPHA
+                current_inertia = inertia
+                base_alpha * (1.0 - (current_inertia * 0.5))
+              end
+
+              def ema(current, observed, alpha)
+                ((current * (1.0 - alpha)) + (observed * alpha)).clamp(0.0, 1.0)
+              end
+
+              def compute_stability
+                return if @history.size < 3
+
+                recent_moods = @history.last(10).map { |h| h[:mood] }
+                unique_moods = recent_moods.uniq.size
+                @stability = (1.0 - (unique_moods.to_f / [recent_moods.size, 1].max)).clamp(0.0, 1.0)
+              end
+
+              def classify_mood
+                best_match = :neutral
+                best_score = 0
+
+                Constants::MOOD_CLASSIFICATION.each do |mood, criteria|
+                  score = match_score(criteria)
+                  if score > best_score
+                    best_score = score
+                    best_match = mood
+                  end
+                end
+
+                @current_mood = best_match
+              end
+
+              def match_score(criteria)
+                matched = 0
+                total = criteria.size
+
+                matched += 1 if criteria[:valence]&.cover?(@valence)
+                matched += 1 if criteria[:arousal]&.cover?(@arousal)
+                matched += 1 if criteria[:energy]&.cover?(@energy)
+
+                matched.to_f / [total, 1].max
+              end
+
+              def record_history
+                @history << {
+                  mood:      @current_mood,
+                  valence:   @valence,
+                  arousal:   @arousal,
+                  energy:    @energy,
+                  stability: @stability,
+                  at:        Time.now.utc
+                }
+                @history = @history.last(Constants::MAX_MOOD_HISTORY)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Mood
+          module Runners
+            module Mood
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def update_mood(tick_results: {}, **)
+                inputs = extract_mood_inputs(tick_results)
+                mood_state.update(inputs)
+
+                Legion::Logging.debug "[mood] #{mood_state.current_mood} (v=#{mood_state.valence.round(2)} " \
+                                      "a=#{mood_state.arousal.round(2)} e=#{mood_state.energy.round(2)})"
+
+                {
+                  mood:        mood_state.current_mood,
+                  valence:     mood_state.valence,
+                  arousal:     mood_state.arousal,
+                  energy:      mood_state.energy,
+                  stability:   mood_state.stability,
+                  modulations: mood_state.modulations
+                }
+              end
+
+              def current_mood(**)
+                Legion::Logging.debug "[mood] query: #{mood_state.current_mood}"
+                mood_state.to_h
+              end
+
+              def mood_modulation(parameter:, **)
+                mods = mood_state.modulations
+                value = mods[parameter.to_sym]
+
+                Legion::Logging.debug "[mood] modulation: #{parameter}=#{value} (mood=#{mood_state.current_mood})"
+
+                {
+                  parameter:    parameter.to_sym,
+                  modulation:   value || 0.0,
+                  current_mood: mood_state.current_mood
+                }
+              end
+
+              def mood_history(limit: 20, **)
+                history = mood_state.history.last(limit)
+                {
+                  entries: history.map { |h| { mood: h[:mood], valence: h[:valence], arousal: h[:arousal], at: h[:at] } },
+                  trend:   mood_state.mood_trend(window: limit),
+                  count:   history.size
+                }
+              end
+
+              def mood_stats(**)
+                history = mood_state.history
+                mood_counts = Hash.new(0)
+                history.each { |h| mood_counts[h[:mood]] += 1 }
+
+                dominant = mood_counts.max_by { |_, v| v }&.first
+
+                {
+                  current_mood:      mood_state.current_mood,
+                  stability:         mood_state.stability,
+                  duration:          mood_state.duration_in_current_mood,
+                  trend:             mood_state.mood_trend,
+                  dominant_mood:     dominant,
+                  mood_distribution: mood_counts,
+                  ticks_processed:   mood_state.tick_counter
+                }
+              end
+
+              private
+
+              def mood_state
+                @mood_state ||= Helpers::MoodState.new
+              end
+
+              def extract_mood_inputs(tick_results)
+                inputs = {}
+
+                emotion = tick_results[:emotional_evaluation]
+                if emotion.is_a?(Hash)
+                  inputs[:valence] = normalize_emotional_valence(emotion)
+                  inputs[:arousal] = emotion[:arousal] || emotion[:magnitude] || 0.3
+                end
+
+                inputs[:energy] = extract_energy(tick_results)
+
+                inputs
+              end
+
+              def normalize_emotional_valence(emotion)
+                if emotion[:valence].is_a?(Hash)
+                  dims = emotion[:valence]
+                  positive = (dims[:importance] || 0) + (dims[:familiarity] || 0)
+                  negative = (dims[:urgency] || 0) + (dims[:novelty] || 0)
+                  ((positive - negative + 1.0) / 2.0).clamp(0.0, 1.0)
+                elsif emotion[:magnitude].is_a?(Numeric)
+                  (emotion[:magnitude] + 0.5).clamp(0.0, 1.0)
+                else
+                  0.5
+                end
+              end
+
+              def extract_energy(tick_results)
+                load = tick_results[:elapsed]
+                budget = tick_results[:budget]
+                return 0.5 unless load.is_a?(Numeric) && budget.is_a?(Numeric) && budget.positive?
+
+                utilization = load / budget
+                (1.0 - utilization).clamp(0.0, 1.0)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/mood/version'
+require 'legion/extensions/agentic/affect/mood/helpers/constants'
+require 'legion/extensions/agentic/affect/mood/helpers/mood_state'
+require 'legion/extensions/agentic/affect/mood/runners/mood'
+require 'legion/extensions/agentic/affect/mood/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Mood
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Motivation
+          module Helpers
+            module Constants
+              # Drive types based on Self-Determination Theory + survival/obligation
+              DRIVE_TYPES = %i[autonomy competence relatedness novelty obligation survival].freeze
+
+              # Motivation operating modes (approach/avoidance model)
+              MOTIVATION_MODES = %i[approach avoidance maintenance dormant].freeze
+
+              # EMA alpha for drive level tracking (slow adaptation)
+              DRIVE_ALPHA = 0.1
+
+              # Intrinsic drives (Self-Determination Theory: autonomy, competence, relatedness + novelty)
+              INTRINSIC_DRIVES = %i[autonomy competence relatedness novelty].freeze
+
+              # Extrinsic drives (external pressure: obligation, survival)
+              EXTRINSIC_DRIVES = %i[obligation survival].freeze
+
+              # Per-tick drive decay rate
+              DRIVE_DECAY_RATE = 0.02
+
+              # Maximum goals tracked simultaneously
+              MAX_GOALS = 50
+
+              # Above this overall level, agent is in approach mode
+              APPROACH_THRESHOLD = 0.6
+
+              # Below this, agent is in avoidance mode
+              AVOIDANCE_THRESHOLD = 0.3
+
+              # Below this across individual drives, drive is in burnout
+              BURNOUT_THRESHOLD = 0.15
+
+              # Below this across ALL drives, agent is amotivated
+              AMOTIVATION_THRESHOLD = 0.2
+            end
+          end
+        end
+      end
+    end
+  end
+end