lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/reward/helpers/constants_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reward::Helpers::Constants do
+  describe 'REWARD_SOURCES' do
+    it 'defines 8 sources' do
+      expect(described_class::REWARD_SOURCES.size).to eq(8)
+    end
+
+    it 'has weights summing to 1.0' do
+      total = described_class::REWARD_SOURCES.values.sum { |v| v[:weight] }
+      expect(total).to be_within(0.001).of(1.0)
+    end
+
+    it 'includes prediction accuracy' do
+      expect(described_class::REWARD_SOURCES).to have_key(:prediction_accuracy)
+    end
+
+    it 'includes curiosity resolved' do
+      expect(described_class::REWARD_SOURCES).to have_key(:curiosity_resolved)
+    end
+
+    it 'includes goal achieved' do
+      expect(described_class::REWARD_SOURCES).to have_key(:goal_achieved)
+    end
+
+    it 'is frozen' do
+      expect(described_class::REWARD_SOURCES).to be_frozen
+    end
+  end
+
+  describe 'REWARD_ALPHA' do
+    it 'is 0.15' do
+      expect(described_class::REWARD_ALPHA).to eq(0.15)
+    end
+  end
+
+  describe 'PREDICTION_ALPHA' do
+    it 'is 0.1' do
+      expect(described_class::PREDICTION_ALPHA).to eq(0.1)
+    end
+  end
+
+  describe 'RPE_THRESHOLD' do
+    it 'is 0.05' do
+      expect(described_class::RPE_THRESHOLD).to eq(0.05)
+    end
+  end
+
+  describe 'REWARD_RANGE' do
+    it 'spans -1.0 to 1.0' do
+      expect(described_class::REWARD_RANGE[:min]).to eq(-1.0)
+      expect(described_class::REWARD_RANGE[:max]).to eq(1.0)
+    end
+  end
+
+  describe 'RPE_LEVELS' do
+    it 'defines 5 levels' do
+      expect(described_class::RPE_LEVELS.size).to eq(5)
+    end
+
+    it 'has large_positive > positive > neutral thresholds' do
+      levels = described_class::RPE_LEVELS
+      expect(levels[:large_positive]).to be > levels[:positive]
+      expect(levels[:positive]).to be > levels[:neutral]
+    end
+  end
+
+  describe 'TEMPORAL_DISCOUNT' do
+    it 'is 0.95' do
+      expect(described_class::TEMPORAL_DISCOUNT).to eq(0.95)
+    end
+  end
+
+  describe 'thresholds' do
+    it 'defines anhedonia threshold' do
+      expect(described_class::ANHEDONIA_THRESHOLD).to eq(-0.3)
+    end
+
+    it 'defines euphoria threshold' do
+      expect(described_class::EUPHORIA_THRESHOLD).to eq(0.7)
+    end
+  end
+
+  describe 'MAX_REWARD_HISTORY' do
+    it 'caps at 200' do
+      expect(described_class::MAX_REWARD_HISTORY).to eq(200)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/reward/helpers/reward_signal_spec.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reward::Helpers::RewardSignal do
+  subject(:signal) { described_class.new }
+
+  let(:positive_sources) do
+    {
+      prediction_accuracy: 0.8,
+      curiosity_resolved:  0.5,
+      goal_achieved:       0.6,
+      social_approval:     0.3,
+      flow_state:          0.4,
+      error_avoidance:     0.7,
+      novelty_encounter:   0.3,
+      homeostatic_balance: 0.2
+    }
+  end
+
+  let(:negative_sources) do
+    {
+      prediction_accuracy: -0.5,
+      curiosity_resolved:  -0.3,
+      goal_achieved:       -0.8,
+      social_approval:     -0.4,
+      flow_state:          -0.2,
+      error_avoidance:     -0.6,
+      novelty_encounter:   -0.1,
+      homeostatic_balance: -0.3
+    }
+  end
+
+  let(:neutral_sources) do
+    {
+      prediction_accuracy: 0.0,
+      curiosity_resolved:  0.0,
+      goal_achieved:       0.0,
+      social_approval:     0.0,
+      flow_state:          0.0,
+      error_avoidance:     0.0,
+      novelty_encounter:   0.0,
+      homeostatic_balance: 0.0
+    }
+  end
+
+  describe '#initialize' do
+    it 'starts with zero running average' do
+      expect(signal.running_average).to eq(0.0)
+    end
+
+    it 'starts with zero predicted reward' do
+      expect(signal.predicted_reward).to eq(0.0)
+    end
+
+    it 'starts with zero RPE' do
+      expect(signal.last_rpe).to eq(0.0)
+    end
+
+    it 'starts with empty history' do
+      expect(signal.history).to be_empty
+    end
+
+    it 'starts with zero tick count' do
+      expect(signal.tick_count).to eq(0)
+    end
+  end
+
+  describe '#compute' do
+    it 'returns reward result hash' do
+      result = signal.compute(positive_sources)
+      expect(result).to include(:reward, :rpe, :rpe_class, :running_average,
+                                :predicted_reward, :sources, :learning_signal)
+    end
+
+    it 'computes positive reward from positive sources' do
+      result = signal.compute(positive_sources)
+      expect(result[:reward]).to be > 0.0
+    end
+
+    it 'computes negative reward from negative sources' do
+      result = signal.compute(negative_sources)
+      expect(result[:reward]).to be < 0.0
+    end
+
+    it 'computes zero reward from neutral sources' do
+      result = signal.compute(neutral_sources)
+      expect(result[:reward]).to eq(0.0)
+    end
+
+    it 'clamps reward to [-1.0, 1.0]' do
+      extreme = positive_sources.transform_values { 10.0 }
+      result = signal.compute(extreme)
+      expect(result[:reward]).to be <= 1.0
+    end
+
+    it 'increments tick count' do
+      signal.compute(positive_sources)
+      expect(signal.tick_count).to eq(1)
+    end
+
+    it 'records in history' do
+      signal.compute(positive_sources)
+      expect(signal.history.size).to eq(1)
+    end
+
+    it 'computes RPE as actual minus predicted' do
+      signal.compute(neutral_sources)
+      result = signal.compute(positive_sources)
+      expect(result[:rpe]).to be > 0.0
+    end
+
+    it 'updates running average via EMA' do
+      signal.compute(positive_sources)
+      expect(signal.running_average).to be > 0.0
+    end
+
+    it 'updates predicted reward via EMA' do
+      signal.compute(positive_sources)
+      expect(signal.predicted_reward).to be > 0.0
+    end
+  end
+
+  describe 'RPE classification' do
+    it 'classifies large positive RPE' do
+      # First tick with neutral, then large positive
+      signal.compute(neutral_sources)
+      result = signal.compute(positive_sources)
+      expect(result[:rpe_class]).to be_a(Symbol)
+    end
+
+    it 'classifies neutral RPE for stable rewards' do
+      20.times { signal.compute(neutral_sources) }
+      result = signal.compute(neutral_sources)
+      expect(result[:rpe_class]).to eq(:neutral)
+    end
+  end
+
+  describe '#record_domain_reward' do
+    it 'stores domain-specific rewards' do
+      signal.record_domain_reward(:networking, 0.5)
+      expect(signal.domain_history[:networking].size).to eq(1)
+    end
+
+    it 'caps domain history at MAX_DOMAIN_HISTORY' do
+      max = Legion::Extensions::Agentic::Affect::Reward::Helpers::Constants::MAX_DOMAIN_HISTORY
+      (max + 5).times { signal.record_domain_reward(:test, 0.1) }
+      expect(signal.domain_history[:test].size).to eq(max)
+    end
+  end
+
+  describe '#domain_average' do
+    it 'returns 0.0 for unknown domain' do
+      expect(signal.domain_average(:unknown)).to eq(0.0)
+    end
+
+    it 'computes average of domain rewards' do
+      signal.record_domain_reward(:test, 0.4)
+      signal.record_domain_reward(:test, 0.6)
+      expect(signal.domain_average(:test)).to eq(0.5)
+    end
+  end
+
+  describe '#domain_trend' do
+    it 'returns :no_data for unknown domain' do
+      expect(signal.domain_trend(:unknown)).to eq(:no_data)
+    end
+
+    it 'returns :no_data with insufficient entries' do
+      3.times { signal.record_domain_reward(:test, 0.5) }
+      expect(signal.domain_trend(:test)).to eq(:no_data)
+    end
+
+    it 'detects improving trend' do
+      5.times { signal.record_domain_reward(:test, 0.1) }
+      5.times { signal.record_domain_reward(:test, 0.9) }
+      expect(signal.domain_trend(:test)).to eq(:improving)
+    end
+
+    it 'detects declining trend' do
+      5.times { signal.record_domain_reward(:test, 0.9) }
+      5.times { signal.record_domain_reward(:test, 0.1) }
+      expect(signal.domain_trend(:test)).to eq(:declining)
+    end
+
+    it 'detects stable trend' do
+      10.times { signal.record_domain_reward(:test, 0.5) }
+      expect(signal.domain_trend(:test)).to eq(:stable)
+    end
+  end
+
+  describe '#anhedonic?' do
+    it 'returns false initially' do
+      expect(signal.anhedonic?).to be false
+    end
+
+    it 'returns true with persistent negative rewards' do
+      50.times { signal.compute(negative_sources) }
+      expect(signal.anhedonic?).to be true
+    end
+  end
+
+  describe '#euphoric?' do
+    it 'returns false initially' do
+      expect(signal.euphoric?).to be false
+    end
+
+    it 'returns true with persistent high rewards' do
+      extreme_positive = positive_sources.transform_values { 1.0 }
+      50.times { signal.compute(extreme_positive) }
+      expect(signal.euphoric?).to be true
+    end
+  end
+
+  describe '#learning_signal?' do
+    it 'returns false when RPE is below threshold' do
+      20.times { signal.compute(neutral_sources) }
+      expect(signal.learning_signal?).to be false
+    end
+
+    it 'returns true when RPE exceeds threshold' do
+      signal.compute(neutral_sources)
+      signal.compute(positive_sources)
+      expect(signal.learning_signal?).to be true
+    end
+  end
+
+  describe '#recent_rewards' do
+    it 'returns empty for no history' do
+      expect(signal.recent_rewards).to be_empty
+    end
+
+    it 'returns requested number of entries' do
+      10.times { signal.compute(positive_sources) }
+      expect(signal.recent_rewards(5).size).to eq(5)
+    end
+  end
+
+  describe '#discounted_return' do
+    it 'returns 0.0 for empty history' do
+      expect(signal.discounted_return).to eq(0.0)
+    end
+
+    it 'computes discounted sum of rewards' do
+      5.times { signal.compute(positive_sources) }
+      expect(signal.discounted_return).to be > 0.0
+    end
+
+    it 'recent rewards count more than older ones' do
+      full = signal.discounted_return(10)
+      expect(full).to eq(0.0)
+
+      5.times { signal.compute(positive_sources) }
+      windowed = signal.discounted_return(3)
+      full_return = signal.discounted_return
+      expect(full_return).to be >= windowed
+    end
+  end
+
+  describe '#reward_volatility' do
+    it 'returns 0.0 with insufficient data' do
+      expect(signal.reward_volatility).to eq(0.0)
+    end
+
+    it 'is low for consistent rewards' do
+      20.times { signal.compute(neutral_sources) }
+      expect(signal.reward_volatility).to be < 0.1
+    end
+
+    it 'is higher for alternating rewards' do
+      10.times do
+        signal.compute(positive_sources)
+        signal.compute(negative_sources)
+      end
+      expect(signal.reward_volatility).to be > 0.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns complete state hash' do
+      signal.compute(positive_sources)
+      h = signal.to_h
+      expect(h).to include(:running_average, :predicted_reward, :last_rpe, :rpe_class,
+                           :tick_count, :learning_signal, :anhedonic, :euphoric,
+                           :volatility, :domains_tracked, :history_size)
+    end
+  end
+
+  describe 'history cap' do
+    it 'caps at MAX_REWARD_HISTORY' do
+      max = Legion::Extensions::Agentic::Affect::Reward::Helpers::Constants::MAX_REWARD_HISTORY
+      (max + 10).times { signal.compute(positive_sources) }
+      expect(signal.history.size).to eq(max)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/reward/helpers/reward_store_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reward::Helpers::RewardStore do
+  subject(:store) { described_class.new }
+
+  let(:positive_tick) do
+    {
+      prediction_engine: { rolling_accuracy: 0.8, error_rate: 0.1 },
+      curiosity:         { resolved_count: 2, intensity: 0.6 },
+      volition:          { completed_count: 1, failed_count: 0, current_domain: :networking },
+      trust:             { composite_delta: 0.1 },
+      flow:              { in_flow: true, score: 0.8 },
+      attention:         { novelty_score: 0.5, spotlight_count: 3 },
+      homeostasis:       { worst_deviation: 0.1, allostatic_load: 0.1 }
+    }
+  end
+
+  let(:negative_tick) do
+    {
+      prediction_engine: { rolling_accuracy: 0.2, error_rate: 0.8 },
+      curiosity:         { resolved_count: 0, intensity: 0.1 },
+      volition:          { completed_count: 0, failed_count: 2, current_domain: :debugging },
+      trust:             { composite_delta: -0.2 },
+      flow:              { in_flow: false, score: 0.1 },
+      attention:         { novelty_score: 0.0, spotlight_count: 0 },
+      homeostasis:       { worst_deviation: 0.8, allostatic_load: 0.7 }
+    }
+  end
+
+  let(:empty_tick) { {} }
+
+  describe '#process_tick' do
+    it 'returns reward result hash' do
+      result = store.process_tick(positive_tick)
+      expect(result).to include(:reward, :rpe, :rpe_class, :running_average,
+                                :predicted_reward, :sources, :learning_signal)
+    end
+
+    it 'computes positive reward for positive tick' do
+      result = store.process_tick(positive_tick)
+      expect(result[:reward]).to be > 0.0
+    end
+
+    it 'computes negative reward for negative tick' do
+      result = store.process_tick(negative_tick)
+      expect(result[:reward]).to be < 0.0
+    end
+
+    it 'handles empty tick results' do
+      result = store.process_tick(empty_tick)
+      expect(result[:reward]).to be_a(Float)
+    end
+
+    it 'records domain reward when domain available' do
+      store.process_tick(positive_tick)
+      expect(store.signal.domain_history[:networking]).not_to be_nil
+    end
+  end
+
+  describe '#domain_report' do
+    it 'returns report for known domain' do
+      store.process_tick(positive_tick)
+      report = store.domain_report(:networking)
+      expect(report).to include(:domain, :average, :trend, :history)
+      expect(report[:domain]).to eq(:networking)
+    end
+
+    it 'returns empty report for unknown domain' do
+      report = store.domain_report(:unknown)
+      expect(report[:average]).to eq(0.0)
+      expect(report[:trend]).to eq(:no_data)
+    end
+  end
+
+  describe '#all_domain_averages' do
+    it 'returns empty hash initially' do
+      expect(store.all_domain_averages).to be_empty
+    end
+
+    it 'tracks multiple domains' do
+      store.process_tick(positive_tick)
+      store.process_tick(negative_tick)
+      averages = store.all_domain_averages
+      expect(averages.keys).to include(:networking, :debugging)
+    end
+  end
+
+  describe '#health_assessment' do
+    it 'returns healthy initially' do
+      assessment = store.health_assessment
+      expect(assessment[:status]).to eq(:neutral).or eq(:healthy)
+    end
+
+    it 'detects anhedonia with persistent negative' do
+      50.times { store.process_tick(negative_tick) }
+      assessment = store.health_assessment
+      expect(assessment[:status]).to eq(:anhedonic)
+    end
+
+    it 'detects euphoria with persistent positive' do
+      extreme = positive_tick.dup
+      extreme[:prediction_engine] = { rolling_accuracy: 1.0, error_rate: 0.0 }
+      extreme[:curiosity] = { resolved_count: 5, intensity: 1.0 }
+      extreme[:volition] = { completed_count: 3, failed_count: 0, current_domain: :test }
+      extreme[:flow] = { in_flow: true, score: 1.0 }
+      extreme[:attention] = { novelty_score: 1.0, spotlight_count: 5 }
+      extreme[:homeostasis] = { worst_deviation: 0.0, allostatic_load: 0.0 }
+      50.times { store.process_tick(extreme) }
+      assessment = store.health_assessment
+      expect(assessment[:status]).to eq(:euphoric)
+    end
+
+    it 'includes severity' do
+      assessment = store.health_assessment
+      expect(assessment).to have_key(:severity)
+    end
+  end
+
+  describe 'signal extraction' do
+    it 'extracts prediction reward from accuracy' do
+      result = store.process_tick(positive_tick)
+      expect(result[:sources][:prediction_accuracy]).to be > 0.0
+    end
+
+    it 'extracts curiosity reward from resolved count' do
+      result = store.process_tick(positive_tick)
+      expect(result[:sources][:curiosity_resolved]).to be > 0.0
+    end
+
+    it 'extracts goal reward from completed count' do
+      result = store.process_tick(positive_tick)
+      expect(result[:sources][:goal_achieved]).to be > 0.0
+    end
+
+    it 'extracts social reward from trust delta' do
+      result = store.process_tick(positive_tick)
+      expect(result[:sources][:social_approval]).to be > 0.0
+    end
+
+    it 'extracts flow reward from flow state' do
+      result = store.process_tick(positive_tick)
+      expect(result[:sources][:flow_state]).to be > 0.0
+    end
+
+    it 'extracts error reward from error rate' do
+      result = store.process_tick(positive_tick)
+      expect(result[:sources][:error_avoidance]).to be > 0.0
+    end
+
+    it 'extracts novelty reward from attention' do
+      result = store.process_tick(positive_tick)
+      expect(result[:sources][:novelty_encounter]).to be > 0.0
+    end
+
+    it 'extracts homeostatic reward from deviation' do
+      result = store.process_tick(positive_tick)
+      expect(result[:sources][:homeostatic_balance]).to be > 0.0
+    end
+
+    it 'returns negative flow reward when not in flow' do
+      result = store.process_tick(negative_tick)
+      expect(result[:sources][:flow_state]).to be < 0.0
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/reward/runners/reward_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Reward::Runners::Reward do
+  let(:client) { Legion::Extensions::Agentic::Affect::Reward::Client.new }
+
+  let(:positive_tick) do
+    {
+      prediction_engine: { rolling_accuracy: 0.8, error_rate: 0.1 },
+      curiosity:         { resolved_count: 2, intensity: 0.6 },
+      volition:          { completed_count: 1, failed_count: 0, current_domain: :test },
+      trust:             { composite_delta: 0.1 },
+      flow:              { in_flow: true, score: 0.7 },
+      attention:         { novelty_score: 0.4, spotlight_count: 2 },
+      homeostasis:       { worst_deviation: 0.1, allostatic_load: 0.1 }
+    }
+  end
+
+  describe '#compute_reward' do
+    it 'returns reward hash' do
+      result = client.compute_reward(tick_results: positive_tick)
+      expect(result).to include(:reward, :rpe, :rpe_class, :running_average,
+                                :predicted_reward, :sources, :learning_signal)
+    end
+
+    it 'returns positive reward for positive tick' do
+      result = client.compute_reward(tick_results: positive_tick)
+      expect(result[:reward]).to be > 0.0
+    end
+
+    it 'returns reward in valid range' do
+      result = client.compute_reward(tick_results: positive_tick)
+      expect(result[:reward]).to be_between(-1.0, 1.0)
+    end
+
+    it 'handles empty tick results' do
+      result = client.compute_reward(tick_results: {})
+      expect(result[:reward]).to be_a(Float)
+    end
+  end
+
+  describe '#reward_status' do
+    it 'returns status with health assessment' do
+      client.compute_reward(tick_results: positive_tick)
+      status = client.reward_status
+      expect(status).to include(:running_average, :predicted_reward, :last_rpe,
+                                :tick_count, :health)
+      expect(status[:health]).to include(:status, :severity)
+    end
+  end
+
+  describe '#reward_for' do
+    it 'returns domain report' do
+      client.compute_reward(tick_results: positive_tick)
+      report = client.reward_for(domain: :test)
+      expect(report).to include(:domain, :average, :trend, :history)
+    end
+
+    it 'returns empty for unknown domain' do
+      report = client.reward_for(domain: :unknown)
+      expect(report[:average]).to eq(0.0)
+    end
+  end
+
+  describe '#reward_history' do
+    it 'returns empty initially' do
+      result = client.reward_history
+      expect(result[:history]).to be_empty
+      expect(result[:total]).to eq(0)
+    end
+
+    it 'returns history after compute calls' do
+      5.times { client.compute_reward(tick_results: positive_tick) }
+      result = client.reward_history
+      expect(result[:history].size).to eq(5)
+      expect(result[:total]).to eq(5)
+    end
+
+    it 'respects limit' do
+      10.times { client.compute_reward(tick_results: positive_tick) }
+      result = client.reward_history(limit: 3)
+      expect(result[:history].size).to eq(3)
+    end
+
+    it 'includes discounted return' do
+      5.times { client.compute_reward(tick_results: positive_tick) }
+      result = client.reward_history
+      expect(result[:discounted_return]).to be_a(Float)
+    end
+  end
+
+  describe '#domain_rewards' do
+    it 'returns empty initially' do
+      result = client.domain_rewards
+      expect(result[:domains]).to be_empty
+      expect(result[:domain_count]).to eq(0)
+    end
+
+    it 'tracks domains from tick results' do
+      client.compute_reward(tick_results: positive_tick)
+      result = client.domain_rewards
+      expect(result[:domain_count]).to be >= 1
+    end
+
+    it 'identifies best and worst domains' do
+      5.times { client.compute_reward(tick_results: positive_tick) }
+      result = client.domain_rewards
+      expect(result[:best_domain]).not_to be_nil if result[:domain_count] > 0
+    end
+  end
+
+  describe '#reward_stats' do
+    it 'returns comprehensive stats' do
+      client.compute_reward(tick_results: positive_tick)
+      stats = client.reward_stats
+      expect(stats).to include(:running_average, :predicted_reward, :volatility,
+                               :tick_count, :health, :domains_tracked,
+                               :history_size, :discounted_return,
+                               :anhedonic, :euphoric)
+    end
+  end
+
+  describe 'reward prediction error learning' do
+    it 'generates large RPE for unexpected positive after neutral' do
+      10.times { client.compute_reward(tick_results: {}) }
+      result = client.compute_reward(tick_results: positive_tick)
+      expect(result[:rpe]).to be > 0.0
+      expect(result[:learning_signal]).to be true
+    end
+
+    it 'generates negative RPE for unexpected negative after positive' do
+      10.times { client.compute_reward(tick_results: positive_tick) }
+      negative_tick = {
+        prediction_engine: { rolling_accuracy: 0.2, error_rate: 0.8 },
+        volition:          { completed_count: 0, failed_count: 2 },
+        flow:              { in_flow: false, score: 0.1 }
+      }
+      result = client.compute_reward(tick_results: negative_tick)
+      expect(result[:rpe]).to be < 0.0
+    end
+
+    it 'converges RPE to zero for stable rewards' do
+      30.times { client.compute_reward(tick_results: positive_tick) }
+      result = client.compute_reward(tick_results: positive_tick)
+      expect(result[:rpe].abs).to be < 0.1
+    end
+  end
+end