lex-agentic-affect 0.1.0

data/spec/legion/extensions/agentic/affect/defusion/runners/cognitive_defusion_spec.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Defusion::Runners::CognitiveDefusion do
+  let(:engine) { Legion::Extensions::Agentic::Affect::Defusion::Helpers::DefusionEngine.new }
+  let(:client) { Legion::Extensions::Agentic::Affect::Defusion::Client.new(engine: engine) }
+
+  def reg(content: 'I will fail', thought_type: :belief, belief_strength: 0.8)
+    client.register_thought(content: content, thought_type: thought_type, belief_strength: belief_strength, engine: engine)
+  end
+
+  describe '#register_thought' do
+    it 'returns success true for valid input' do
+      result = reg
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the thought_id' do
+      result = reg
+      expect(result[:thought_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns success false for invalid thought_type' do
+      result = client.register_thought(content: 'x', thought_type: :bad, belief_strength: 0.5, engine: engine)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_thought_type)
+    end
+
+    it 'accepts an injected engine' do
+      other_engine = Legion::Extensions::Agentic::Affect::Defusion::Helpers::DefusionEngine.new
+      result = client.register_thought(content: 'test', thought_type: :judgment, belief_strength: 0.5, engine: other_engine)
+      expect(result[:success]).to be true
+      expect(other_engine.thoughts.size).to eq(1)
+    end
+  end
+
+  describe '#apply_defusion' do
+    let(:thought_id) { reg[:thought_id] }
+
+    it 'returns success and fusion reduction' do
+      result = client.apply_defusion(thought_id: thought_id, technique: :acceptance, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:reduction]).to be > 0.0
+    end
+
+    it 'returns success false for invalid thought_id' do
+      result = client.apply_defusion(thought_id: 'nope', technique: :labeling, engine: engine)
+      expect(result[:success]).to be false
+    end
+
+    it 'returns success false for invalid technique' do
+      result = client.apply_defusion(thought_id: thought_id, technique: :made_up, engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#apply_all_techniques' do
+    let(:thought_id) { reg[:thought_id] }
+
+    it 'applies all techniques and returns success' do
+      result = client.apply_all_techniques(thought_id: thought_id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:total_applied]).to eq(Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::DEFUSION_TECHNIQUES.size)
+    end
+
+    it 'returns success false for unknown thought' do
+      result = client.apply_all_techniques(thought_id: 'missing', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#visit_thought' do
+    let(:thought_id) { reg[:thought_id] }
+
+    it 'returns success with visit_count' do
+      result = client.visit_thought(thought_id: thought_id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:visit_count]).to eq(1)
+    end
+
+    it 'returns success false for unknown thought' do
+      result = client.visit_thought(thought_id: 'missing', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#fuse_thought' do
+    let(:thought_id) { reg[:thought_id] }
+
+    it 'increases fusion and returns enmeshed flag' do
+      result = client.fuse_thought(thought_id: thought_id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:after]).to be > result[:before]
+    end
+
+    it 'returns success false for unknown thought' do
+      result = client.fuse_thought(thought_id: 'missing', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#enmeshed_thoughts' do
+    it 'returns count and thoughts array' do
+      reg
+      result = client.enmeshed_thoughts(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:count]).to be >= 1
+      expect(result[:thoughts]).to be_an(Array)
+    end
+  end
+
+  describe '#defused_thoughts' do
+    it 'returns empty when no thoughts are defused' do
+      reg
+      result = client.defused_thoughts(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns thought after being defused' do
+      tid = reg[:thought_id]
+      20.times { client.apply_defusion(thought_id: tid, technique: :acceptance, engine: engine) }
+      result = client.defused_thoughts(engine: engine)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#ruminating_thoughts' do
+    it 'returns empty with no visits' do
+      reg
+      result = client.ruminating_thoughts(engine: engine)
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns thought after enough visits' do
+      tid = reg[:thought_id]
+      Legion::Extensions::Agentic::Affect::Defusion::Helpers::Constants::RUMINATION_COUNT.times do
+        client.visit_thought(thought_id: tid, engine: engine)
+      end
+      result = client.ruminating_thoughts(engine: engine)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#most_fused' do
+    it 'returns success with thoughts array' do
+      reg
+      result = client.most_fused(limit: 3, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:thoughts]).to be_an(Array)
+    end
+  end
+
+  describe '#recommend_technique' do
+    let(:thought_id) { reg[:thought_id] }
+
+    it 'returns success with technique recommendation' do
+      result = client.recommend_technique(thought_id: thought_id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:technique]).to be_a(Symbol)
+    end
+
+    it 'returns success false for unknown thought' do
+      result = client.recommend_technique(thought_id: 'missing', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#defusion_report' do
+    it 'returns success with full report' do
+      reg
+      result = client.defusion_report(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:total_thoughts]).to be >= 1
+    end
+  end
+
+  describe '#defusion_state' do
+    it 'returns full engine state' do
+      reg
+      result = client.defusion_state(engine: engine)
+      expect(result[:success]).to be true
+      expect(result).to have_key(:thoughts)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/emotion/actors/momentum_decay_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Stub the base class before loading the actor
+module Legion
+  module Extensions
+    module Actors
+      class Every; end # rubocop:disable Lint/EmptyClass
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require_relative '../../../../../../../lib/legion/extensions/agentic/affect/emotion/actors/momentum_decay'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Emotion::Actor::MomentumDecay do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it { expect(actor.runner_class).to eq Legion::Extensions::Agentic::Affect::Emotion::Runners::Gut }
+  end
+
+  describe '#runner_function' do
+    it { expect(actor.runner_function).to eq 'decay_momentum' }
+  end
+
+  describe '#time' do
+    it { expect(actor.time).to eq 60 }
+  end
+
+  describe '#run_now?' do
+    it { expect(actor.run_now?).to be false }
+  end
+
+  describe '#use_runner?' do
+    it { expect(actor.use_runner?).to be false }
+  end
+
+  describe '#check_subtask?' do
+    it { expect(actor.check_subtask?).to be false }
+  end
+
+  describe '#generate_task?' do
+    it { expect(actor.generate_task?).to be false }
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/emotion/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Emotion::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to valence runner methods' do
+    expect(client).to respond_to(:evaluate_valence)
+    expect(client).to respond_to(:aggregate_valences)
+    expect(client).to respond_to(:modulate_attention)
+    expect(client).to respond_to(:compute_arousal)
+  end
+
+  it 'responds to gut runner methods' do
+    expect(client).to respond_to(:gut_instinct)
+    expect(client).to respond_to(:emotional_state)
+  end
+
+  it 'tracks domain counts for familiarity' do
+    client.track_domain('work')
+    client.track_domain('work')
+    client.track_domain('personal')
+    # Domain tracking improves familiarity scoring
+    result = client.evaluate_valence(signal: {}, domain: 'work')
+    expect(result[:valence][:familiarity]).to be >= 0.0
+  end
+
+  it 'round-trips a full emotional evaluation cycle' do
+    # Evaluate multiple signals
+    v1 = client.evaluate_valence(signal: { urgency_hint: 0.8 }, source_type: :human_direct)
+    v2 = client.evaluate_valence(signal: { novelty_score: 0.9 }, source_type: :ambient)
+
+    # Aggregate
+    agg = client.aggregate_valences(valences: [v1[:valence], v2[:valence]])
+    expect(agg[:count]).to eq(2)
+
+    # Gut instinct
+    gut = client.gut_instinct(valences: [v1[:valence], v2[:valence]])
+    expect(gut[:signal]).to be_a(Symbol)
+
+    # State persists
+    state = client.emotional_state
+    expect(state[:momentum][:history_size]).to be >= 1
+  end
+end

