lex-agentic-affect 0.1.0

data/lib/legion/extensions/agentic/affect/somatic_marker/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 SomaticMarker
+          module Actor
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Affect::SomaticMarker::Runners::SomaticMarker
+              end
+
+              def runner_function
+                'update_somatic_markers'
+              end
+
+              def time
+                30
+              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/somatic_marker/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/somatic_marker/helpers/constants'
+require 'legion/extensions/agentic/affect/somatic_marker/helpers/somatic_marker'
+require 'legion/extensions/agentic/affect/somatic_marker/helpers/body_state'
+require 'legion/extensions/agentic/affect/somatic_marker/helpers/marker_store'
+require 'legion/extensions/agentic/affect/somatic_marker/runners/somatic_marker'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module SomaticMarker
+          class Client
+            include Runners::SomaticMarker
+
+            def initialize(**)
+              @store = Helpers::MarkerStore.new
+            end
+
+            private
+
+            attr_reader :store
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module SomaticMarker
+          module Helpers
+            class BodyState
+              include Constants
+
+              attr_reader :arousal, :tension, :comfort, :gut_signal
+
+              def initialize(arousal: 0.5, tension: 0.5, comfort: 0.5, gut_signal: 0.0)
+                @arousal    = arousal.clamp(0.0, 1.0)
+                @tension    = tension.clamp(0.0, 1.0)
+                @comfort    = comfort.clamp(0.0, 1.0)
+                @gut_signal = gut_signal.clamp(-1.0, 1.0)
+              end
+
+              def update(arousal: nil, tension: nil, comfort: nil, gut_signal: nil)
+                @arousal    = arousal.clamp(0.0, 1.0)    if arousal
+                @tension    = tension.clamp(0.0, 1.0)    if tension
+                @comfort    = comfort.clamp(0.0, 1.0)    if comfort
+                @gut_signal = gut_signal.clamp(-1.0, 1.0) if gut_signal
+              end
+
+              def composite_valence
+                (@comfort * 0.4) + ((1.0 - @tension) * 0.3) + (@gut_signal * 0.3)
+              end
+
+              def decay
+                @arousal    = drift(@arousal,    0.5, BODY_STATE_DECAY)
+                @tension    = drift(@tension,    0.5, BODY_STATE_DECAY)
+                @comfort    = drift(@comfort,    0.5, BODY_STATE_DECAY)
+                @gut_signal = drift(@gut_signal, 0.0, BODY_STATE_DECAY)
+              end
+
+              def stressed?
+                @tension > 0.7 && @comfort < 0.3
+              end
+
+              def to_h
+                {
+                  arousal:           @arousal,
+                  tension:           @tension,
+                  comfort:           @comfort,
+                  gut_signal:        @gut_signal,
+                  composite_valence: composite_valence,
+                  stressed:          stressed?
+                }
+              end
+
+              private
+
+              def drift(value, target, rate)
+                if value > target
+                  (value - rate).clamp(target, 1.0)
+                else
+                  (value + rate).clamp(-1.0, target)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module SomaticMarker
+          module Helpers
+            module Constants
+              MAX_MARKERS              = 500
+              MAX_OPTIONS_PER_DECISION = 20
+              MAX_DECISION_HISTORY     = 200
+              MARKER_DECAY             = 0.01
+              MARKER_STRENGTH_FLOOR    = 0.05
+              MARKER_ALPHA             = 0.12
+              POSITIVE_BIAS            = 0.6
+              NEGATIVE_BIAS            = -0.6
+              DEFAULT_VALENCE          = 0.0
+              REINFORCEMENT_BOOST      = 0.15
+              PUNISHMENT_PENALTY       = 0.2
+              BODY_STATE_DECAY         = 0.03
+              MAX_BODY_STATES          = 50
+
+              VALENCE_LABELS = {
+                (-1.0..-0.6) => :strongly_negative,
+                (-0.6..-0.2) => :negative,
+                (-0.2..0.2)  => :neutral,
+                (0.2..0.6)   => :positive,
+                (0.6..1.0)   => :strongly_positive
+              }.freeze
+
+              SIGNAL_LABELS = {
+                approach: 'somatic signal favoring action',
+                avoid:    'somatic signal against action',
+                neutral:  'no clear somatic signal'
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module SomaticMarker
+          module Helpers
+            class MarkerStore
+              include Constants
+
+              attr_reader :markers, :body_state
+
+              def initialize
+                @markers          = {}
+                @body_state       = BodyState.new
+                @decision_history = []
+                @next_id          = 1
+              end
+
+              def register_marker(action:, domain:, valence:, source: :experience)
+                evict_weakest if @markers.size >= MAX_MARKERS
+
+                id     = generate_id
+                marker = SomaticMarker.new(
+                  id:      id,
+                  action:  action,
+                  domain:  domain,
+                  valence: valence,
+                  source:  source
+                )
+                @markers[id] = marker
+                marker
+              end
+
+              def evaluate_option(action:, domain:)
+                relevant = markers_for(action: action, domain: domain)
+                return { signal: :neutral, valence: DEFAULT_VALENCE, marker_count: 0 } if relevant.empty?
+
+                weighted_valence = compute_weighted_valence(relevant)
+                signal           = valence_to_signal(weighted_valence)
+                { signal: signal, valence: weighted_valence, marker_count: relevant.size }
+              end
+
+              def decide(options:, domain:)
+                capped = options.first(MAX_OPTIONS_PER_DECISION)
+                ranked = capped.map do |option|
+                  eval_result = evaluate_option(action: option, domain: domain)
+                  {
+                    action:       option,
+                    signal:       eval_result[:signal],
+                    valence:      eval_result[:valence],
+                    marker_count: eval_result[:marker_count]
+                  }
+                end
+
+                ranked.sort_by! { |r| -r[:valence] }
+
+                body_contribution = body_influence
+
+                record = {
+                  options:           capped,
+                  ranked:            ranked,
+                  domain:            domain,
+                  body_contribution: body_contribution,
+                  decided_at:        Time.now.utc
+                }
+
+                @decision_history.shift while @decision_history.size >= MAX_DECISION_HISTORY
+                @decision_history << record
+
+                record
+              end
+
+              def reinforce_marker(marker_id:, outcome_valence:)
+                marker = @markers[marker_id]
+                return nil unless marker
+
+                marker.reinforce(outcome_valence: outcome_valence)
+                marker
+              end
+
+              def update_body_state(arousal: nil, tension: nil, comfort: nil, gut_signal: nil)
+                @body_state.update(
+                  arousal:    arousal,
+                  tension:    tension,
+                  comfort:    comfort,
+                  gut_signal: gut_signal
+                )
+                @body_state
+              end
+
+              def markers_for(action:, domain:)
+                @markers.values.select { |m| m.action == action && m.domain == domain }
+              end
+
+              def body_influence
+                {
+                  composite_valence: @body_state.composite_valence,
+                  stressed:          @body_state.stressed?
+                }
+              end
+
+              def decay_all
+                @markers.each_value(&:decay)
+                faded_ids = @markers.select { |_id, m| m.faded? }.keys
+                faded_ids.each { |id| @markers.delete(id) }
+                @body_state.decay
+                { markers_decayed: @markers.size, markers_removed: faded_ids.size }
+              end
+
+              def decision_history(limit: 10)
+                @decision_history.last(limit)
+              end
+
+              def to_h
+                {
+                  marker_count:   @markers.size,
+                  decision_count: @decision_history.size,
+                  body_state:     @body_state.to_h,
+                  stressed:       @body_state.stressed?
+                }
+              end
+
+              private
+
+              def compute_weighted_valence(relevant)
+                total_strength = relevant.sum(&:strength)
+                return DEFAULT_VALENCE unless total_strength.positive?
+
+                relevant.sum { |m| m.valence * m.strength } / total_strength
+              end
+
+              def valence_to_signal(weighted_valence)
+                if weighted_valence > POSITIVE_BIAS
+                  :approach
+                elsif weighted_valence < NEGATIVE_BIAS
+                  :avoid
+                else
+                  :neutral
+                end
+              end
+
+              def generate_id
+                id = "sm_#{@next_id}"
+                @next_id += 1
+                id
+              end
+
+              def evict_weakest
+                weakest_id = @markers.min_by { |_id, m| m.strength }&.first
+                @markers.delete(weakest_id) if weakest_id
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module SomaticMarker
+          module Helpers
+            class SomaticMarker
+              include Constants
+
+              attr_reader :id, :action, :domain, :valence, :strength, :source, :created_at
+
+              def initialize(id:, action:, domain:, valence:, strength: 0.5, source: :experience)
+                @id         = id
+                @action     = action
+                @domain     = domain
+                @valence    = valence.clamp(-1.0, 1.0)
+                @strength   = strength.clamp(0.0, 1.0)
+                @source     = source
+                @created_at = Time.now.utc
+              end
+
+              def signal
+                if @valence > POSITIVE_BIAS
+                  :approach
+                elsif @valence < NEGATIVE_BIAS
+                  :avoid
+                else
+                  :neutral
+                end
+              end
+
+              def reinforce(outcome_valence:)
+                @valence  = (MARKER_ALPHA * outcome_valence) + ((1.0 - MARKER_ALPHA) * @valence)
+                @valence  = @valence.clamp(-1.0, 1.0)
+                @strength = (@strength + REINFORCEMENT_BOOST).clamp(0.0, 1.0)
+              end
+
+              def decay
+                @strength = (@strength - MARKER_DECAY).clamp(0.0, 1.0)
+              end
+
+              def faded?
+                @strength <= MARKER_STRENGTH_FLOOR
+              end
+
+              def valence_label
+                VALENCE_LABELS.each do |range, label|
+                  return label if range.cover?(@valence)
+                end
+                :neutral
+              end
+
+              def to_h
+                {
+                  id:         @id,
+                  action:     @action,
+                  domain:     @domain,
+                  valence:    @valence,
+                  strength:   @strength,
+                  source:     @source,
+                  signal:     signal,
+                  label:      valence_label,
+                  created_at: @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module SomaticMarker
+          module Runners
+            module SomaticMarker
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def register_marker(action:, domain:, valence:, source: :experience, **)
+                marker = store.register_marker(action: action, domain: domain, valence: valence, source: source)
+                Legion::Logging.debug "[somatic_marker] register: action=#{action} domain=#{domain} " \
+                                      "valence=#{valence.round(3)} source=#{source} id=#{marker.id}"
+                { success: true, marker: marker.to_h }
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] register failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def evaluate_option(action:, domain:, **)
+                result = store.evaluate_option(action: action, domain: domain)
+                Legion::Logging.debug "[somatic_marker] evaluate: action=#{action} domain=#{domain} " \
+                                      "signal=#{result[:signal]} valence=#{result[:valence].round(3)}"
+                { success: true }.merge(result)
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] evaluate failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def make_decision(options:, domain:, **)
+                result = store.decide(options: options, domain: domain)
+                Legion::Logging.debug "[somatic_marker] decide: domain=#{domain} options=#{options.size} " \
+                                      "top=#{result[:ranked].first&.fetch(:action)}"
+                { success: true, decision: result }
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] decide failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def reinforce(marker_id:, outcome_valence:, **)
+                marker = store.reinforce_marker(marker_id: marker_id, outcome_valence: outcome_valence)
+                unless marker
+                  Legion::Logging.debug "[somatic_marker] reinforce: marker_id=#{marker_id} not found"
+                  return { success: false, error: 'marker not found' }
+                end
+
+                Legion::Logging.debug "[somatic_marker] reinforce: id=#{marker_id} " \
+                                      "outcome=#{outcome_valence.round(3)} new_valence=#{marker.valence.round(3)}"
+                { success: true, marker: marker.to_h }
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] reinforce failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def update_body(arousal: nil, tension: nil, comfort: nil, gut_signal: nil, **)
+                state = store.update_body_state(
+                  arousal:    arousal,
+                  tension:    tension,
+                  comfort:    comfort,
+                  gut_signal: gut_signal
+                )
+                Legion::Logging.debug "[somatic_marker] body_update: composite=#{state.composite_valence.round(3)} " \
+                                      "stressed=#{state.stressed?}"
+                { success: true, body_state: state.to_h }
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] body update failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def body_state(**)
+                state = store.body_state
+                Legion::Logging.debug "[somatic_marker] body_state: composite=#{state.composite_valence.round(3)}"
+                { success: true, body_state: state.to_h }
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] body_state failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def markers_for_action(action:, domain:, **)
+                markers = store.markers_for(action: action, domain: domain)
+                Legion::Logging.debug "[somatic_marker] markers_for: action=#{action} domain=#{domain} " \
+                                      "count=#{markers.size}"
+                { success: true, markers: markers.map(&:to_h), count: markers.size }
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] markers_for_action failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def recent_decisions(limit: 10, **)
+                decisions = store.decision_history(limit: limit)
+                Legion::Logging.debug "[somatic_marker] recent_decisions: limit=#{limit} count=#{decisions.size}"
+                { success: true, decisions: decisions, count: decisions.size }
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] recent_decisions failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def update_somatic_markers(**)
+                result = store.decay_all
+                Legion::Logging.debug "[somatic_marker] decay: remaining=#{result[:markers_decayed]} " \
+                                      "removed=#{result[:markers_removed]}"
+                { success: true }.merge(result)
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] decay failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def somatic_marker_stats(**)
+                stats = store.to_h
+                Legion::Logging.debug "[somatic_marker] stats: markers=#{stats[:marker_count]} " \
+                                      "decisions=#{stats[:decision_count]}"
+                { success: true }.merge(stats)
+              rescue StandardError => e
+                Legion::Logging.error "[somatic_marker] stats failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              private
+
+              def store
+                @store ||= Helpers::MarkerStore.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'affect/version'
+require_relative 'affect/cognitive_empathy'
+require_relative 'affect/reappraisal'
+require_relative 'affect/defusion'
+require_relative 'affect/contagion'
+require_relative 'affect/emotion'
+require_relative 'affect/regulation'
+require_relative 'affect/mood'
+require_relative 'affect/appraisal'
+require_relative 'affect/empathy'
+require_relative 'affect/somatic_marker'
+require_relative 'affect/interoception'
+require_relative 'affect/flow'
+require_relative 'affect/fatigue'
+require_relative 'affect/motivation'
+require_relative 'affect/reward'
+require_relative 'affect/resilience'
+require_relative 'affect/resonance'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+
+        def remote_invocable?
+          false
+        end
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/appraisal/client_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/appraisal/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Appraisal::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:appraise_event)
+    expect(client).to respond_to(:reappraise_event)
+    expect(client).to respond_to(:select_coping_strategy)
+    expect(client).to respond_to(:add_coping_strategy)
+    expect(client).to respond_to(:evaluate_coping)
+    expect(client).to respond_to(:emotional_pattern)
+    expect(client).to respond_to(:update_appraisal)
+    expect(client).to respond_to(:appraisal_stats)
+  end
+
+  it 'maintains isolated engine state per client instance' do
+    client2 = described_class.new
+    client.appraise_event(
+      event:     'only in client1',
+      primary:   { relevance: 0.9, goal_congruence: 0.9, goal_importance: 0.8 },
+      secondary: { coping_potential: 0.8, control_expectation: 0.7, future_expectancy: 0.6 }
+    )
+    expect(client.appraisal_stats[:total]).to eq(1)
+    expect(client2.appraisal_stats[:total]).to eq(0)
+  end
+
+  it 'runs a full appraisal cycle' do
+    primary   = { relevance: 0.9, goal_congruence: 0.3, goal_importance: 0.8 }
+    secondary = { coping_potential: 0.2, control_expectation: 0.3, future_expectancy: 0.4 }
+
+    appraisal_id = client.appraise_event(event: 'crisis', primary: primary,
+                                         secondary: secondary)[:appraisal][:id]
+    client.add_coping_strategy(name: 'deep_breathing', coping_type: :emotion_focused, effectiveness: 0.7)
+    client.select_coping_strategy(appraisal_id: appraisal_id, coping_type: :emotion_focused)
+    eval_result = client.evaluate_coping(appraisal_id: appraisal_id)
+    expect(eval_result[:success]).to be(true)
+    expect(eval_result[:coping]).to eq('deep_breathing')
+
+    client.reappraise_event(
+      appraisal_id:  appraisal_id,
+      new_primary:   { relevance: 0.9, goal_congruence: 0.9, goal_importance: 0.8 },
+      new_secondary: { coping_potential: 0.8, control_expectation: 0.7, future_expectancy: 0.6 }
+    )
+    client.update_appraisal
+    stats = client.appraisal_stats
+    expect(stats[:total]).to eq(1)
+    expect(stats[:pattern]).to be_a(Hash)
+  end
+end