lex-agentic-affect 0.1.0

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Motivation
+          module Helpers
+            class DriveState
+              attr_reader :drives
+
+              def initialize
+                @drives = Constants::DRIVE_TYPES.to_h do |type|
+                  [type, { level: 0.5, satisfied: false, last_signal: nil }]
+                end
+              end
+
+              def update_drive(type, signal)
+                return unless Constants::DRIVE_TYPES.include?(type)
+
+                clamped = signal.clamp(0.0, 1.0)
+                current = @drives[type][:level]
+                @drives[type][:level]       = ema(current, clamped, Constants::DRIVE_ALPHA)
+                @drives[type][:satisfied]   = @drives[type][:level] >= 0.6
+                @drives[type][:last_signal] = Time.now.utc
+              end
+
+              def drive_level(type)
+                return 0.0 unless Constants::DRIVE_TYPES.include?(type)
+
+                @drives[type][:level]
+              end
+
+              def satisfied?(type)
+                return false unless Constants::DRIVE_TYPES.include?(type)
+
+                @drives[type][:satisfied]
+              end
+
+              def intrinsic_average
+                levels = Constants::INTRINSIC_DRIVES.map { |d| @drives[d][:level] }
+                mean(levels)
+              end
+
+              def extrinsic_average
+                levels = Constants::EXTRINSIC_DRIVES.map { |d| @drives[d][:level] }
+                mean(levels)
+              end
+
+              def overall_level
+                all_levels = @drives.values.map { |d| d[:level] }
+                mean(all_levels)
+              end
+
+              def current_mode
+                level = overall_level
+                if level >= Constants::APPROACH_THRESHOLD
+                  :approach
+                elsif level <= Constants::BURNOUT_THRESHOLD
+                  :dormant
+                elsif level <= Constants::AVOIDANCE_THRESHOLD
+                  :avoidance
+                else
+                  :maintenance
+                end
+              end
+
+              def decay_all
+                @drives.each_key do |type|
+                  current = @drives[type][:level]
+                  decayed = [current - Constants::DRIVE_DECAY_RATE, 0.0].max
+                  @drives[type][:level]     = decayed
+                  @drives[type][:satisfied] = decayed >= 0.6
+                end
+              end
+
+              def amotivated?
+                @drives.values.all? { |d| d[:level] < Constants::AMOTIVATION_THRESHOLD }
+              end
+
+              private
+
+              def ema(current, observed, alpha)
+                (current * (1.0 - alpha)) + (observed * alpha)
+              end
+
+              def mean(values)
+                return 0.0 if values.empty?
+
+                values.sum / values.size.to_f
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Motivation
+          module Helpers
+            class MotivationStore
+              attr_reader :drive_state, :goal_motivations
+
+              def initialize(drive_state: nil)
+                @drive_state      = drive_state || DriveState.new
+                @goal_motivations = {}
+                @low_motivation_ticks = 0
+              end
+
+              def commit_goal(goal_id, drives)
+                valid_drives = Array(drives).select { |d| Constants::DRIVE_TYPES.include?(d) }
+                return false if valid_drives.empty?
+
+                trim_goals
+                @goal_motivations[goal_id] = {
+                  drives:       valid_drives,
+                  energy:       goal_energy_for(valid_drives),
+                  committed:    true,
+                  committed_at: Time.now.utc
+                }
+                true
+              end
+
+              def release_goal(goal_id)
+                @goal_motivations.delete(goal_id)
+                true
+              end
+
+              def goal_energy(goal_id)
+                entry = @goal_motivations[goal_id]
+                return 0.0 unless entry
+
+                entry[:energy] = goal_energy_for(entry[:drives])
+                entry[:energy]
+              end
+
+              def most_motivated_goal
+                return nil if @goal_motivations.empty?
+
+                refreshed = @goal_motivations.transform_values do |entry|
+                  entry.merge(energy: goal_energy_for(entry[:drives]))
+                end
+
+                best_id, best_entry = refreshed.max_by { |_, v| v[:energy] }
+                return nil unless best_id
+
+                { goal_id: best_id, energy: best_entry[:energy].round(4), drives: best_entry[:drives] }
+              end
+
+              def burnout_check
+                overall = @drive_state.overall_level
+                if overall < Constants::BURNOUT_THRESHOLD
+                  @low_motivation_ticks += 1
+                else
+                  @low_motivation_ticks = 0
+                end
+
+                {
+                  burnout:              @low_motivation_ticks >= 10,
+                  low_motivation_ticks: @low_motivation_ticks,
+                  overall_level:        overall.round(4)
+                }
+              end
+
+              def stats
+                {
+                  overall_level:        @drive_state.overall_level.round(4),
+                  current_mode:         @drive_state.current_mode,
+                  intrinsic_average:    @drive_state.intrinsic_average.round(4),
+                  extrinsic_average:    @drive_state.extrinsic_average.round(4),
+                  amotivated:           @drive_state.amotivated?,
+                  goal_count:           @goal_motivations.size,
+                  low_motivation_ticks: @low_motivation_ticks
+                }
+              end
+
+              private
+
+              def goal_energy_for(drives)
+                return 0.0 if drives.empty?
+
+                total = drives.sum { |d| @drive_state.drive_level(d) }
+                (total / drives.size.to_f).clamp(0.0, 1.0)
+              end
+
+              def trim_goals
+                return unless @goal_motivations.size >= Constants::MAX_GOALS
+
+                oldest_key = @goal_motivations.min_by { |_, v| v[:committed_at] }&.first
+                @goal_motivations.delete(oldest_key) if oldest_key
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Motivation
+          module Runners
+            module Motivation
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def update_motivation(tick_results: {}, **)
+                extract_drive_signals(tick_results)
+                motivation_store.drive_state.decay_all
+                burnout = motivation_store.burnout_check
+                mode    = motivation_store.drive_state.current_mode
+
+                Legion::Logging.debug "[motivation] mode=#{mode} " \
+                                      "overall=#{motivation_store.drive_state.overall_level.round(3)} " \
+                                      "amotivated=#{motivation_store.drive_state.amotivated?}"
+
+                {
+                  mode:              mode,
+                  overall_level:     motivation_store.drive_state.overall_level.round(4),
+                  intrinsic_average: motivation_store.drive_state.intrinsic_average.round(4),
+                  extrinsic_average: motivation_store.drive_state.extrinsic_average.round(4),
+                  amotivated:        motivation_store.drive_state.amotivated?,
+                  burnout:           burnout[:burnout]
+                }
+              end
+
+              def signal_drive(drive:, signal:, **)
+                drive_sym = drive.to_sym
+                return { success: false, error: "unknown drive: #{drive}" } unless Helpers::Constants::DRIVE_TYPES.include?(drive_sym)
+
+                motivation_store.drive_state.update_drive(drive_sym, signal.to_f)
+                level = motivation_store.drive_state.drive_level(drive_sym)
+
+                Legion::Logging.debug "[motivation] drive signal: #{drive_sym}=#{level.round(3)}"
+                { success: true, drive: drive_sym, level: level.round(4) }
+              end
+
+              def commit_to_goal(goal_id:, drives:, **)
+                drive_syms = Array(drives).map(&:to_sym)
+                result = motivation_store.commit_goal(goal_id, drive_syms)
+
+                if result
+                  energy = motivation_store.goal_energy(goal_id)
+                  Legion::Logging.info "[motivation] committed goal=#{goal_id} energy=#{energy.round(3)}"
+                  { success: true, goal_id: goal_id, energy: energy.round(4) }
+                else
+                  Legion::Logging.warn "[motivation] commit_goal rejected: no valid drives for #{goal_id}"
+                  { success: false, error: 'no valid drives provided' }
+                end
+              end
+
+              def release_goal(goal_id:, **)
+                motivation_store.release_goal(goal_id)
+                Legion::Logging.debug "[motivation] released goal=#{goal_id}"
+                { success: true, goal_id: goal_id }
+              end
+
+              def motivation_for(goal_id:, **)
+                energy = motivation_store.goal_energy(goal_id)
+                Legion::Logging.debug "[motivation] motivation_for goal=#{goal_id} energy=#{energy.round(3)}"
+                { goal_id: goal_id, energy: energy.round(4) }
+              end
+
+              def most_motivated_goal(**)
+                result = motivation_store.most_motivated_goal
+                Legion::Logging.debug "[motivation] most_motivated_goal=#{result&.fetch(:goal_id, nil)}"
+                result || { goal_id: nil, energy: 0.0, drives: [] }
+              end
+
+              def drive_status(**)
+                drives = motivation_store.drive_state.drives.transform_values do |d|
+                  { level: d[:level].round(4), satisfied: d[:satisfied] }
+                end
+
+                Legion::Logging.debug '[motivation] drive_status'
+                {
+                  drives:  drives,
+                  mode:    motivation_store.drive_state.current_mode,
+                  overall: motivation_store.drive_state.overall_level.round(4)
+                }
+              end
+
+              def motivation_stats(**)
+                Legion::Logging.debug '[motivation] stats'
+                motivation_store.stats
+              end
+
+              private
+
+              def motivation_store
+                @motivation_store ||= Helpers::MotivationStore.new
+              end
+
+              def extract_drive_signals(tick_results)
+                extract_autonomy_signal(tick_results)
+                extract_competence_signal(tick_results)
+                extract_relatedness_signal(tick_results)
+                extract_novelty_signal(tick_results)
+                extract_obligation_signal(tick_results)
+                extract_survival_signal(tick_results)
+              end
+
+              def extract_autonomy_signal(tick_results)
+                consent_tier = tick_results.dig(:consent, :tier)
+                return unless consent_tier
+
+                signal = case consent_tier
+                         when :autonomous then 1.0
+                         when :collaborate then 0.7
+                         when :consult     then 0.4
+                         else 0.1
+                         end
+                motivation_store.drive_state.update_drive(:autonomy, signal)
+              end
+
+              def extract_competence_signal(tick_results)
+                accuracy = tick_results.dig(:prediction_engine, :accuracy)
+                return unless accuracy
+
+                motivation_store.drive_state.update_drive(:competence, accuracy.to_f)
+              end
+
+              def extract_relatedness_signal(tick_results)
+                trust_level = tick_results.dig(:trust, :overall_level)
+                return unless trust_level
+
+                motivation_store.drive_state.update_drive(:relatedness, trust_level.to_f)
+              end
+
+              def extract_novelty_signal(tick_results)
+                novel = tick_results.dig(:memory_retrieval, :novel_traces)
+                return unless novel
+
+                signal = novel.positive? ? [novel.to_f / 10.0, 1.0].min : 0.1
+                motivation_store.drive_state.update_drive(:novelty, signal)
+              end
+
+              def extract_obligation_signal(tick_results)
+                pending = tick_results.dig(:scheduler, :pending_tasks)
+                return unless pending
+
+                signal = pending.positive? ? [pending.to_f / 20.0, 1.0].min : 0.0
+                motivation_store.drive_state.update_drive(:obligation, signal)
+              end
+
+              def extract_survival_signal(tick_results)
+                extinction_level = tick_results.dig(:extinction, :level)
+                return unless extinction_level
+
+                signal = extinction_level.to_f / 4.0
+                motivation_store.drive_state.update_drive(:survival, signal)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/motivation/version'
+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'
+require 'legion/extensions/agentic/affect/motivation/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Motivation
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/reappraisal/actors/auto_regulate.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Reappraisal
+          module Actor
+            class AutoRegulate < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Affect::Reappraisal::Runners::CognitiveReappraisal
+              end
+
+              def runner_function
+                'regulate_pending_events'
+              end
+
+              def time
+                300
+              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/affect/reappraisal/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/reappraisal/helpers/constants'
+require 'legion/extensions/agentic/affect/reappraisal/helpers/emotional_event'
+require 'legion/extensions/agentic/affect/reappraisal/helpers/reappraisal_engine'
+require 'legion/extensions/agentic/affect/reappraisal/runners/cognitive_reappraisal'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Reappraisal
+          class Client
+            include Runners::CognitiveReappraisal
+
+            def initialize(engine: nil, **)
+              @reappraisal_engine = engine || Helpers::ReappraisalEngine.new
+            end
+
+            private
+
+            attr_reader :reappraisal_engine
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Reappraisal
+          module Helpers
+            module Constants
+              MAX_EVENTS       = 300
+              MAX_REAPPRAISALS = 500
+
+              STRATEGIES = %i[
+                reinterpretation
+                distancing
+                benefit_finding
+                normalizing
+                perspective_taking
+                temporal_distancing
+              ].freeze
+
+              STRATEGY_EFFECTIVENESS = {
+                reinterpretation:    0.25,
+                distancing:          0.15,
+                benefit_finding:     0.20,
+                normalizing:         0.12,
+                perspective_taking:  0.18,
+                temporal_distancing: 0.10
+              }.freeze
+
+              VALENCE_LABELS = {
+                (0.5..)       => :positive,
+                (0.1...0.5)   => :mildly_positive,
+                (-0.1...0.1)  => :neutral,
+                (-0.5...-0.1) => :mildly_negative,
+                (..-0.5)      => :negative
+              }.freeze
+
+              INTENSITY_LABELS = {
+                (0.8..)     => :overwhelming,
+                (0.6...0.8) => :intense,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :mild,
+                (..0.2)     => :faint
+              }.freeze
+
+              REGULATION_LABELS = {
+                (0.8..)     => :excellent,
+                (0.6...0.8) => :good,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :poor,
+                (..0.2)     => :minimal
+              }.freeze
+
+              NEGATIVE_VALENCE_THRESHOLD      = -0.3
+              HIGH_INTENSITY_THRESHOLD        = 0.7
+              REAPPRAISAL_DIFFICULTY_MULTIPLIER = 0.5
+
+              module_function
+
+              def label_for(value, label_map)
+                label_map.find { |range, _label| range.cover?(value) }&.last || :unknown
+              end
+
+              def valid_strategy?(strategy)
+                STRATEGIES.include?(strategy)
+              end
+
+              def clamp(value, min = -1.0, max = 1.0)
+                value.clamp(min, max)
+              end
+
+              def clamp_intensity(value)
+                value.clamp(0.0, 1.0)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/reappraisal/helpers/emotional_event.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Reappraisal
+          module Helpers
+            class EmotionalEvent
+              include Constants
+
+              attr_reader :id, :content, :initial_valence, :current_valence,
+                          :initial_intensity, :current_intensity, :appraisal,
+                          :reappraisal_count, :created_at
+
+              def initialize(content:, valence:, intensity:, appraisal:)
+                @id                = SecureRandom.uuid
+                @content           = content
+                @initial_valence   = Constants.clamp(valence)
+                @current_valence   = @initial_valence
+                @initial_intensity = Constants.clamp_intensity(intensity)
+                @current_intensity = @initial_intensity
+                @appraisal         = appraisal
+                @reappraisal_count = 0
+                @created_at        = Time.now.utc
+              end
+
+              def reappraise!(strategy:, new_appraisal:)
+                return 0.0 unless Constants.valid_strategy?(strategy)
+
+                base_effectiveness = Constants::STRATEGY_EFFECTIVENESS[strategy]
+                difficulty = @current_intensity > Constants::HIGH_INTENSITY_THRESHOLD ? Constants::REAPPRAISAL_DIFFICULTY_MULTIPLIER : 1.0
+                effectiveness = (base_effectiveness * difficulty).round(10)
+
+                valence_shift = effectiveness
+                intensity_reduction = (effectiveness * 0.5).round(10)
+
+                old_valence   = @current_valence
+                old_intensity = @current_intensity
+
+                @current_valence   = Constants.clamp(@current_valence + valence_shift)
+                @current_intensity = Constants.clamp_intensity(@current_intensity - intensity_reduction)
+                @appraisal         = new_appraisal
+                @reappraisal_count += 1
+
+                ((@current_valence - old_valence).abs + (old_intensity - @current_intensity).abs).round(10)
+              end
+
+              def negative?
+                @current_valence < Constants::NEGATIVE_VALENCE_THRESHOLD
+              end
+
+              def intense?
+                @current_intensity > Constants::HIGH_INTENSITY_THRESHOLD
+              end
+
+              def regulation_amount
+                valence_change   = (@current_valence - @initial_valence).abs
+                intensity_change = (@initial_intensity - @current_intensity).abs
+                raw = valence_change + intensity_change
+                Constants.clamp_intensity(raw / 2.0)
+              end
+
+              def valence_label
+                Constants.label_for(@current_valence, Constants::VALENCE_LABELS)
+              end
+
+              def intensity_label
+                Constants.label_for(@current_intensity, Constants::INTENSITY_LABELS)
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  content:           @content,
+                  initial_valence:   @initial_valence.round(10),
+                  current_valence:   @current_valence.round(10),
+                  initial_intensity: @initial_intensity.round(10),
+                  current_intensity: @current_intensity.round(10),
+                  appraisal:         @appraisal,
+                  reappraisal_count: @reappraisal_count,
+                  negative:          negative?,
+                  intense:           intense?,
+                  regulation_amount: regulation_amount.round(10),
+                  valence_label:     valence_label,
+                  intensity_label:   intensity_label,
+                  created_at:        @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end