lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/empathy/helpers/mental_model_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Empathy::Helpers::MentalModel do
+  subject(:model) { described_class.new(agent_id: 'agent-42') }
+
+  describe '#initialize' do
+    it 'sets agent_id' do
+      expect(model.agent_id).to eq('agent-42')
+    end
+
+    it 'starts with unknown emotional state' do
+      expect(model.emotional_state).to eq(:unknown)
+    end
+
+    it 'starts with unknown cooperation stance' do
+      expect(model.cooperation_stance).to eq(:unknown)
+    end
+
+    it 'starts with 0.5 confidence' do
+      expect(model.confidence_level).to eq(0.5)
+    end
+  end
+
+  describe '#update_from_observation' do
+    it 'updates believed goal' do
+      model.update_from_observation(goal: 'code_review')
+      expect(model.believed_goal).to eq('code_review')
+    end
+
+    it 'updates emotional state' do
+      model.update_from_observation(emotion: :focused)
+      expect(model.emotional_state).to eq(:focused)
+    end
+
+    it 'updates cooperation stance' do
+      model.update_from_observation(cooperation: :cooperative)
+      expect(model.cooperation_stance).to eq(:cooperative)
+    end
+
+    it 'records interaction history' do
+      model.update_from_observation(summary: 'sent a message')
+      expect(model.interaction_history.size).to eq(1)
+    end
+
+    it 'rejects unknown emotions as :unknown' do
+      model.update_from_observation(emotion: :nonexistent)
+      expect(model.emotional_state).to eq(:unknown)
+    end
+
+    it 'updates confidence via EMA' do
+      model.update_from_observation(evidence_strength: 0.9)
+      expect(model.confidence_level).to be > 0.5
+    end
+  end
+
+  describe '#predict_reaction' do
+    before do
+      model.update_from_observation(cooperation: :cooperative, emotion: :calm)
+    end
+
+    it 'returns a prediction hash' do
+      prediction = model.predict_reaction(emotional_impact: :positive)
+      expect(prediction).to have_key(:prediction_id)
+      expect(prediction).to have_key(:likely_response)
+      expect(prediction).to have_key(:confidence)
+    end
+
+    it 'predicts cooperative agents will likely agree' do
+      prediction = model.predict_reaction(cooperative_option: :accept)
+      expect(prediction[:likely_response]).to eq(:accept)
+    end
+
+    it 'stores predictions' do
+      model.predict_reaction({})
+      expect(model.predictions.size).to eq(1)
+    end
+  end
+
+  describe '#record_prediction_outcome' do
+    it 'records accurate prediction' do
+      prediction = model.predict_reaction({})
+      result = model.record_prediction_outcome(
+        prediction_id:   prediction[:prediction_id],
+        actual_response: :agreed,
+        accurate:        true
+      )
+      expect(result).to be true
+    end
+
+    it 'returns nil for unknown prediction' do
+      result = model.record_prediction_outcome(
+        prediction_id:   'nonexistent',
+        actual_response: :agreed,
+        accurate:        true
+      )
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#prediction_accuracy' do
+    it 'returns nil with no outcomes' do
+      expect(model.prediction_accuracy).to be_nil
+    end
+
+    it 'computes accuracy from outcomes' do
+      3.times do
+        pred = model.predict_reaction({})
+        model.record_prediction_outcome(prediction_id: pred[:prediction_id],
+                                        actual_response: :ok, accurate: true)
+      end
+      pred = model.predict_reaction({})
+      model.record_prediction_outcome(prediction_id: pred[:prediction_id],
+                                      actual_response: :nope, accurate: false)
+
+      expect(model.prediction_accuracy).to eq(0.75)
+    end
+  end
+
+  describe '#stale?' do
+    it 'returns false when fresh' do
+      expect(model.stale?).to be false
+    end
+
+    it 'returns true when old' do
+      model.instance_variable_set(:@updated_at, Time.now.utc - 400)
+      expect(model.stale?).to be true
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces confidence' do
+      original = model.confidence_level
+      model.decay
+      expect(model.confidence_level).to be < original
+    end
+
+    it 'floors confidence at 0.1' do
+      50.times { model.decay }
+      expect(model.confidence_level).to be >= 0.1
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a complete state hash' do
+      h = model.to_h
+      expect(h).to include(:agent_id, :believed_goal, :emotional_state,
+                           :cooperation_stance, :confidence_level, :stale)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/empathy/helpers/model_store_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Empathy::Helpers::ModelStore do
+  subject(:store) { described_class.new }
+
+  describe '#get_or_create' do
+    it 'creates a new model for unknown agent' do
+      model = store.get_or_create('agent-1')
+      expect(model.agent_id).to eq('agent-1')
+    end
+
+    it 'returns existing model' do
+      m1 = store.get_or_create('agent-1')
+      m2 = store.get_or_create('agent-1')
+      expect(m1).to equal(m2)
+    end
+  end
+
+  describe '#update' do
+    it 'updates model with observation' do
+      model = store.update('agent-1', emotion: :focused, cooperation: :cooperative)
+      expect(model.emotional_state).to eq(:focused)
+    end
+
+    it 'increments store size' do
+      store.update('agent-1', {})
+      store.update('agent-2', {})
+      expect(store.size).to eq(2)
+    end
+  end
+
+  describe '#predict' do
+    it 'returns nil for unknown agent' do
+      expect(store.predict('nobody', {})).to be_nil
+    end
+
+    it 'returns prediction for known agent' do
+      store.update('agent-1', cooperation: :cooperative)
+      prediction = store.predict('agent-1', {})
+      expect(prediction).to have_key(:likely_response)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all models' do
+      store.update('agent-1', {})
+      store.update('agent-2', {})
+      count = store.decay_all
+      expect(count).to eq(2)
+    end
+  end
+
+  describe '#remove_stale' do
+    it 'removes stale models with no interactions' do
+      store.get_or_create('agent-old')
+      store.models['agent-old'].instance_variable_set(:@updated_at, Time.now.utc - 400)
+      removed = store.remove_stale
+      expect(removed).to eq(1)
+      expect(store.size).to eq(0)
+    end
+
+    it 'keeps stale models that have interactions' do
+      store.update('agent-old', summary: 'did something')
+      store.models['agent-old'].instance_variable_set(:@updated_at, Time.now.utc - 400)
+      removed = store.remove_stale
+      expect(removed).to eq(0)
+    end
+  end
+
+  describe '#by_cooperation' do
+    it 'filters by cooperation stance' do
+      store.update('a', cooperation: :cooperative)
+      store.update('b', cooperation: :competitive)
+      store.update('c', cooperation: :cooperative)
+      expect(store.by_cooperation(:cooperative).size).to eq(2)
+    end
+  end
+
+  describe '#by_emotion' do
+    it 'filters by emotional state' do
+      store.update('a', emotion: :stressed)
+      store.update('b', emotion: :calm)
+      expect(store.by_emotion(:stressed).size).to eq(1)
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all models' do
+      store.update('a', {})
+      store.clear
+      expect(store.size).to eq(0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/empathy/runners/empathy_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Empathy::Runners::Empathy do
+  let(:client) { Legion::Extensions::Agentic::Affect::Empathy::Client.new }
+
+  describe '#observe_agent' do
+    it 'creates a mental model from observation' do
+      result = client.observe_agent(agent_id: 'agent-b', observation: {
+                                      goal: 'testing', emotion: :focused, cooperation: :cooperative, evidence_strength: 0.8
+                                    })
+      expect(result[:emotional_state]).to eq(:focused)
+      expect(result[:cooperation_stance]).to eq(:cooperative)
+      expect(result[:believed_goal]).to eq('testing')
+    end
+
+    it 'updates existing models' do
+      client.observe_agent(agent_id: 'agent-b', observation: { emotion: :calm })
+      result = client.observe_agent(agent_id: 'agent-b', observation: { emotion: :stressed })
+      expect(result[:emotional_state]).to eq(:stressed)
+    end
+  end
+
+  describe '#predict_reaction' do
+    before do
+      client.observe_agent(agent_id: 'agent-b', observation: {
+                             cooperation: :cooperative, emotion: :calm
+                           })
+    end
+
+    it 'returns prediction for known agent' do
+      result = client.predict_reaction(agent_id: 'agent-b', scenario: {
+                                         emotional_impact: :positive, impact_on_agent: :beneficial
+                                       })
+      expect(result).to have_key(:likely_response)
+      expect(result).to have_key(:confidence)
+    end
+
+    it 'returns error for unknown agent' do
+      result = client.predict_reaction(agent_id: 'nobody', scenario: {})
+      expect(result[:error]).to eq(:no_model)
+    end
+  end
+
+  describe '#record_outcome' do
+    it 'records prediction outcome' do
+      client.observe_agent(agent_id: 'agent-b', observation: { cooperation: :cooperative })
+      prediction = client.predict_reaction(agent_id: 'agent-b', scenario: {})
+      result = client.record_outcome(
+        agent_id:        'agent-b',
+        prediction_id:   prediction[:prediction_id],
+        actual_response: :agreed,
+        accurate:        true
+      )
+      expect(result[:accurate]).to be true
+      expect(result[:current_accuracy]).to eq(1.0)
+    end
+
+    it 'returns error for unknown agent' do
+      result = client.record_outcome(agent_id: 'nobody', prediction_id: 'x',
+                                     actual_response: :ok, accurate: true)
+      expect(result[:error]).to eq(:no_model)
+    end
+
+    it 'returns error for unknown prediction' do
+      client.observe_agent(agent_id: 'agent-b', observation: {})
+      result = client.record_outcome(agent_id: 'agent-b', prediction_id: 'nonexistent',
+                                     actual_response: :ok, accurate: true)
+      expect(result[:error]).to eq(:prediction_not_found)
+    end
+  end
+
+  describe '#perspective_take' do
+    it 'generates narrative for known agent' do
+      client.observe_agent(agent_id: 'agent-b', observation: {
+                             goal: 'code_review', emotion: :focused, cooperation: :cooperative
+                           })
+      result = client.perspective_take(agent_id: 'agent-b')
+      expect(result[:narrative]).to include('agent-b')
+      expect(result[:narrative]).to include('code_review')
+    end
+
+    it 'returns error for unknown agent' do
+      result = client.perspective_take(agent_id: 'nobody')
+      expect(result[:error]).to eq(:no_model)
+    end
+  end
+
+  describe '#social_landscape' do
+    before do
+      client.observe_agent(agent_id: 'a', observation: { cooperation: :cooperative, emotion: :calm })
+      client.observe_agent(agent_id: 'b', observation: { cooperation: :cooperative, emotion: :focused })
+      client.observe_agent(agent_id: 'c', observation: { cooperation: :competitive, emotion: :stressed })
+    end
+
+    it 'returns social climate assessment' do
+      result = client.social_landscape
+      expect(result[:tracked_agents]).to eq(3)
+      expect(result[:cooperative_count]).to eq(2)
+      expect(result[:competitive_count]).to eq(1)
+      expect(result).to have_key(:overall_climate)
+    end
+
+    it 'assesses harmonious climate when mostly cooperative' do
+      client.observe_agent(agent_id: 'd', observation: { cooperation: :cooperative })
+      result = client.social_landscape
+      expect(result[:overall_climate]).to eq(:harmonious)
+    end
+  end
+
+  describe '#decay_models' do
+    it 'decays all models' do
+      client.observe_agent(agent_id: 'a', observation: {})
+      result = client.decay_models
+      expect(result[:decayed]).to eq(1)
+    end
+  end
+
+  describe '#empathy_stats' do
+    it 'returns summary statistics' do
+      client.observe_agent(agent_id: 'a', observation: { cooperation: :cooperative })
+      client.predict_reaction(agent_id: 'a', scenario: {})
+      result = client.empathy_stats
+      expect(result[:tracked_agents]).to eq(1)
+      expect(result[:total_predictions]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/fatigue/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Fatigue::Client do
+  subject(:client) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates a default fatigue_store' do
+      expect(client.fatigue_store).to be_a(Legion::Extensions::Agentic::Affect::Fatigue::Helpers::FatigueStore)
+    end
+
+    it 'accepts an injected fatigue_store' do
+      custom_store = Legion::Extensions::Agentic::Affect::Fatigue::Helpers::FatigueStore.new
+      c = described_class.new(fatigue_store: custom_store)
+      expect(c.fatigue_store).to be(custom_store)
+    end
+  end
+
+  describe 'runner methods' do
+    it 'responds to update_fatigue' do
+      expect(client).to respond_to(:update_fatigue)
+    end
+
+    it 'responds to energy_status' do
+      expect(client).to respond_to(:energy_status)
+    end
+
+    it 'responds to enter_rest' do
+      expect(client).to respond_to(:enter_rest)
+    end
+
+    it 'responds to exit_rest' do
+      expect(client).to respond_to(:exit_rest)
+    end
+
+    it 'responds to energy_forecast' do
+      expect(client).to respond_to(:energy_forecast)
+    end
+
+    it 'responds to fatigue_stats' do
+      expect(client).to respond_to(:fatigue_stats)
+    end
+  end
+
+  describe 'state persistence' do
+    it 'maintains state across multiple update calls' do
+      5.times { client.update_fatigue(tick_results: { cognitive_load: 0.8, emotional_arousal: 0.8 }) }
+      stats = client.fatigue_stats
+      expect(stats[:session][:active_ticks]).to eq(5)
+    end
+
+    it 'reflects state after entering rest' do
+      client.enter_rest(mode: :sleep)
+      status = client.energy_status
+      expect(status[:recovery_mode]).to eq(:sleep)
+    end
+
+    it 'clears recovery mode after exit_rest' do
+      client.enter_rest(mode: :sleep)
+      client.exit_rest
+      status = client.energy_status
+      expect(status[:recovery_mode]).to be_nil
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Fatigue::Helpers::Constants do
+  describe 'energy limits' do
+    it 'defines MAX_ENERGY as 1.0' do
+      expect(described_class::MAX_ENERGY).to eq(1.0)
+    end
+
+    it 'defines MIN_ENERGY as 0.0' do
+      expect(described_class::MIN_ENERGY).to eq(0.0)
+    end
+
+    it 'MAX_ENERGY is greater than MIN_ENERGY' do
+      expect(described_class::MAX_ENERGY).to be > described_class::MIN_ENERGY
+    end
+  end
+
+  describe 'drain and recovery rates' do
+    it 'defines ACTIVE_DRAIN_RATE as a positive float' do
+      expect(described_class::ACTIVE_DRAIN_RATE).to be > 0.0
+    end
+
+    it 'defines RESTING_RECOVERY_RATE as a positive float' do
+      expect(described_class::RESTING_RECOVERY_RATE).to be > 0.0
+    end
+
+    it 'defines COGNITIVE_DRAIN_MULTIPLIER greater than 1.0' do
+      expect(described_class::COGNITIVE_DRAIN_MULTIPLIER).to be > 1.0
+    end
+
+    it 'defines EMOTIONAL_DRAIN_MULTIPLIER greater than 1.0' do
+      expect(described_class::EMOTIONAL_DRAIN_MULTIPLIER).to be > 1.0
+    end
+  end
+
+  describe 'FATIGUE_LEVELS' do
+    subject(:levels) { described_class::FATIGUE_LEVELS }
+
+    it 'contains exactly 5 levels' do
+      expect(levels.size).to eq(5)
+    end
+
+    it 'includes fresh, alert, tired, exhausted, depleted' do
+      expect(levels).to include(:fresh, :alert, :tired, :exhausted, :depleted)
+    end
+
+    it 'has thresholds in descending order' do
+      values = levels.values
+      expect(values).to eq(values.sort.reverse)
+    end
+
+    it 'fresh threshold is the highest' do
+      expect(levels[:fresh]).to be > levels[:alert]
+    end
+
+    it 'depleted threshold is 0.0' do
+      expect(levels[:depleted]).to eq(0.0)
+    end
+  end
+
+  describe 'PERFORMANCE_DEGRADATION' do
+    subject(:degradation) { described_class::PERFORMANCE_DEGRADATION }
+
+    it 'contains exactly 5 levels matching FATIGUE_LEVELS' do
+      expect(degradation.keys).to match_array(described_class::FATIGUE_LEVELS.keys)
+    end
+
+    it 'fresh performance is 1.0' do
+      expect(degradation[:fresh]).to eq(1.0)
+    end
+
+    it 'depleted performance is lowest' do
+      expect(degradation[:depleted]).to be < degradation[:exhausted]
+    end
+
+    it 'all values are between 0 and 1' do
+      degradation.each_value do |v|
+        expect(v).to be_between(0.0, 1.0)
+      end
+    end
+  end
+
+  describe 'RECOVERY_MODES' do
+    it 'includes expected recovery modes' do
+      expect(described_class::RECOVERY_MODES).to include(:active_rest, :light_duty, :full_rest, :sleep)
+    end
+
+    it 'has exactly 4 modes' do
+      expect(described_class::RECOVERY_MODES.size).to eq(4)
+    end
+  end
+
+  describe 'RECOVERY_RATES' do
+    subject(:rates) { described_class::RECOVERY_RATES }
+
+    it 'has a rate for each recovery mode' do
+      described_class::RECOVERY_MODES.each do |mode|
+        expect(rates).to include(mode)
+      end
+    end
+
+    it 'sleep has the highest recovery rate' do
+      expect(rates[:sleep]).to be > rates[:full_rest]
+      expect(rates[:full_rest]).to be > rates[:light_duty]
+      expect(rates[:light_duty]).to be > rates[:active_rest]
+    end
+  end
+
+  describe 'thresholds' do
+    it 'REST_THRESHOLD is between 0 and 1' do
+      expect(described_class::REST_THRESHOLD).to be_between(0.0, 1.0)
+    end
+
+    it 'CRITICAL_THRESHOLD is below REST_THRESHOLD' do
+      expect(described_class::CRITICAL_THRESHOLD).to be < described_class::REST_THRESHOLD
+    end
+
+    it 'SECOND_WIND_CHANCE is a small probability' do
+      expect(described_class::SECOND_WIND_CHANCE).to be_between(0.0, 0.1)
+    end
+
+    it 'BURNOUT_THRESHOLD is a positive integer' do
+      expect(described_class::BURNOUT_THRESHOLD).to be > 0
+    end
+
+    it 'MAX_HISTORY is a positive integer' do
+      expect(described_class::MAX_HISTORY).to be > 0
+    end
+  end
+end