lex-agentic-affect 0.1.0

data/lib/legion/extensions/agentic/affect/flow/helpers/flow_detector.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Flow
+          module Helpers
+            class FlowDetector
+              attr_reader :challenge, :skill, :flow_state, :flow_score,
+                          :consecutive_flow_ticks, :total_flow_ticks, :history
+
+              def initialize
+                @challenge = 0.5
+                @skill = 0.5
+                @flow_state = :relaxation
+                @flow_score = 0.0
+                @consecutive_flow_ticks = 0
+                @total_flow_ticks = 0
+                @history = []
+              end
+
+              def update(challenge_input:, skill_input:, modifiers: {})
+                @challenge = ema(@challenge, challenge_input.clamp(0.0, 1.0), Constants::FLOW_ALPHA)
+                @skill = ema(@skill, skill_input.clamp(0.0, 1.0), Constants::FLOW_ALPHA)
+
+                @flow_state = classify_state
+                @flow_score = compute_flow_score(modifiers)
+
+                if @flow_state == :flow
+                  @consecutive_flow_ticks += 1
+                  @total_flow_ticks += 1
+                else
+                  @consecutive_flow_ticks = 0
+                end
+
+                record_snapshot
+              end
+
+              def in_flow?
+                @flow_state == :flow
+              end
+
+              def deep_flow?
+                in_flow? && @consecutive_flow_ticks >= Constants::DEEP_FLOW_THRESHOLD
+              end
+
+              def flow_effects
+                if in_flow?
+                  effects = Constants::FLOW_EFFECTS.dup
+                  if deep_flow?
+                    effects[:performance_boost] += 0.05
+                    effects[:creativity_boost] += 0.1
+                  end
+                  effects
+                else
+                  { fatigue_reduction: 1.0, time_dilation: 1.0, performance_boost: 1.0,
+                    attention_broadening: 1.0, creativity_boost: 1.0 }
+                end
+              end
+
+              def challenge_skill_balance
+                (@challenge - @skill).abs
+              end
+
+              def flow_trend
+                return :insufficient_data if @history.size < 5
+
+                recent = @history.last(10)
+                scores = recent.map { |h| h[:flow_score] }
+                first_half = scores[0...(scores.size / 2)]
+                second_half = scores[(scores.size / 2)..]
+                diff = (second_half.sum / second_half.size.to_f) - (first_half.sum / first_half.size.to_f)
+
+                if diff > 0.05
+                  :entering_flow
+                elsif diff < -0.05
+                  :leaving_flow
+                else
+                  :stable
+                end
+              end
+
+              def flow_percentage
+                return 0.0 if @history.empty?
+
+                flow_count = @history.count { |h| h[:state] == :flow }
+                (flow_count.to_f / @history.size * 100).round(1)
+              end
+
+              def to_h
+                {
+                  state:                  @flow_state,
+                  score:                  @flow_score.round(3),
+                  challenge:              @challenge.round(3),
+                  skill:                  @skill.round(3),
+                  balance:                challenge_skill_balance.round(3),
+                  in_flow:                in_flow?,
+                  deep_flow:              deep_flow?,
+                  consecutive_flow_ticks: @consecutive_flow_ticks,
+                  total_flow_ticks:       @total_flow_ticks,
+                  flow_percentage:        flow_percentage,
+                  trend:                  flow_trend,
+                  effects:                flow_effects
+                }
+              end
+
+              private
+
+              def classify_state
+                best_state = :apathy
+                best_score = -1.0
+
+                Constants::STATE_REGIONS.each do |state, region|
+                  next unless region[:challenge].cover?(@challenge) && region[:skill].cover?(@skill)
+
+                  score = region[:balanced] ? balance_bonus : 0.5
+                  if score > best_score
+                    best_score = score
+                    best_state = state
+                  end
+                end
+
+                best_state
+              end
+
+              def balance_bonus
+                balance = challenge_skill_balance
+                balance <= Constants::FLOW_ZONE[:balance_tolerance] ? 1.0 : 0.7
+              end
+
+              def compute_flow_score(modifiers)
+                base = if in_flow?
+                         0.7 + ((1.0 - challenge_skill_balance) * 0.3)
+                       else
+                         [0.0, 0.5 - (challenge_skill_balance * 0.5)].max
+                       end
+
+                base += Constants::DEEP_FLOW_BONUS if deep_flow?
+                base += Constants::CURIOSITY_BONUS if modifiers[:curiosity_active]
+                base += Constants::LOW_ERROR_BONUS if modifiers[:low_errors]
+
+                base.clamp(0.0, 1.0)
+              end
+
+              def ema(current, observed, alpha)
+                (current * (1.0 - alpha)) + (observed * alpha)
+              end
+
+              def record_snapshot
+                @history << {
+                  state:      @flow_state,
+                  flow_score: @flow_score,
+                  challenge:  @challenge,
+                  skill:      @skill,
+                  at:         Time.now.utc
+                }
+                @history.shift while @history.size > Constants::MAX_FLOW_HISTORY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Flow
+          module Runners
+            module Flow
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def update_flow(tick_results: {}, **)
+                challenge_input = extract_challenge(tick_results)
+                skill_input = extract_skill(tick_results)
+                modifiers = extract_modifiers(tick_results)
+
+                flow_detector.update(challenge_input: challenge_input, skill_input: skill_input, modifiers: modifiers)
+
+                breakers = detect_flow_breakers(tick_results)
+                if breakers.any? && flow_detector.in_flow?
+                  flow_detector.instance_variable_set(:@flow_state, :disrupted)
+                  flow_detector.instance_variable_set(:@consecutive_flow_ticks, 0)
+                end
+
+                Legion::Logging.debug "[flow] state=#{flow_detector.flow_state} score=#{flow_detector.flow_score.round(3)} " \
+                                      "deep=#{flow_detector.deep_flow?} breakers=#{breakers}"
+
+                {
+                  state:     flow_detector.flow_state,
+                  score:     flow_detector.flow_score.round(3),
+                  in_flow:   flow_detector.in_flow?,
+                  deep_flow: flow_detector.deep_flow?,
+                  effects:   flow_detector.flow_effects,
+                  breakers:  breakers,
+                  challenge: flow_detector.challenge.round(3),
+                  skill:     flow_detector.skill.round(3)
+                }
+              end
+
+              def flow_status(**)
+                Legion::Logging.debug "[flow] status: state=#{flow_detector.flow_state} score=#{flow_detector.flow_score.round(3)}"
+                flow_detector.to_h
+              end
+
+              def flow_effects(**)
+                effects = flow_detector.flow_effects
+                Legion::Logging.debug "[flow] effects: #{effects}"
+                { effects: effects, in_flow: flow_detector.in_flow?, deep_flow: flow_detector.deep_flow? }
+              end
+
+              def flow_history(limit: 20, **)
+                recent = flow_detector.history.last(limit)
+                Legion::Logging.debug "[flow] history: #{recent.size} entries"
+                { history: recent, total: flow_detector.history.size }
+              end
+
+              def flow_stats(**)
+                Legion::Logging.debug '[flow] stats'
+                {
+                  state:                  flow_detector.flow_state,
+                  score:                  flow_detector.flow_score.round(3),
+                  consecutive_flow_ticks: flow_detector.consecutive_flow_ticks,
+                  total_flow_ticks:       flow_detector.total_flow_ticks,
+                  flow_percentage:        flow_detector.flow_percentage,
+                  trend:                  flow_detector.flow_trend,
+                  balance:                flow_detector.challenge_skill_balance.round(3)
+                }
+              end
+
+              private
+
+              def flow_detector
+                @flow_detector ||= Helpers::FlowDetector.new
+              end
+
+              def extract_challenge(tick_results)
+                prediction_accuracy = tick_results.dig(:prediction_engine, :rolling_accuracy) || 0.5
+                error_rate = tick_results.dig(:prediction_engine, :error_rate) || 0.5
+                task_complexity = tick_results.dig(:action_selection, :complexity) || 0.5
+
+                ((1.0 - prediction_accuracy) * 0.4) + (error_rate * 0.3) + (task_complexity * 0.3)
+              end
+
+              def extract_skill(tick_results)
+                prediction_accuracy = tick_results.dig(:prediction_engine, :rolling_accuracy) || 0.5
+                memory_strength = tick_results.dig(:memory_retrieval, :avg_strength) || 0.5
+                habit_automation = tick_results.dig(:habit, :automation_level) || 0.5
+
+                (prediction_accuracy * 0.4) + (memory_strength * 0.3) + (habit_automation * 0.3)
+              end
+
+              def extract_modifiers(tick_results)
+                {
+                  curiosity_active: (tick_results.dig(:curiosity, :intensity) || 0.0) > 0.5,
+                  low_errors:       (tick_results.dig(:prediction_engine, :error_rate) || 1.0) < 0.2
+                }
+              end
+
+              def detect_flow_breakers(tick_results)
+                breakers = []
+                check_anxiety_breaker(tick_results, breakers)
+                check_simple_breakers(tick_results, breakers)
+                check_conflict_breaker(tick_results, breakers)
+                breakers
+              end
+
+              def check_anxiety_breaker(tick_results, breakers)
+                anxiety = tick_results.dig(:emotional_evaluation, :anxiety) || 0.0
+                breakers << :high_anxiety if anxiety > 0.8
+              end
+
+              def check_simple_breakers(tick_results, breakers)
+                breakers << :trust_violation if tick_results.dig(:trust, :violation)
+                breakers << :critical_error if tick_results.dig(:error, :critical)
+                breakers << :burnout if tick_results.dig(:fatigue, :burnout)
+              end
+
+              def check_conflict_breaker(tick_results, breakers)
+                conflict = tick_results.dig(:conflict, :severity)
+                breakers << :conflict_escalation if conflict && conflict >= 4
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Interoception
+          module Actor
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Affect::Interoception::Runners::Interoception
+              end
+
+              def runner_function
+                'update_interoception'
+              end
+
+              def time
+                60
+              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/interoception/client.rb

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

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Interoception
+          module Helpers
+            class BodyBudget
+              include Constants
+
+              attr_reader :vitals, :baselines, :markers, :vital_history
+
+              def initialize
+                @vitals        = {}
+                @baselines     = {}
+                @markers       = []
+                @vital_history = {}
+              end
+
+              # --- Vital Signal Tracking ---
+
+              def report_vital(channel:, value:)
+                channel = channel.to_sym
+                normalized = value.clamp(0.0, 1.0)
+                @baselines[channel] ||= DEFAULT_BASELINE
+                @vitals[channel] = if @vitals.key?(channel)
+                                     ema(@vitals[channel], normalized, VITAL_ALPHA)
+                                   else
+                                     normalized
+                                   end
+                record_vital_history(channel, @vitals[channel])
+                @baselines[channel] = ema(@baselines[channel], @vitals[channel], VITAL_ALPHA * 0.5)
+                @vitals[channel]
+              end
+
+              def vital_for(channel)
+                @vitals.fetch(channel.to_sym, DEFAULT_BASELINE)
+              end
+
+              def deviation_for(channel)
+                channel = channel.to_sym
+                current = @vitals.fetch(channel, DEFAULT_BASELINE)
+                baseline = @baselines.fetch(channel, DEFAULT_BASELINE)
+                current - baseline
+              end
+
+              def vital_label(channel)
+                health = vital_health(channel)
+                VITAL_LABELS.each { |range, lbl| return lbl if range.cover?(health) }
+                :nominal
+              end
+
+              def vital_health(channel)
+                val = vital_for(channel)
+                inverted_channels = %i[cpu_load memory_pressure queue_depth error_rate disk_usage gc_pressure]
+                inverted_channels.include?(channel.to_sym) ? 1.0 - val : val
+              end
+
+              def deviating_channels
+                @vitals.select { |ch, _| deviation_for(ch).abs >= DEVIATION_THRESHOLD }
+                       .map { |ch, _| { channel: ch, deviation: deviation_for(ch).round(4), label: vital_label(ch) } }
+              end
+
+              # --- Somatic Markers ---
+
+              def create_marker(action:, domain:, valence:, strength: 1.0)
+                marker = SomaticMarker.new(action: action, domain: domain, valence: valence, strength: strength)
+                @markers << marker
+                prune_markers if @markers.size > MAX_MARKERS
+                marker
+              end
+
+              def markers_for(action:, domain: nil)
+                results = @markers.select { |m| m.action == action }
+                results = results.select { |m| m.domain == domain } if domain
+                results
+              end
+
+              def bias_for_action(action:, domain: nil)
+                relevant = markers_for(action: action, domain: domain)
+                return 0.0 if relevant.empty?
+
+                relevant.sum { |m| m.bias_for(action) } / relevant.size
+              end
+
+              def reinforce_markers(action:, domain: nil, amount: 0.1)
+                markers_for(action: action, domain: domain).each { |m| m.reinforce(amount: amount) }
+              end
+
+              def decay_markers
+                @markers.each(&:decay)
+                @markers.reject!(&:faded?)
+              end
+
+              # --- Body Budget Overview ---
+
+              def overall_health
+                return DEFAULT_BASELINE if @vitals.empty?
+
+                healths = @vitals.keys.map { |ch| vital_health(ch) }
+                healths.sum / healths.size
+              end
+
+              def body_budget_label
+                health = overall_health
+                BODY_BUDGET_LABELS.each { |range, lbl| return lbl if range.cover?(health) }
+                :comfortable
+              end
+
+              def channel_count
+                @vitals.size
+              end
+
+              def marker_count
+                @markers.size
+              end
+
+              def to_h
+                {
+                  overall_health:    overall_health.round(4),
+                  body_budget_label: body_budget_label,
+                  channels:          channel_count,
+                  markers:           marker_count,
+                  vitals:            @vitals.transform_values { |v| v.round(4) },
+                  deviations:        deviating_channels
+                }
+              end
+
+              private
+
+              def ema(old_val, new_val, alpha)
+                old_val + (alpha * (new_val - old_val))
+              end
+
+              def record_vital_history(channel, value)
+                @vital_history[channel] ||= []
+                @vital_history[channel] << { value: value, at: Time.now.utc }
+                @vital_history[channel].shift while @vital_history[channel].size > MAX_VITAL_HISTORY
+              end
+
+              def prune_markers
+                @markers.sort_by!(&:strength)
+                @markers.shift while @markers.size > MAX_MARKERS
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Interoception
+          module Helpers
+            module Constants
+              # Vital signal channels the agent monitors
+              VITAL_CHANNELS = %i[
+                cpu_load memory_pressure queue_depth
+                response_latency error_rate connection_health
+                disk_usage thread_count gc_pressure
+              ].freeze
+
+              # Somatic marker valence thresholds
+              MARKER_POSITIVE_THRESHOLD = 0.3
+              MARKER_NEGATIVE_THRESHOLD = -0.3
+
+              # How strongly markers bias decisions (0..1)
+              MARKER_INFLUENCE = 0.4
+
+              # EMA alpha for vital signal smoothing
+              VITAL_ALPHA = 0.15
+
+              # Default baseline for vitals (normalized 0..1)
+              DEFAULT_BASELINE = 0.5
+
+              # Deviation from baseline that triggers a somatic marker
+              DEVIATION_THRESHOLD = 0.2
+
+              # Maximum stored somatic markers
+              MAX_MARKERS = 200
+
+              # Maximum stored vital snapshots per channel
+              MAX_VITAL_HISTORY = 100
+
+              # Marker decay per tick
+              MARKER_DECAY = 0.02
+
+              # Marker floor (below this, marker is pruned)
+              MARKER_FLOOR = 0.05
+
+              # Body budget labels based on overall vital health
+              BODY_BUDGET_LABELS = {
+                (0.8..)     => :thriving,
+                (0.6...0.8) => :comfortable,
+                (0.4...0.6) => :strained,
+                (0.2...0.4) => :distressed,
+                (..0.2)     => :critical
+              }.freeze
+
+              # Vital health labels
+              VITAL_LABELS = {
+                (0.8..)     => :healthy,
+                (0.6...0.8) => :nominal,
+                (0.4...0.6) => :elevated,
+                (0.2...0.4) => :warning,
+                (..0.2)     => :critical
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Interoception
+          module Helpers
+            class SomaticMarker
+              attr_reader :id, :action, :domain, :valence, :created_at
+              attr_accessor :strength
+
+              def initialize(action:, domain:, valence:, strength: 1.0)
+                @id         = SecureRandom.uuid
+                @action     = action
+                @domain     = domain
+                @valence    = valence.clamp(-1.0, 1.0)
+                @strength   = strength.clamp(0.0, 1.0)
+                @created_at = Time.now.utc
+              end
+
+              def bias_for(candidate_action)
+                return 0.0 unless candidate_action == @action
+
+                @valence * @strength * Constants::MARKER_INFLUENCE
+              end
+
+              def reinforce(amount: 0.1)
+                @strength = [@strength + amount, 1.0].min
+              end
+
+              def decay
+                @strength = [@strength - Constants::MARKER_DECAY, Constants::MARKER_FLOOR].max
+              end
+
+              def faded?
+                @strength <= Constants::MARKER_FLOOR
+              end
+
+              def positive?
+                @valence >= Constants::MARKER_POSITIVE_THRESHOLD
+              end
+
+              def negative?
+                @valence <= Constants::MARKER_NEGATIVE_THRESHOLD
+              end
+
+              def label
+                if positive?
+                  :approach
+                elsif negative?
+                  :avoid
+                else
+                  :neutral
+                end
+              end
+
+              def to_h
+                {
+                  id:         @id,
+                  action:     @action,
+                  domain:     @domain,
+                  valence:    @valence,
+                  strength:   @strength,
+                  label:      label,
+                  created_at: @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end