lex-agentic-affect 0.1.0

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/regulation/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Regulation::Client do
+  subject(:client) { described_class.new }
+
+  describe '#initialize' do
+    it 'creates a regulation_model' do
+      expect(client.regulation_model).to be_a(Legion::Extensions::Agentic::Affect::Regulation::Helpers::RegulationModel)
+    end
+
+    it 'accepts an injected regulation_model' do
+      custom_model = Legion::Extensions::Agentic::Affect::Regulation::Helpers::RegulationModel.new
+      c = described_class.new(regulation_model: custom_model)
+      expect(c.regulation_model).to be(custom_model)
+    end
+  end
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:regulate_emotion)
+    expect(client).to respond_to(:recommend_strategy)
+    expect(client).to respond_to(:update_emotional_regulation)
+    expect(client).to respond_to(:regulation_profile)
+    expect(client).to respond_to(:regulation_history)
+    expect(client).to respond_to(:emotional_regulation_stats)
+  end
+
+  it 'persists regulation model state across calls' do
+    client.regulate_emotion(emotion_magnitude: 0.7, emotion_valence: :negative, strategy: :cognitive_reappraisal)
+    stats = client.emotional_regulation_stats
+    expect(stats[:total_events]).to eq(1)
+  end
+
+  it 'runs a full regulation cycle' do
+    # First, get a recommendation
+    rec = client.recommend_strategy(emotion_magnitude: 0.8, emotion_valence: :negative)
+    expect(rec[:recommended]).to be_a(Symbol)
+
+    # Apply that strategy
+    reg = client.regulate_emotion(emotion_magnitude: 0.8, emotion_valence: :negative,
+                                  strategy: rec[:recommended])
+    expect(reg[:regulated_magnitude]).to be < 0.8
+
+    # Tick decay
+    tick = client.update_emotional_regulation
+    expect(tick[:success]).to be(true)
+
+    # Check profile
+    profile = client.regulation_profile
+    expect(profile[:skills]).not_to be_empty
+
+    # Check history
+    history = client.regulation_history
+    expect(history[:count]).to eq(1)
+
+    # Check stats
+    stats = client.emotional_regulation_stats
+    expect(stats[:total_events]).to eq(1)
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Regulation::Helpers::Constants do
+  let(:mod) { described_class }
+
+  describe 'STRATEGIES' do
+    it 'defines all five strategies' do
+      expect(mod::STRATEGIES).to eq(%i[
+                                      situation_selection
+                                      situation_modification
+                                      attentional_deployment
+                                      cognitive_reappraisal
+                                      response_suppression
+                                    ])
+    end
+
+    it 'is frozen' do
+      expect(mod::STRATEGIES).to be_frozen
+    end
+  end
+
+  describe 'STRATEGY_EFFECTIVENESS' do
+    it 'covers all strategies' do
+      expect(mod::STRATEGY_EFFECTIVENESS.keys).to match_array(mod::STRATEGIES)
+    end
+
+    it 'has values in [0, 1]' do
+      mod::STRATEGY_EFFECTIVENESS.each_value do |v|
+        expect(v).to be_between(0.0, 1.0)
+      end
+    end
+
+    it 'ranks situation_selection as most effective' do
+      expect(mod::STRATEGY_EFFECTIVENESS[:situation_selection]).to eq(0.8)
+    end
+
+    it 'ranks response_suppression as least effective' do
+      expect(mod::STRATEGY_EFFECTIVENESS[:response_suppression]).to eq(0.3)
+    end
+  end
+
+  describe 'STRATEGY_COST' do
+    it 'covers all strategies' do
+      expect(mod::STRATEGY_COST.keys).to match_array(mod::STRATEGIES)
+    end
+
+    it 'has values in [0, 1]' do
+      mod::STRATEGY_COST.each_value do |v|
+        expect(v).to be_between(0.0, 1.0)
+      end
+    end
+
+    it 'ranks situation_selection as lowest cost' do
+      expect(mod::STRATEGY_COST[:situation_selection]).to eq(0.1)
+    end
+
+    it 'ranks response_suppression as highest cost' do
+      expect(mod::STRATEGY_COST[:response_suppression]).to eq(0.35)
+    end
+  end
+
+  describe 'REGULATION_LABELS' do
+    it 'covers all ranges without gaps for values 0..1' do
+      [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0].each do |value|
+        matched = mod::REGULATION_LABELS.any? { |range, _| range.cover?(value) }
+        expect(matched).to be(true), "No range covers #{value}"
+      end
+    end
+
+    it 'maps 1.0 to :masterful' do
+      label = mod::REGULATION_LABELS.find { |range, _| range.cover?(1.0) }&.last
+      expect(label).to eq(:masterful)
+    end
+
+    it 'maps 0.0 to :reactive' do
+      label = mod::REGULATION_LABELS.find { |range, _| range.cover?(0.0) }&.last
+      expect(label).to eq(:reactive)
+    end
+
+    it 'maps 0.5 to :developing' do
+      label = mod::REGULATION_LABELS.find { |range, _| range.cover?(0.5) }&.last
+      expect(label).to eq(:developing)
+    end
+  end
+
+  describe 'numeric constants' do
+    it 'has REGULATION_ALPHA as a small positive float' do
+      expect(mod::REGULATION_ALPHA).to be > 0.0
+      expect(mod::REGULATION_ALPHA).to be < 1.0
+    end
+
+    it 'has DEFAULT_SKILL in [0, 1]' do
+      expect(mod::DEFAULT_SKILL).to be_between(0.0, 1.0)
+    end
+
+    it 'has SKILL_GAIN > SKILL_DECAY' do
+      expect(mod::SKILL_GAIN).to be > mod::SKILL_DECAY
+    end
+
+    it 'has MAX_REGULATION_HISTORY as positive integer' do
+      expect(mod::MAX_REGULATION_HISTORY).to be > 0
+    end
+
+    it 'has SUPPRESSION_PENALTY_THRESHOLD as positive integer' do
+      expect(mod::SUPPRESSION_PENALTY_THRESHOLD).to be > 0
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/regulation/helpers/regulation_model_spec.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Regulation::Helpers::RegulationModel do
+  subject(:model) { described_class.new }
+
+  let(:c) { Legion::Extensions::Agentic::Affect::Regulation::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'starts all skills at DEFAULT_SKILL' do
+      c::STRATEGIES.each do |strategy|
+        expect(model.skill[strategy]).to eq(c::DEFAULT_SKILL)
+      end
+    end
+
+    it 'starts with zero consecutive suppressions' do
+      expect(model.consecutive_suppressions).to eq(0)
+    end
+
+    it 'starts with empty history' do
+      expect(model.regulation_history).to be_empty
+    end
+  end
+
+  describe '#regulate' do
+    context 'with a valid strategy' do
+      it 'returns success: true' do
+        result = model.regulate(emotion_magnitude: 0.8, emotion_valence: :negative, strategy: :cognitive_reappraisal)
+        expect(result[:success]).to be(true)
+      end
+
+      it 'reduces emotion magnitude' do
+        result = model.regulate(emotion_magnitude: 0.8, emotion_valence: :negative, strategy: :cognitive_reappraisal)
+        expect(result[:regulated_magnitude]).to be < 0.8
+      end
+
+      it 'returns the strategy used' do
+        result = model.regulate(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :attentional_deployment)
+        expect(result[:strategy]).to eq(:attentional_deployment)
+      end
+
+      it 'returns a cost value' do
+        result = model.regulate(emotion_magnitude: 0.6, emotion_valence: :neutral, strategy: :situation_modification)
+        expect(result[:cost]).to be > 0.0
+      end
+
+      it 'records an event in history' do
+        expect { model.regulate(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :cognitive_reappraisal) }
+          .to change { model.regulation_history.size }.by(1)
+      end
+
+      it 'does not reduce regulated_magnitude below 0' do
+        result = model.regulate(emotion_magnitude: 0.0, emotion_valence: :neutral, strategy: :situation_selection)
+        expect(result[:regulated_magnitude]).to be >= 0.0
+      end
+    end
+
+    context 'with an unknown strategy' do
+      it 'returns success: false' do
+        result = model.regulate(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :teleportation)
+        expect(result[:success]).to be(false)
+      end
+
+      it 'does not change the magnitude' do
+        result = model.regulate(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :teleportation)
+        expect(result[:regulated_magnitude]).to eq(0.5)
+      end
+
+      it 'includes reason: :unknown_strategy' do
+        result = model.regulate(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :teleportation)
+        expect(result[:reason]).to eq(:unknown_strategy)
+      end
+    end
+
+    context 'suppression tracking' do
+      it 'increments consecutive_suppressions on suppression use' do
+        model.regulate(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :response_suppression)
+        expect(model.consecutive_suppressions).to eq(1)
+      end
+
+      it 'resets consecutive_suppressions when a different strategy is used' do
+        model.regulate(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :response_suppression)
+        model.regulate(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :cognitive_reappraisal)
+        expect(model.consecutive_suppressions).to eq(0)
+      end
+    end
+
+    context 'skill learning' do
+      it 'improves skill on successful regulation' do
+        initial = model.skill[:cognitive_reappraisal]
+        model.regulate(emotion_magnitude: 0.8, emotion_valence: :negative, strategy: :cognitive_reappraisal)
+        expect(model.skill[:cognitive_reappraisal]).to be > initial
+      end
+    end
+
+    context 'history capping' do
+      it 'caps history at MAX_REGULATION_HISTORY' do
+        (c::MAX_REGULATION_HISTORY + 10).times do
+          model.regulate(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :attentional_deployment)
+        end
+        expect(model.regulation_history.size).to eq(c::MAX_REGULATION_HISTORY)
+      end
+    end
+  end
+
+  describe '#recommend_strategy' do
+    it 'returns a recommended strategy' do
+      result = model.recommend_strategy(emotion_magnitude: 0.7, emotion_valence: :negative)
+      expect(c::STRATEGIES).to include(result[:recommended])
+    end
+
+    it 'returns scores for all strategies' do
+      result = model.recommend_strategy(emotion_magnitude: 0.5, emotion_valence: :neutral)
+      expect(result[:scores].keys).to match_array(c::STRATEGIES)
+    end
+
+    it 'returns the context' do
+      result = model.recommend_strategy(emotion_magnitude: 0.5, emotion_valence: :neutral, context: :sustained)
+      expect(result[:context]).to eq(:sustained)
+    end
+
+    it 'penalises situation_selection at high magnitude' do
+      result = model.recommend_strategy(emotion_magnitude: 0.9, emotion_valence: :negative, context: :general)
+      # situation_selection should score lower than cognitive_reappraisal at high magnitude
+      expect(result[:scores][:situation_selection]).to be < result[:scores][:cognitive_reappraisal]
+    end
+
+    it 'penalises suppression in sustained context' do
+      general_result = model.recommend_strategy(emotion_magnitude: 0.5, emotion_valence: :neutral, context: :general)
+      sustained_result = model.recommend_strategy(emotion_magnitude: 0.5, emotion_valence: :neutral, context: :sustained)
+      expect(sustained_result[:scores][:response_suppression]).to be < general_result[:scores][:response_suppression]
+    end
+  end
+
+  describe '#decay' do
+    it 'moves skills above DEFAULT_SKILL toward DEFAULT_SKILL' do
+      model.instance_variable_get(:@skill)[:cognitive_reappraisal] = 0.8
+      model.decay
+      expect(model.skill[:cognitive_reappraisal]).to be < 0.8
+    end
+
+    it 'does not decay skills below 0' do
+      c::STRATEGIES.each do |s|
+        model.instance_variable_get(:@skill)[s] = 0.0
+      end
+      model.decay
+      c::STRATEGIES.each do |s|
+        expect(model.skill[s]).to be >= 0.0
+      end
+    end
+  end
+
+  describe '#skill_for' do
+    it 'returns the skill value for a known strategy' do
+      expect(model.skill_for(:cognitive_reappraisal)).to eq(c::DEFAULT_SKILL)
+    end
+
+    it 'returns DEFAULT_SKILL for an unknown strategy' do
+      expect(model.skill_for(:nonexistent)).to eq(c::DEFAULT_SKILL)
+    end
+  end
+
+  describe '#overall_regulation_ability' do
+    it 'returns a float in [0, 1]' do
+      ability = model.overall_regulation_ability
+      expect(ability).to be_between(0.0, 1.0)
+    end
+
+    it 'starts at DEFAULT_SKILL when all skills are equal' do
+      expect(model.overall_regulation_ability).to be_within(0.001).of(c::DEFAULT_SKILL)
+    end
+  end
+
+  describe '#regulation_label' do
+    it 'returns a symbol from REGULATION_LABELS' do
+      expect(c::REGULATION_LABELS.values).to include(model.regulation_label)
+    end
+
+    it 'returns :novice when ability is around DEFAULT_SKILL (0.3)' do
+      expect(model.regulation_label).to eq(:novice)
+    end
+
+    it 'returns :masterful when all skills are near 1.0' do
+      c::STRATEGIES.each do |s|
+        model.instance_variable_get(:@skill)[s] = 0.95
+      end
+      expect(model.regulation_label).to eq(:masterful)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      hash = model.to_h
+      expect(hash.keys).to include(:skill, :consecutive_suppressions, :overall_ability, :regulation_label, :history_size)
+    end
+
+    it 'returns a duplicate of skill (not same object)' do
+      expect(model.to_h[:skill]).not_to be(model.skill)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/regulation/runners/emotional_regulation_spec.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/regulation/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Regulation::Runners::EmotionalRegulation do
+  let(:client) { Legion::Extensions::Agentic::Affect::Regulation::Client.new }
+
+  describe '#regulate_emotion' do
+    it 'returns success: true' do
+      result = client.regulate_emotion(emotion_magnitude: 0.7, emotion_valence: :negative)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns a regulated_magnitude' do
+      result = client.regulate_emotion(emotion_magnitude: 0.7, emotion_valence: :negative)
+      expect(result[:regulated_magnitude]).to be_a(Float)
+    end
+
+    it 'reduces magnitude when a valid strategy is provided' do
+      result = client.regulate_emotion(emotion_magnitude: 0.8, emotion_valence: :negative,
+                                       strategy: :cognitive_reappraisal)
+      expect(result[:regulated_magnitude]).to be < 0.8
+    end
+
+    it 'auto-selects a strategy when none given' do
+      result = client.regulate_emotion(emotion_magnitude: 0.6, emotion_valence: :neutral)
+      expect(result[:strategy]).not_to be_nil
+    end
+
+    it 'accepts and uses an explicit strategy' do
+      result = client.regulate_emotion(emotion_magnitude: 0.5, emotion_valence: :neutral,
+                                       strategy: :attentional_deployment)
+      expect(result[:strategy]).to eq(:attentional_deployment)
+    end
+
+    it 'returns a cost value' do
+      result = client.regulate_emotion(emotion_magnitude: 0.5, emotion_valence: :neutral,
+                                       strategy: :situation_modification)
+      expect(result[:cost]).to be > 0.0
+    end
+
+    it 'returns success: false for unknown strategy' do
+      result = client.regulate_emotion(emotion_magnitude: 0.5, emotion_valence: :neutral,
+                                       strategy: :nonexistent)
+      expect(result[:success]).to be(false)
+    end
+  end
+
+  describe '#recommend_strategy' do
+    it 'returns success: true' do
+      result = client.recommend_strategy(emotion_magnitude: 0.7, emotion_valence: :negative)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns a recommended strategy symbol' do
+      result = client.recommend_strategy(emotion_magnitude: 0.7, emotion_valence: :negative)
+      expect(Legion::Extensions::Agentic::Affect::Regulation::Helpers::Constants::STRATEGIES).to include(result[:recommended])
+    end
+
+    it 'returns scores for all strategies' do
+      result = client.recommend_strategy(emotion_magnitude: 0.5, emotion_valence: :neutral)
+      expect(result[:scores].keys).to match_array(Legion::Extensions::Agentic::Affect::Regulation::Helpers::Constants::STRATEGIES)
+    end
+
+    it 'accepts a context parameter' do
+      result = client.recommend_strategy(emotion_magnitude: 0.5, emotion_valence: :neutral, context: :sustained)
+      expect(result[:context]).to eq(:sustained)
+    end
+  end
+
+  describe '#update_emotional_regulation' do
+    it 'returns success: true' do
+      result = client.update_emotional_regulation
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns overall_ability' do
+      result = client.update_emotional_regulation
+      expect(result[:overall_ability]).to be_a(Float)
+    end
+
+    it 'returns a regulation_label symbol' do
+      result = client.update_emotional_regulation
+      expect(result[:regulation_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#regulation_profile' do
+    it 'returns success: true' do
+      result = client.regulation_profile
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns skills for all strategies' do
+      result = client.regulation_profile
+      expect(result[:skills].keys).to match_array(Legion::Extensions::Agentic::Affect::Regulation::Helpers::Constants::STRATEGIES)
+    end
+
+    it 'returns overall ability' do
+      result = client.regulation_profile
+      expect(result[:overall]).to be_a(Float)
+    end
+
+    it 'returns a label' do
+      result = client.regulation_profile
+      expect(result[:label]).to be_a(Symbol)
+    end
+
+    it 'returns suppressions count' do
+      result = client.regulation_profile
+      expect(result[:suppressions]).to be_a(Integer)
+    end
+  end
+
+  describe '#regulation_history' do
+    it 'returns success: true' do
+      result = client.regulation_history
+      expect(result[:success]).to be(true)
+    end
+
+    it 'starts with empty events' do
+      result = client.regulation_history
+      expect(result[:events]).to be_empty
+    end
+
+    it 'returns events after regulation' do
+      client.regulate_emotion(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :cognitive_reappraisal)
+      result = client.regulation_history
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'respects the count parameter' do
+      5.times do
+        client.regulate_emotion(emotion_magnitude: 0.5, emotion_valence: :neutral, strategy: :attentional_deployment)
+      end
+      result = client.regulation_history(count: 3)
+      expect(result[:events].size).to be <= 3
+    end
+  end
+
+  describe '#emotional_regulation_stats' do
+    it 'returns success: true' do
+      result = client.emotional_regulation_stats
+      expect(result[:success]).to be(true)
+    end
+
+    context 'with no history' do
+      it 'returns zero total_events' do
+        expect(client.emotional_regulation_stats[:total_events]).to eq(0)
+      end
+
+      it 'returns 0.0 success_rate' do
+        expect(client.emotional_regulation_stats[:success_rate]).to eq(0.0)
+      end
+    end
+
+    context 'with some history' do
+      before do
+        3.times do
+          client.regulate_emotion(emotion_magnitude: 0.6, emotion_valence: :negative,
+                                  strategy: :cognitive_reappraisal)
+        end
+      end
+
+      it 'returns correct total_events' do
+        expect(client.emotional_regulation_stats[:total_events]).to eq(3)
+      end
+
+      it 'returns a success_rate in [0, 1]' do
+        rate = client.emotional_regulation_stats[:success_rate]
+        expect(rate).to be_between(0.0, 1.0)
+      end
+
+      it 'returns average_cost' do
+        expect(client.emotional_regulation_stats[:average_cost]).to be > 0.0
+      end
+
+      it 'returns a strategy_breakdown hash' do
+        breakdown = client.emotional_regulation_stats[:strategy_breakdown]
+        expect(breakdown).to be_a(Hash)
+        expect(breakdown.keys).to match_array(Legion::Extensions::Agentic::Affect::Regulation::Helpers::Constants::STRATEGIES)
+      end
+
+      it 'correctly counts strategy usage in breakdown' do
+        breakdown = client.emotional_regulation_stats[:strategy_breakdown]
+        expect(breakdown[:cognitive_reappraisal][:count]).to eq(3)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Resilience::Client do
+  describe '#initialize' do
+    it 'creates default adversity tracker and model' do
+      client = described_class.new
+      expect(client.adversity_tracker).to be_a(Legion::Extensions::Agentic::Affect::Resilience::Helpers::AdversityTracker)
+      expect(client.resilience_model).to be_a(Legion::Extensions::Agentic::Affect::Resilience::Helpers::ResilienceModel)
+    end
+
+    it 'accepts injected dependencies' do
+      tracker = Legion::Extensions::Agentic::Affect::Resilience::Helpers::AdversityTracker.new
+      model = Legion::Extensions::Agentic::Affect::Resilience::Helpers::ResilienceModel.new
+      client = described_class.new(adversity_tracker: tracker, resilience_model: model)
+      expect(client.adversity_tracker).to be(tracker)
+      expect(client.resilience_model).to be(model)
+    end
+
+    it 'ignores unknown kwargs' do
+      expect { described_class.new(unknown: true) }.not_to raise_error
+    end
+  end
+
+  describe 'runner integration' do
+    let(:client) { described_class.new }
+
+    it { expect(client).to respond_to(:update_resilience) }
+    it { expect(client).to respond_to(:register_adversity) }
+    it { expect(client).to respond_to(:resilience_status) }
+    it { expect(client).to respond_to(:adversity_report) }
+    it { expect(client).to respond_to(:dimension_detail) }
+    it { expect(client).to respond_to(:resilience_stats) }
+  end
+end