lex-agentic-affect 0.1.0

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

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Fatigue::Helpers::EnergyModel do
+  subject(:model) { described_class.new }
+
+  let(:constants) { Legion::Extensions::Agentic::Affect::Fatigue::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'starts at MAX_ENERGY' do
+      expect(model.energy).to eq(constants::MAX_ENERGY)
+    end
+
+    it 'starts as :fresh' do
+      expect(model.fatigue_level).to eq(:fresh)
+    end
+
+    it 'starts with zero ticks' do
+      expect(model.ticks_active).to eq(0)
+      expect(model.ticks_resting).to eq(0)
+    end
+
+    it 'starts without burnout' do
+      expect(model.burnout).to eq(false)
+    end
+
+    it 'starts with no recovery mode' do
+      expect(model.recovery_mode).to be_nil
+    end
+
+    it 'starts with empty history' do
+      expect(model.history).to be_empty
+    end
+
+    it 'sets peak_energy to MAX_ENERGY' do
+      expect(model.peak_energy).to eq(constants::MAX_ENERGY)
+    end
+  end
+
+  describe '#tick (active)' do
+    it 'reduces energy on an active tick' do
+      initial = model.energy
+      model.tick(cognitive_load: 0.5, emotional_arousal: 0.5, is_resting: false)
+      expect(model.energy).to be < initial
+    end
+
+    it 'increments ticks_active' do
+      model.tick(is_resting: false)
+      expect(model.ticks_active).to eq(1)
+    end
+
+    it 'does not increment ticks_resting on active tick' do
+      model.tick(is_resting: false)
+      expect(model.ticks_resting).to eq(0)
+    end
+
+    it 'drains more with high cognitive load' do
+      m1 = described_class.new
+      m2 = described_class.new
+      m1.tick(cognitive_load: 0.1, emotional_arousal: 0.5, is_resting: false)
+      m2.tick(cognitive_load: 0.9, emotional_arousal: 0.5, is_resting: false)
+      expect(m2.energy).to be < m1.energy
+    end
+
+    it 'drains more with high emotional arousal' do
+      m1 = described_class.new
+      m2 = described_class.new
+      m1.tick(cognitive_load: 0.5, emotional_arousal: 0.1, is_resting: false)
+      m2.tick(cognitive_load: 0.5, emotional_arousal: 0.9, is_resting: false)
+      expect(m2.energy).to be < m1.energy
+    end
+
+    it 'records a history snapshot' do
+      model.tick
+      expect(model.history.size).to eq(1)
+    end
+
+    it 'returns a hash with energy and fatigue_level' do
+      result = model.tick
+      expect(result).to include(:energy, :fatigue_level, :performance_factor)
+    end
+  end
+
+  describe '#tick (resting)' do
+    before do
+      # Drain some energy first
+      20.times { model.tick(cognitive_load: 0.8, emotional_arousal: 0.8, is_resting: false) }
+    end
+
+    it 'recovers energy on a rest tick' do
+      drained = model.energy
+      model.tick(is_resting: true)
+      expect(model.energy).to be > drained
+    end
+
+    it 'increments ticks_resting' do
+      model.tick(is_resting: true)
+      expect(model.ticks_resting).to be >= 1
+    end
+
+    it 'resets consecutive_low_ticks when resting' do
+      model.tick(is_resting: true)
+      expect(model.consecutive_low_ticks).to eq(0)
+    end
+  end
+
+  describe '#fatigue_level classification' do
+    it 'returns :fresh when energy is high' do
+      expect(model.fatigue_level).to eq(:fresh)
+    end
+
+    it 'returns :depleted when energy is very low' do
+      model.instance_variable_set(:@energy, 0.05)
+      model.send(:classify_fatigue)
+      expect(model.fatigue_level).to eq(:depleted)
+    end
+
+    it 'returns :alert when energy is between alert and fresh thresholds' do
+      # Drain to alert range (0.6-0.8)
+      model.instance_variable_set(:@energy, 0.7)
+      model.send(:classify_fatigue)
+      expect(model.fatigue_level).to eq(:alert)
+    end
+
+    it 'returns :tired when energy is in tired range' do
+      model.instance_variable_set(:@energy, 0.5)
+      model.send(:classify_fatigue)
+      expect(model.fatigue_level).to eq(:tired)
+    end
+
+    it 'returns :exhausted when energy is in exhausted range' do
+      model.instance_variable_set(:@energy, 0.3)
+      model.send(:classify_fatigue)
+      expect(model.fatigue_level).to eq(:exhausted)
+    end
+  end
+
+  describe '#performance_factor' do
+    it 'returns 1.0 when fresh' do
+      expect(model.performance_factor).to eq(1.0)
+    end
+
+    it 'returns degraded performance when tired' do
+      model.instance_variable_set(:@energy, 0.5)
+      model.send(:classify_fatigue)
+      expect(model.performance_factor).to be < 1.0
+    end
+  end
+
+  describe '#needs_rest?' do
+    it 'returns false when energy is high' do
+      expect(model.needs_rest?).to eq(false)
+    end
+
+    it 'returns true when energy is below REST_THRESHOLD' do
+      model.instance_variable_set(:@energy, constants::REST_THRESHOLD - 0.01)
+      expect(model.needs_rest?).to eq(true)
+    end
+  end
+
+  describe '#critically_fatigued?' do
+    it 'returns false when energy is normal' do
+      expect(model.critically_fatigued?).to eq(false)
+    end
+
+    it 'returns true when energy is below CRITICAL_THRESHOLD' do
+      model.instance_variable_set(:@energy, constants::CRITICAL_THRESHOLD - 0.01)
+      expect(model.critically_fatigued?).to eq(true)
+    end
+  end
+
+  describe '#burnout?' do
+    it 'returns false initially' do
+      expect(model.burnout?).to eq(false)
+    end
+
+    it 'returns true after BURNOUT_THRESHOLD consecutive low-energy ticks' do
+      model.instance_variable_set(:@energy, 0.1)
+      model.instance_variable_set(:@consecutive_low_ticks, constants::BURNOUT_THRESHOLD + 1)
+      model.send(:check_burnout)
+      expect(model.burnout?).to eq(true)
+    end
+  end
+
+  describe '#enter_recovery' do
+    it 'sets recovery mode to a valid mode' do
+      model.enter_recovery(:full_rest)
+      expect(model.recovery_mode).to eq(:full_rest)
+    end
+
+    it 'rejects invalid recovery modes' do
+      model.enter_recovery(:turbo_nap)
+      expect(model.recovery_mode).to be_nil
+    end
+
+    it 'accepts all defined recovery modes' do
+      constants::RECOVERY_MODES.each do |mode|
+        m = described_class.new
+        m.enter_recovery(mode)
+        expect(m.recovery_mode).to eq(mode)
+      end
+    end
+  end
+
+  describe '#exit_recovery' do
+    it 'clears the recovery mode' do
+      model.enter_recovery(:sleep)
+      model.exit_recovery
+      expect(model.recovery_mode).to be_nil
+    end
+  end
+
+  describe '#time_to_rest_threshold' do
+    it 'returns 0 when already needs rest' do
+      model.instance_variable_set(:@energy, 0.1)
+      expect(model.time_to_rest_threshold).to eq(0)
+    end
+
+    it 'returns a positive integer when energy is above REST_THRESHOLD' do
+      expect(model.time_to_rest_threshold).to be > 0
+    end
+  end
+
+  describe '#time_to_full_recovery' do
+    it 'returns 0 when already at MAX_ENERGY' do
+      expect(model.time_to_full_recovery).to eq(0)
+    end
+
+    it 'returns a positive integer when below MAX_ENERGY' do
+      model.instance_variable_set(:@energy, 0.5)
+      expect(model.time_to_full_recovery).to be > 0
+    end
+
+    it 'recovers faster with sleep mode' do
+      m1 = described_class.new
+      m2 = described_class.new
+      m1.instance_variable_set(:@energy, 0.5)
+      m2.instance_variable_set(:@energy, 0.5)
+      m1.enter_recovery(:active_rest)
+      m2.enter_recovery(:sleep)
+      expect(m2.time_to_full_recovery).to be < m1.time_to_full_recovery
+    end
+  end
+
+  describe '#trend' do
+    it 'returns :stable with less than 5 history entries' do
+      3.times { model.tick }
+      expect(model.trend).to eq(:stable)
+    end
+
+    it 'returns :draining after continuous active ticks' do
+      # Ensure 5+ history entries with declining energy
+      10.times { model.tick(cognitive_load: 0.9, emotional_arousal: 0.9, is_resting: false) }
+      expect(model.trend).to eq(:draining)
+    end
+
+    it 'returns :recovering after rest ticks from low energy' do
+      model.instance_variable_set(:@energy, 0.2)
+      10.times { model.tick(is_resting: true) }
+      expect(model.trend).to eq(:recovering)
+    end
+  end
+
+  describe 'history capping' do
+    it 'does not exceed MAX_HISTORY entries' do
+      (constants::MAX_HISTORY + 20).times { model.tick }
+      expect(model.history.size).to eq(constants::MAX_HISTORY)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      result = model.to_h
+      expect(result).to include(
+        :energy, :fatigue_level, :performance_factor,
+        :needs_rest, :critically_fatigued, :burnout,
+        :recovery_mode, :peak_energy, :ticks_active,
+        :ticks_resting, :trend, :history_size
+      )
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Fatigue::Helpers::FatigueStore do
+  subject(:store) { described_class.new }
+
+  let(:constants) { Legion::Extensions::Agentic::Affect::Fatigue::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'creates a default EnergyModel' do
+      expect(store.model).to be_a(Legion::Extensions::Agentic::Affect::Fatigue::Helpers::EnergyModel)
+    end
+
+    it 'accepts an injected model' do
+      custom_model = Legion::Extensions::Agentic::Affect::Fatigue::Helpers::EnergyModel.new
+      s = described_class.new(model: custom_model)
+      expect(s.model).to be(custom_model)
+    end
+
+    it 'records session start time' do
+      expect(store.session_start).to be_a(Time)
+    end
+
+    it 'starts with zero ticks' do
+      expect(store.total_active_ticks).to eq(0)
+      expect(store.total_rest_ticks).to eq(0)
+    end
+  end
+
+  describe '#update' do
+    it 'calls model.tick and returns results' do
+      result = store.update(tick_results: { cognitive_load: 0.5, emotional_arousal: 0.5 })
+      expect(result).to include(:energy, :fatigue_level)
+    end
+
+    it 'increments total_active_ticks on active update' do
+      store.update(tick_results: { cognitive_load: 0.5 })
+      expect(store.total_active_ticks).to eq(1)
+    end
+
+    it 'increments total_rest_ticks when mode is :resting' do
+      store.update(tick_results: { mode: :resting })
+      expect(store.total_rest_ticks).to eq(1)
+    end
+
+    it 'uses default cognitive_load and emotional_arousal when not provided' do
+      expect { store.update(tick_results: {}) }.not_to raise_error
+    end
+
+    it 'increments rest ticks when recovery_mode is set on model' do
+      store.model.enter_recovery(:full_rest)
+      store.update(tick_results: {})
+      expect(store.total_rest_ticks).to be >= 1
+    end
+  end
+
+  describe '#recommend_action' do
+    it 'returns :continue when energy is high' do
+      expect(store.recommend_action).to eq(:continue)
+    end
+
+    it 'returns :reduce_load when tired' do
+      store.model.instance_variable_set(:@energy, 0.5)
+      store.model.instance_variable_set(:@fatigue_level, :tired)
+      expect(store.recommend_action).to eq(:reduce_load)
+    end
+
+    it 'returns :take_break when needs_rest' do
+      store.model.instance_variable_set(:@energy, constants::REST_THRESHOLD - 0.01)
+      expect(store.recommend_action).to eq(:take_break)
+    end
+
+    it 'returns :enter_rest when critically fatigued' do
+      store.model.instance_variable_set(:@energy, constants::CRITICAL_THRESHOLD - 0.01)
+      expect(store.recommend_action).to eq(:enter_rest)
+    end
+
+    it 'returns :emergency_shutdown when burnout' do
+      store.model.instance_variable_set(:@burnout, true)
+      expect(store.recommend_action).to eq(:emergency_shutdown)
+    end
+
+    it 'returns :emergency_shutdown when critically fatigued with burnout' do
+      store.model.instance_variable_set(:@energy, 0.01)
+      store.model.instance_variable_set(:@burnout, true)
+      expect(store.recommend_action).to eq(:emergency_shutdown)
+    end
+  end
+
+  describe '#session_stats' do
+    it 'returns a hash with expected keys' do
+      result = store.session_stats
+      expect(result).to include(
+        :duration_seconds, :total_ticks, :active_ticks, :rest_ticks,
+        :active_ratio, :current_energy, :fatigue_level, :burnout
+      )
+    end
+
+    it 'reflects updated tick counts' do
+      3.times { store.update(tick_results: {}) }
+      stats = store.session_stats
+      expect(stats[:active_ticks]).to eq(3)
+      expect(stats[:total_ticks]).to eq(3)
+    end
+
+    it 'reports active_ratio of 0.0 before any ticks' do
+      expect(store.session_stats[:active_ratio]).to eq(0.0)
+    end
+  end
+
+  describe '#energy_forecast' do
+    it 'returns forecast for requested number of ticks' do
+      result = store.energy_forecast(ticks: 10)
+      expect(result[:forecast].size).to eq(10)
+    end
+
+    it 'includes current_energy and ticks_to_rest' do
+      result = store.energy_forecast(ticks: 5)
+      expect(result).to include(:current_energy, :ticks_to_rest, :forecast)
+    end
+
+    it 'energy in forecast is non-increasing (draining scenario)' do
+      result = store.energy_forecast(ticks: 5)
+      energies = result[:forecast].map { |f| f[:energy] }
+      energies.each_cons(2) do |a, b|
+        expect(b).to be <= a
+      end
+    end
+
+    it 'each forecast entry includes tick, energy, and fatigue_level' do
+      result = store.energy_forecast(ticks: 3)
+      result[:forecast].each do |entry|
+        expect(entry).to include(:tick, :energy, :fatigue_level)
+      end
+    end
+  end
+
+  describe '#optimal_rest_schedule' do
+    it 'returns schedule hash with expected keys' do
+      result = store.optimal_rest_schedule
+      expect(result).to include(
+        :recommend_rest_in, :full_recovery_ticks, :current_energy,
+        :recommended_mode, :trend
+      )
+    end
+
+    it 'recommends sleep mode for critically low energy' do
+      store.model.instance_variable_set(:@energy, constants::CRITICAL_THRESHOLD - 0.01)
+      result = store.optimal_rest_schedule
+      expect(result[:recommended_mode]).to eq(:sleep)
+    end
+
+    it 'recommends active_rest when energy is normal' do
+      result = store.optimal_rest_schedule
+      expect(result[:recommended_mode]).to eq(:active_rest)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/fatigue/runners/fatigue_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Fatigue::Runners::Fatigue do
+  let(:client) { Legion::Extensions::Agentic::Affect::Fatigue::Client.new }
+
+  describe '#update_fatigue' do
+    it 'returns energy, fatigue_level, performance_factor, and recommendation' do
+      result = client.update_fatigue(tick_results: { cognitive_load: 0.5, emotional_arousal: 0.5 })
+      expect(result).to include(:energy, :fatigue_level, :performance_factor, :recommendation)
+    end
+
+    it 'accepts empty tick_results' do
+      expect { client.update_fatigue(tick_results: {}) }.not_to raise_error
+    end
+
+    it 'accepts no arguments' do
+      expect { client.update_fatigue }.not_to raise_error
+    end
+
+    it 'returns a valid fatigue level symbol' do
+      result = client.update_fatigue
+      expected_levels = Legion::Extensions::Agentic::Affect::Fatigue::Helpers::Constants::FATIGUE_LEVELS.keys
+      expect(expected_levels).to include(result[:fatigue_level])
+    end
+
+    it 'returns a valid recommendation symbol' do
+      result = client.update_fatigue
+      valid_recs = %i[continue reduce_load take_break enter_rest emergency_shutdown]
+      expect(valid_recs).to include(result[:recommendation])
+    end
+
+    it 'includes needs_rest and burnout in result' do
+      result = client.update_fatigue
+      expect(result).to include(:needs_rest, :burnout)
+    end
+  end
+
+  describe '#energy_status' do
+    it 'returns current energy state' do
+      result = client.energy_status
+      expect(result).to include(
+        :energy, :fatigue_level, :performance_factor,
+        :needs_rest, :critically_fatigued, :burnout, :recovery_mode, :trend
+      )
+    end
+
+    it 'starts fresh' do
+      result = client.energy_status
+      expect(result[:fatigue_level]).to eq(:fresh)
+      expect(result[:burnout]).to eq(false)
+    end
+  end
+
+  describe '#enter_rest' do
+    it 'sets recovery mode on the model' do
+      result = client.enter_rest(mode: :full_rest)
+      expect(result[:success]).to eq(true)
+      expect(result[:mode]).to eq(:full_rest)
+    end
+
+    it 'defaults to :full_rest mode' do
+      result = client.enter_rest
+      expect(result[:mode]).to eq(:full_rest)
+    end
+
+    it 'returns error for unknown mode' do
+      result = client.enter_rest(mode: :hyper_sleep)
+      expect(result[:success]).to eq(false)
+      expect(result[:error]).to include('hyper_sleep')
+    end
+
+    it 'accepts all valid recovery modes' do
+      Legion::Extensions::Agentic::Affect::Fatigue::Helpers::Constants::RECOVERY_MODES.each do |mode|
+        c = Legion::Extensions::Agentic::Affect::Fatigue::Client.new
+        result = c.enter_rest(mode: mode)
+        expect(result[:success]).to eq(true)
+      end
+    end
+  end
+
+  describe '#exit_rest' do
+    it 'clears recovery mode' do
+      client.enter_rest(mode: :sleep)
+      result = client.exit_rest
+      expect(result[:success]).to eq(true)
+    end
+
+    it 'returns current energy and fatigue_level' do
+      result = client.exit_rest
+      expect(result).to include(:energy, :fatigue_level)
+    end
+  end
+
+  describe '#energy_forecast' do
+    it 'returns forecast for default ticks' do
+      result = client.energy_forecast
+      expect(result[:forecast]).not_to be_empty
+    end
+
+    it 'returns forecast for specified ticks' do
+      result = client.energy_forecast(ticks: 20)
+      expect(result[:forecast].size).to eq(20)
+    end
+
+    it 'includes current_energy and ticks_to_rest' do
+      result = client.energy_forecast(ticks: 10)
+      expect(result).to include(:current_energy, :ticks_to_rest, :forecast)
+    end
+  end
+
+  describe '#fatigue_stats' do
+    it 'returns session, history, trend, and schedule' do
+      result = client.fatigue_stats
+      expect(result).to include(:session, :history, :trend, :schedule)
+    end
+
+    it 'session includes expected keys' do
+      result = client.fatigue_stats
+      expect(result[:session]).to include(:total_ticks, :current_energy, :fatigue_level, :burnout)
+    end
+
+    it 'trend is a symbol' do
+      result = client.fatigue_stats
+      expect(result[:trend]).to be_a(Symbol)
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Flow::Client do
+  describe '#initialize' do
+    it 'creates a default flow detector' do
+      client = described_class.new
+      expect(client.flow_detector).to be_a(Legion::Extensions::Agentic::Affect::Flow::Helpers::FlowDetector)
+    end
+
+    it 'accepts an injected flow detector' do
+      detector = Legion::Extensions::Agentic::Affect::Flow::Helpers::FlowDetector.new
+      client = described_class.new(flow_detector: detector)
+      expect(client.flow_detector).to be(detector)
+    end
+
+    it 'ignores unknown keyword arguments' do
+      expect { described_class.new(unknown: 'value') }.not_to raise_error
+    end
+  end
+
+  describe 'runner integration' do
+    it 'responds to update_flow' do
+      expect(described_class.new).to respond_to(:update_flow)
+    end
+
+    it 'responds to flow_status' do
+      expect(described_class.new).to respond_to(:flow_status)
+    end
+
+    it 'responds to flow_effects' do
+      expect(described_class.new).to respond_to(:flow_effects)
+    end
+
+    it 'responds to flow_history' do
+      expect(described_class.new).to respond_to(:flow_history)
+    end
+
+    it 'responds to flow_stats' do
+      expect(described_class.new).to respond_to(:flow_stats)
+    end
+  end
+
+  describe 'shared state across calls' do
+    it 'accumulates flow state across multiple update_flow calls' do
+      client = described_class.new
+      tick = {
+        prediction_engine: { rolling_accuracy: 0.6, error_rate: 0.2 },
+        action_selection:  { complexity: 0.5 },
+        memory_retrieval:  { avg_strength: 0.6 },
+        habit:             { automation_level: 0.5 }
+      }
+      20.times { client.update_flow(tick_results: tick) }
+      expect(client.flow_history[:total]).to eq(20)
+    end
+  end
+end