data/spec/legion/extensions/agentic/affect/emotion/helpers/baseline_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Emotion::Helpers::Baseline do
+  let(:baseline) { described_class.new }
+
+  describe '#initialize' do
+    it 'sets initial values for all dimensions' do
+      Legion::Extensions::Agentic::Affect::Emotion::Helpers::Valence::DIMENSIONS.each do |dim|
+        state = baseline.get(dim)
+        expect(state[:mean]).to eq(0.5)
+        expect(state[:stddev]).to eq(0.25)
+        expect(state[:count]).to eq(0)
+      end
+    end
+  end
+
+  describe '#normalize' do
+    it 'normalizes a raw score against baseline' do
+      result = baseline.normalize(0.5, :urgency)
+      expect(result).to be_between(0.0, 1.0)
+    end
+
+    it 'returns higher value for scores above mean' do
+      low = baseline.normalize(0.3, :urgency)
+      high = baseline.normalize(0.9, :urgency)
+      expect(high).to be > low
+    end
+  end
+
+  describe '#update' do
+    it 'shifts mean toward observed values' do
+      original_mean = baseline.get(:urgency)[:mean]
+      10.times { baseline.update(:urgency, 0.9) }
+      expect(baseline.get(:urgency)[:mean]).to be > original_mean
+    end
+
+    it 'increments count' do
+      3.times { baseline.update(:importance, 0.5) }
+      expect(baseline.get(:importance)[:count]).to eq(3)
+    end
+
+    it 'adapts slowly (alpha=0.05)' do
+      baseline.update(:urgency, 1.0)
+      # After one update, mean should barely move: 0.05*1.0 + 0.95*0.5 = 0.525
+      expect(baseline.get(:urgency)[:mean]).to be_within(0.001).of(0.525)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/emotion/helpers/momentum_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Emotion::Helpers::Momentum do
+  let(:momentum) { described_class.new }
+  let(:valence_mod) { Legion::Extensions::Agentic::Affect::Emotion::Helpers::Valence }
+
+  describe '#initialize' do
+    it 'starts with zero state' do
+      state = momentum.emotional_state
+      expect(state[:arousal_ema]).to eq(0.0)
+      expect(state[:stability]).to eq(1.0)
+      expect(state[:history_size]).to eq(0)
+    end
+  end
+
+  describe '#update' do
+    it 'updates EMA toward current values' do
+      v = valence_mod.new_valence(urgency: 0.8, importance: 0.7)
+      result = momentum.update(v, 0.6)
+      expect(result[:arousal_ema]).to be > 0.0
+      expect(result[:valence_ema][:urgency]).to be > 0.0
+    end
+
+    it 'tracks history' do
+      v = valence_mod.new_valence(urgency: 0.5)
+      3.times { momentum.update(v, 0.5) }
+      expect(momentum.emotional_state[:history_size]).to eq(3)
+    end
+
+    it 'caps history at 100' do
+      v = valence_mod.new_valence
+      105.times { momentum.update(v, 0.1) }
+      expect(momentum.emotional_state[:history_size]).to eq(100)
+    end
+
+    it 'computes stability as inverse of emotional change' do
+      v_calm = valence_mod.new_valence(urgency: 0.1)
+      v_alarm = valence_mod.new_valence(urgency: 1.0, importance: 1.0, novelty: 1.0, familiarity: 1.0)
+
+      momentum.update(v_calm, 0.1)
+      result = momentum.update(v_alarm, 0.9)
+      expect(result[:stability]).to be < 1.0
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/emotion/helpers/valence_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Emotion::Helpers::Valence do
+  describe '.new_valence' do
+    it 'creates a valence with defaults' do
+      v = described_class.new_valence
+      expect(v[:urgency]).to eq(0.0)
+      expect(v[:importance]).to eq(0.0)
+      expect(v[:novelty]).to eq(0.0)
+      expect(v[:familiarity]).to eq(0.0)
+    end
+
+    it 'creates a valence with custom values' do
+      v = described_class.new_valence(urgency: 0.8, importance: 0.6)
+      expect(v[:urgency]).to eq(0.8)
+      expect(v[:importance]).to eq(0.6)
+    end
+
+    it 'clamps values to [0, 1]' do
+      v = described_class.new_valence(urgency: 1.5, novelty: -0.3)
+      expect(v[:urgency]).to eq(1.0)
+      expect(v[:novelty]).to eq(0.0)
+    end
+  end
+
+  describe '.magnitude' do
+    it 'computes zero for zero valence' do
+      v = described_class.new_valence
+      expect(described_class.magnitude(v)).to eq(0.0)
+    end
+
+    it 'computes sqrt(4) for all-ones valence' do
+      v = described_class.new_valence(urgency: 1.0, importance: 1.0, novelty: 1.0, familiarity: 1.0)
+      expect(described_class.magnitude(v)).to be_within(0.001).of(2.0)
+    end
+  end
+
+  describe '.dominant_dimension' do
+    it 'returns the highest dimension' do
+      v = described_class.new_valence(urgency: 0.2, importance: 0.9, novelty: 0.1, familiarity: 0.3)
+      expect(described_class.dominant_dimension(v)).to eq(:importance)
+    end
+  end
+
+  describe '.aggregate' do
+    it 'returns zero valence for empty array' do
+      result = described_class.aggregate([])
+      expect(result[:urgency]).to eq(0.0)
+    end
+
+    it 'averages multiple valences' do
+      v1 = described_class.new_valence(urgency: 0.8, importance: 0.2)
+      v2 = described_class.new_valence(urgency: 0.4, importance: 0.6)
+      result = described_class.aggregate([v1, v2])
+      expect(result[:urgency]).to be_within(0.001).of(0.6)
+      expect(result[:importance]).to be_within(0.001).of(0.4)
+    end
+  end
+
+  describe '.compute_arousal' do
+    it 'returns 0 for empty valences' do
+      expect(described_class.compute_arousal([])).to eq(0.0)
+    end
+
+    it 'returns 1.0 for all-max valences' do
+      v = described_class.new_valence(urgency: 1.0, importance: 1.0, novelty: 1.0, familiarity: 1.0)
+      expect(described_class.compute_arousal([v])).to be_within(0.001).of(1.0)
+    end
+
+    it 'returns moderate arousal for mixed valences' do
+      v = described_class.new_valence(urgency: 0.5, importance: 0.5)
+      arousal = described_class.compute_arousal([v])
+      expect(arousal).to be > 0.0
+      expect(arousal).to be < 1.0
+    end
+  end
+
+  describe '.modulate_salience' do
+    it 'boosts salience based on valence' do
+      v = described_class.new_valence(urgency: 0.8, importance: 0.6, novelty: 0.4)
+      modulated = described_class.modulate_salience(0.5, v)
+      expect(modulated).to be > 0.5
+    end
+
+    it 'clamps at 1.0' do
+      v = described_class.new_valence(urgency: 1.0, importance: 1.0, novelty: 1.0)
+      modulated = described_class.modulate_salience(0.9, v)
+      expect(modulated).to eq(1.0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/emotion/runners/gut_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/emotion/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Emotion::Runners::Gut do
+  let(:client) { Legion::Extensions::Agentic::Affect::Emotion::Client.new }
+  let(:valence_mod) { Legion::Extensions::Agentic::Affect::Emotion::Helpers::Valence }
+
+  describe '#gut_instinct' do
+    it 'returns neutral for empty valences' do
+      result = client.gut_instinct(valences: [])
+      expect(result[:signal]).to eq(:neutral)
+      expect(result[:confidence]).to eq(0.0)
+    end
+
+    it 'returns alarm for high urgency + importance' do
+      v = valence_mod.new_valence(urgency: 0.9, importance: 0.9, novelty: 0.5, familiarity: 0.5)
+      result = client.gut_instinct(valences: [v])
+      expect(result[:signal]).to eq(:alarm)
+    end
+
+    it 'returns explore for high novelty + low familiarity' do
+      v = valence_mod.new_valence(urgency: 0.2, importance: 0.2, novelty: 0.9, familiarity: 0.1)
+      result = client.gut_instinct(valences: [v])
+      expect(result[:signal]).to eq(:explore)
+    end
+
+    it 'returns calm for low arousal' do
+      v = valence_mod.new_valence(urgency: 0.05, importance: 0.05, novelty: 0.05, familiarity: 0.05)
+      result = client.gut_instinct(valences: [v])
+      expect(result[:signal]).to eq(:calm)
+    end
+
+    it 'includes confidence and reliability' do
+      v = valence_mod.new_valence(urgency: 0.5)
+      result = client.gut_instinct(valences: [v], memory_signals: [1, 2, 3])
+      expect(result).to have_key(:confidence)
+      expect(result).to have_key(:reliable)
+    end
+
+    it 'increases confidence with more memory evidence' do
+      v = valence_mod.new_valence(urgency: 0.5)
+      low_evidence = client.gut_instinct(valences: [v], memory_signals: [])
+      high_evidence = client.gut_instinct(valences: [v], memory_signals: Array.new(10, 1))
+      expect(high_evidence[:confidence]).to be >= low_evidence[:confidence]
+    end
+  end
+
+  describe '#emotional_state' do
+    it 'returns momentum and baseline state' do
+      state = client.emotional_state
+      expect(state).to have_key(:momentum)
+      expect(state).to have_key(:baseline)
+    end
+  end
+
+  describe '#decay_momentum' do
+    it 'returns decayed: true' do
+      result = client.decay_momentum
+      expect(result[:decayed]).to be true
+    end
+
+    it 'returns a Float stability value' do
+      result = client.decay_momentum
+      expect(result[:stability]).to be_a(Float)
+    end
+
+    it 'returns stability within [0.0, 1.0]' do
+      result = client.decay_momentum
+      expect(result[:stability]).to be_between(0.0, 1.0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/emotion/runners/valence_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/emotion/client'
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Emotion::Runners::Valence do
+  let(:client) { Legion::Extensions::Agentic::Affect::Emotion::Client.new }
+
+  describe '#evaluate_valence' do
+    it 'returns a valence with 4 dimensions' do
+      result = client.evaluate_valence(signal: { urgency_hint: 0.5 })
+      expect(result[:valence].keys).to contain_exactly(:urgency, :importance, :novelty, :familiarity)
+    end
+
+    it 'returns magnitude' do
+      result = client.evaluate_valence(signal: {})
+      expect(result[:magnitude]).to be >= 0.0
+    end
+
+    it 'returns dominant dimension' do
+      result = client.evaluate_valence(signal: { domain_weight: 0.9, impact_scope: 0.8, outcome_severity: 0.9 })
+      expect(result[:dominant_dimension]).to be_a(Symbol)
+    end
+
+    it 'responds to source type urgency' do
+      ambient = client.evaluate_valence(signal: {}, source_type: :ambient)
+      human = client.evaluate_valence(signal: {}, source_type: :human_direct)
+      expect(human[:valence][:urgency]).to be >= ambient[:valence][:urgency]
+    end
+
+    it 'responds to deadlines' do
+      no_deadline = client.evaluate_valence(signal: {})
+      with_deadline = client.evaluate_valence(signal: {}, deadline: Time.now.utc + 60)
+      expect(with_deadline[:valence][:urgency]).to be >= no_deadline[:valence][:urgency]
+    end
+  end
+
+  describe '#aggregate_valences' do
+    it 'aggregates multiple valences' do
+      v = Legion::Extensions::Agentic::Affect::Emotion::Helpers::Valence
+      valences = [
+        v.new_valence(urgency: 0.8, importance: 0.2),
+        v.new_valence(urgency: 0.4, importance: 0.6)
+      ]
+      result = client.aggregate_valences(valences: valences)
+      expect(result[:aggregate][:urgency]).to be_within(0.01).of(0.6)
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#modulate_attention' do
+    it 'boosts salience' do
+      v = Legion::Extensions::Agentic::Affect::Emotion::Helpers::Valence.new_valence(urgency: 0.8, importance: 0.7)
+      result = client.modulate_attention(base_salience: 0.5, valence: v)
+      expect(result[:modulated]).to be > result[:original]
+      expect(result[:boost]).to be > 0
+    end
+  end
+
+  describe '#compute_arousal' do
+    it 'computes arousal from valences' do
+      v = Legion::Extensions::Agentic::Affect::Emotion::Helpers::Valence
+      valences = [v.new_valence(urgency: 0.9, importance: 0.9)]
+      result = client.compute_arousal(valences: valences)
+      expect(result[:arousal]).to be > 0.0
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Empathy::Client do
+  it 'creates default model store' do
+    client = described_class.new
+    expect(client.model_store).to be_a(Legion::Extensions::Agentic::Affect::Empathy::Helpers::ModelStore)
+  end
+
+  it 'accepts injected model store' do
+    store = Legion::Extensions::Agentic::Affect::Empathy::Helpers::ModelStore.new
+    client = described_class.new(model_store: store)
+    expect(client.model_store).to equal(store)
+  end
+
+  it 'includes Empathy runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:observe_agent, :predict_reaction, :perspective_take,
+                                 :social_landscape, :empathy_stats)
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Empathy::Helpers::Constants do
+  it 'defines 5 mental state dimensions' do
+    expect(described_class::MENTAL_STATE_DIMENSIONS.size).to eq(5)
+  end
+
+  it 'defines cooperation stances' do
+    expect(described_class::COOPERATION_STANCES).to include(:cooperative, :competitive, :neutral, :unknown)
+  end
+
+  it 'defines inferred emotions' do
+    expect(described_class::INFERRED_EMOTIONS).to include(:calm, :stressed, :curious, :unknown)
+  end
+
+  it 'defines prediction thresholds in order' do
+    expect(described_class::PREDICTION_UNCERTAIN).to be < described_class::PREDICTION_CONFIDENT
+  end
+
+  it 'sets MAX_TRACKED_AGENTS to 100' do
+    expect(described_class::MAX_TRACKED_AGENTS).to eq(100)
+  end
+end