lex-agentic-social 0.1.0

data/spec/legion/extensions/agentic/social/mentalizing/runners/mentalizing_spec.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/mentalizing/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Mentalizing::Runners::Mentalizing do
+  let(:client) { Legion::Extensions::Agentic::Social::Mentalizing::Client.new }
+
+  describe '#attribute_belief' do
+    it 'returns attributed: true with belief hash' do
+      result = client.attribute_belief(agent_id: 'alice', subject: 'rain', content: 'yes', confidence: 0.8)
+      expect(result[:attributed]).to be true
+      expect(result[:belief]).to include(:id, :agent_id, :subject, :content, :confidence, :depth)
+    end
+
+    it 'defaults confidence to DEFAULT_CONFIDENCE when not provided' do
+      result = client.attribute_belief(agent_id: 'alice', subject: 'snow', content: 'maybe')
+      expect(result[:belief][:confidence]).to eq(Legion::Extensions::Agentic::Social::Mentalizing::Helpers::Constants::DEFAULT_CONFIDENCE)
+    end
+
+    it 'caps depth at MAX_RECURSION_DEPTH' do
+      result = client.attribute_belief(agent_id: 'alice', subject: 's', content: 'c', depth: 100)
+      expect(result[:belief][:depth]).to eq(Legion::Extensions::Agentic::Social::Mentalizing::Helpers::Constants::MAX_RECURSION_DEPTH)
+    end
+
+    it 'accepts depth 0 (first-order)' do
+      result = client.attribute_belief(agent_id: 'alice', subject: 'trust', content: 'high', confidence: 0.9, depth: 0)
+      expect(result[:belief][:depth]).to eq(0)
+    end
+
+    it 'stores about_agent_id for second-order beliefs' do
+      result = client.attribute_belief(agent_id: 'alice', subject: 'plan', content: 'I will act', confidence: 0.7,
+                                       depth: 1, about_agent_id: 'bob')
+      expect(result[:belief][:about_agent_id]).to eq('bob')
+    end
+  end
+
+  describe '#project_belief' do
+    it 'returns projected: true with discounted confidence' do
+      result = client.project_belief(subject: 'plan', own_belief: 0.8, other_agent_id: 'bob')
+      expect(result[:projected]).to be true
+      discount = Legion::Extensions::Agentic::Social::Mentalizing::Helpers::Constants::PROJECTION_DISCOUNT
+      expect(result[:belief][:confidence]).to be_within(0.001).of(0.8 * discount)
+    end
+
+    it 'creates depth-1 belief about the other agent' do
+      result = client.project_belief(subject: 'plan', own_belief: 1.0, other_agent_id: 'carol')
+      expect(result[:belief][:depth]).to eq(1)
+      expect(result[:belief][:about_agent_id]).to eq('carol')
+    end
+  end
+
+  describe '#check_alignment' do
+    it 'returns alignment score of 0.0 when no shared beliefs' do
+      result = client.check_alignment(agent_a: 'alice', agent_b: 'bob', subject: 'rain')
+      expect(result[:alignment]).to eq(0.0)
+    end
+
+    it 'returns alignment near 1.0 for identical confidences' do
+      client.attribute_belief(agent_id: 'alice', subject: 'rain', content: 'yes', confidence: 0.7)
+      client.attribute_belief(agent_id: 'bob',   subject: 'rain', content: 'yes', confidence: 0.7)
+      result = client.check_alignment(agent_a: 'alice', agent_b: 'bob', subject: 'rain')
+      expect(result[:alignment]).to be_within(0.001).of(1.0)
+    end
+
+    it 'returns subject in result' do
+      result = client.check_alignment(agent_a: 'alice', agent_b: 'bob', subject: 'rain')
+      expect(result[:subject]).to eq('rain')
+    end
+  end
+
+  describe '#detect_false_belief' do
+    it 'detects false belief when agent belief contradicts reality' do
+      client.attribute_belief(agent_id: 'alice', subject: 'weather', content: 'sunny', confidence: 0.9)
+      result = client.detect_false_belief(agent_id: 'alice', subject: 'weather', reality: 'raining')
+      expect(result[:false_belief]).to be true
+      expect(result[:held_belief]).to eq('sunny')
+    end
+
+    it 'returns false_belief: false when belief matches reality' do
+      client.attribute_belief(agent_id: 'alice', subject: 'weather', content: 'sunny', confidence: 0.9)
+      result = client.detect_false_belief(agent_id: 'alice', subject: 'weather', reality: 'sunny')
+      expect(result[:false_belief]).to be false
+    end
+
+    it 'returns no_beliefs reason when agent unknown' do
+      result = client.detect_false_belief(agent_id: 'nobody', subject: 'weather', reality: 'sunny')
+      expect(result[:reason]).to eq(:no_beliefs)
+    end
+  end
+
+  describe '#beliefs_for_agent' do
+    it 'returns empty beliefs for unknown agent' do
+      result = client.beliefs_for_agent(agent_id: 'nobody')
+      expect(result[:beliefs]).to eq([])
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns beliefs for known agent' do
+      client.attribute_belief(agent_id: 'alice', subject: 'rain', content: 'yes', confidence: 0.8)
+      result = client.beliefs_for_agent(agent_id: 'alice')
+      expect(result[:count]).to eq(1)
+      expect(result[:beliefs].first[:agent_id]).to eq('alice')
+    end
+  end
+
+  describe '#beliefs_about_agent' do
+    it 'returns beliefs where about_agent_id matches' do
+      client.attribute_belief(agent_id: 'alice', subject: 'my_reliability', content: 'high', confidence: 0.8, about_agent_id: 'me')
+      client.attribute_belief(agent_id: 'bob',   subject: 'my_reliability', content: 'low',  confidence: 0.3, about_agent_id: 'me')
+      result = client.beliefs_about_agent(about_agent_id: 'me')
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'returns empty when no beliefs about agent' do
+      result = client.beliefs_about_agent(about_agent_id: 'nobody')
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#recursive_belief_lookup' do
+    it 'returns found: false when no match' do
+      result = client.recursive_belief_lookup(agent_id: 'alice', about_agent_id: 'bob', subject: 'rain')
+      expect(result[:found]).to be false
+    end
+
+    it 'returns found: true with belief when match exists' do
+      client.attribute_belief(agent_id: 'alice', subject: 'rain', content: 'bob thinks rain', confidence: 0.75, about_agent_id: 'bob')
+      result = client.recursive_belief_lookup(agent_id: 'alice', about_agent_id: 'bob', subject: 'rain')
+      expect(result[:found]).to be true
+      expect(result[:belief][:content]).to eq('bob thinks rain')
+    end
+  end
+
+  describe '#update_mentalizing' do
+    it 'returns decayed: true' do
+      result = client.update_mentalizing
+      expect(result[:decayed]).to be true
+    end
+
+    it 'returns agent and belief counts' do
+      client.attribute_belief(agent_id: 'alice', subject: 'rain', content: 'yes', confidence: 0.8)
+      result = client.update_mentalizing
+      expect(result).to have_key(:agents)
+      expect(result).to have_key(:beliefs)
+    end
+  end
+
+  describe '#mentalizing_stats' do
+    it 'returns agents and beliefs counts' do
+      result = client.mentalizing_stats
+      expect(result).to include(:agents, :beliefs)
+    end
+
+    it 'reflects current state' do
+      client.attribute_belief(agent_id: 'alice', subject: 'rain', content: 'yes', confidence: 0.8)
+      client.attribute_belief(agent_id: 'bob',   subject: 'snow', content: 'no',  confidence: 0.5)
+      result = client.mentalizing_stats
+      expect(result[:agents]).to eq(2)
+      expect(result[:beliefs]).to eq(2)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/mirror/client_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/social/mirror/client'
+
+RSpec.describe Legion::Extensions::Agentic::Social::Mirror::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to observe runner methods' do
+    expect(client).to respond_to(:observe_action)
+    expect(client).to respond_to(:list_events)
+  end
+
+  it 'responds to simulate runner methods' do
+    expect(client).to respond_to(:simulate_action)
+    expect(client).to respond_to(:record_simulation_accuracy)
+    expect(client).to respond_to(:simulation_history)
+  end
+
+  it 'responds to resonance runner methods' do
+    expect(client).to respond_to(:empathic_resonance)
+    expect(client).to respond_to(:decay_resonances)
+    expect(client).to respond_to(:resonance_summary)
+  end
+
+  it 'shares a single internal engine across all runners' do
+    client.observe_action(agent_id: 'agent-1', action_type: :communication)
+    result = client.list_events(agent_id: 'agent-1')
+    expect(result[:count]).to eq(1)
+  end
+
+  it 'performs a full observe -> simulate -> resonance cycle' do
+    obs_result = client.observe_action(
+      agent_id:          'agent-1',
+      action_type:       :decision,
+      emotional_valence: 0.6
+    )
+    expect(obs_result[:success]).to be(true)
+
+    event_id = obs_result[:event][:id]
+    sim_result = client.simulate_action(event_id: event_id, confidence: 0.75)
+    expect(sim_result[:success]).to be(true)
+    expect(sim_result[:simulation][:confidence]).to eq(0.75)
+
+    res_result = client.empathic_resonance(agent_id: 'agent-1')
+    expect(res_result[:resonance]).to be > 0.5
+  end
+
+  it 'records accuracy and returns it in subsequent queries' do
+    obs = client.observe_action(agent_id: 'agent-2', action_type: :analytical_task)
+    sim_result = client.simulate_action(event_id: obs[:event][:id])
+    sim_id = sim_result[:simulation][:id]
+
+    client.record_simulation_accuracy(simulation_id: sim_id, accuracy: 0.9)
+
+    res = client.empathic_resonance(agent_id: 'agent-2')
+    expect(res[:accuracy]).to be_within(0.001).of(0.9)
+  end
+
+  it 'global decay lowers resonance for all agents' do
+    client.observe_action(agent_id: 'agent-a', action_type: :movement)
+    client.observe_action(agent_id: 'agent-b', action_type: :social_interaction)
+
+    # Boost by simulating
+    list_a = client.list_events(agent_id: 'agent-a')
+    list_b = client.list_events(agent_id: 'agent-b')
+    client.simulate_action(event_id: list_a[:events].first[:id])
+    client.simulate_action(event_id: list_b[:events].first[:id])
+
+    before_a = client.empathic_resonance(agent_id: 'agent-a')[:resonance]
+    before_b = client.empathic_resonance(agent_id: 'agent-b')[:resonance]
+
+    client.decay_resonances
+
+    after_a = client.empathic_resonance(agent_id: 'agent-a')[:resonance]
+    after_b = client.empathic_resonance(agent_id: 'agent-b')[:resonance]
+
+    expect(after_a).to be < before_a
+    expect(after_b).to be < before_b
+  end
+
+  it 'resonance_summary shows all agents after observations' do
+    client.observe_action(agent_id: 'agent-x', action_type: :creative_act)
+    e = client.list_events(agent_id: 'agent-x')
+    client.simulate_action(event_id: e[:events].first[:id])
+
+    summary = client.resonance_summary
+    expect(summary[:total]).to be >= 1
+    agent_entry = summary[:agents].find { |a| a[:agent_id] == 'agent-x' }
+    expect(agent_entry).not_to be_nil
+    expect(agent_entry[:empathy_label]).to be_a(Symbol)
+  end
+end

data/spec/legion/extensions/agentic/social/mirror/helpers/constants_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Mirror::Helpers::Constants do
+  describe 'MAX_EVENTS' do
+    it 'equals 500' do
+      expect(described_class::MAX_EVENTS).to eq(500)
+    end
+  end
+
+  describe 'MAX_SIMULATIONS' do
+    it 'equals 300' do
+      expect(described_class::MAX_SIMULATIONS).to eq(300)
+    end
+  end
+
+  describe 'DEFAULT_RESONANCE' do
+    it 'equals 0.5' do
+      expect(described_class::DEFAULT_RESONANCE).to eq(0.5)
+    end
+  end
+
+  describe 'RESONANCE_BOOST' do
+    it 'equals 0.1' do
+      expect(described_class::RESONANCE_BOOST).to eq(0.1)
+    end
+  end
+
+  describe 'RESONANCE_DECAY' do
+    it 'equals 0.03' do
+      expect(described_class::RESONANCE_DECAY).to eq(0.03)
+    end
+  end
+
+  describe 'SIMULATION_CONFIDENCE_DEFAULT' do
+    it 'equals 0.5' do
+      expect(described_class::SIMULATION_CONFIDENCE_DEFAULT).to eq(0.5)
+    end
+  end
+
+  describe 'ACTION_TYPES' do
+    it 'contains exactly 8 types' do
+      expect(described_class::ACTION_TYPES.size).to eq(8)
+    end
+
+    it 'includes all expected types' do
+      expected = %i[movement communication decision emotional_expression
+                    creative_act analytical_task social_interaction unknown]
+      expect(described_class::ACTION_TYPES).to match_array(expected)
+    end
+
+    it 'is frozen' do
+      expect(described_class::ACTION_TYPES).to be_frozen
+    end
+  end
+
+  describe 'RESONANCE_LABELS' do
+    it 'maps low values to :minimal' do
+      expect(described_class::RESONANCE_LABELS[(0.0..0.2)]).to eq(:minimal)
+    end
+
+    it 'maps high values to :deep' do
+      expect(described_class::RESONANCE_LABELS[(0.8..1.0)]).to eq(:deep)
+    end
+  end
+
+  describe 'CONFIDENCE_LABELS' do
+    it 'maps low values to :uncertain' do
+      expect(described_class::CONFIDENCE_LABELS[(0.0..0.2)]).to eq(:uncertain)
+    end
+
+    it 'maps high values to :certain' do
+      expect(described_class::CONFIDENCE_LABELS[(0.8..1.0)]).to eq(:certain)
+    end
+  end
+
+  describe 'EMPATHY_LABELS' do
+    it 'maps low values to :detached' do
+      expect(described_class::EMPATHY_LABELS[(0.0..0.2)]).to eq(:detached)
+    end
+
+    it 'maps high values to :immersed' do
+      expect(described_class::EMPATHY_LABELS[(0.8..1.0)]).to eq(:immersed)
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns :minimal for 0.1' do
+      expect(described_class.label_for(described_class::RESONANCE_LABELS, 0.1)).to eq(:minimal)
+    end
+
+    it 'returns :low for 0.3' do
+      expect(described_class.label_for(described_class::RESONANCE_LABELS, 0.3)).to eq(:low)
+    end
+
+    it 'returns :moderate for 0.5' do
+      expect(described_class.label_for(described_class::RESONANCE_LABELS, 0.5)).to eq(:moderate)
+    end
+
+    it 'returns :high for 0.7' do
+      expect(described_class.label_for(described_class::RESONANCE_LABELS, 0.7)).to eq(:high)
+    end
+
+    it 'returns :deep for 0.9' do
+      expect(described_class.label_for(described_class::RESONANCE_LABELS, 0.9)).to eq(:deep)
+    end
+
+    it 'clamps values above 1.0' do
+      expect(described_class.label_for(described_class::RESONANCE_LABELS, 1.5)).to eq(:deep)
+    end
+
+    it 'clamps values below 0.0' do
+      expect(described_class.label_for(described_class::RESONANCE_LABELS, -0.5)).to eq(:minimal)
+    end
+
+    it 'works with CONFIDENCE_LABELS' do
+      expect(described_class.label_for(described_class::CONFIDENCE_LABELS, 0.75)).to eq(:confident)
+    end
+
+    it 'works with EMPATHY_LABELS' do
+      expect(described_class.label_for(described_class::EMPATHY_LABELS, 0.65)).to eq(:resonant)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/mirror/helpers/mirror_engine_spec.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Mirror::Helpers::MirrorEngine do
+  subject(:engine) { described_class.new }
+
+  let(:agent_id) { 'agent-alpha' }
+
+  def observe_event(action_type: :communication, valence: 0.5)
+    engine.observe(agent_id: agent_id, action_type: action_type, emotional_valence: valence)
+  end
+
+  describe '#initialize' do
+    it 'starts with empty events' do
+      expect(engine.events).to be_empty
+    end
+
+    it 'starts with empty simulations' do
+      expect(engine.simulations).to be_empty
+    end
+
+    it 'returns DEFAULT_RESONANCE for unknown agents' do
+      expect(engine.empathic_resonance('unknown-agent')).to eq(
+        Legion::Extensions::Agentic::Social::Mirror::Helpers::Constants::DEFAULT_RESONANCE
+      )
+    end
+  end
+
+  describe '#observe' do
+    it 'creates and stores a MirrorEvent' do
+      event = observe_event
+      expect(engine.events).to include(event)
+    end
+
+    it 'returns a MirrorEvent instance' do
+      expect(observe_event).to be_a(Legion::Extensions::Agentic::Social::Mirror::Helpers::MirrorEvent)
+    end
+
+    it 'caps events at MAX_EVENTS' do
+      max = Legion::Extensions::Agentic::Social::Mirror::Helpers::Constants::MAX_EVENTS
+      (max + 5).times { observe_event }
+      expect(engine.events.size).to eq(max)
+    end
+  end
+
+  describe '#simulate' do
+    let(:event) { observe_event }
+
+    it 'returns a Simulation instance' do
+      sim = engine.simulate(event)
+      expect(sim).to be_a(Legion::Extensions::Agentic::Social::Mirror::Helpers::Simulation)
+    end
+
+    it 'links simulation to the event via event_id' do
+      sim = engine.simulate(event)
+      expect(sim.event_id).to eq(event.id)
+    end
+
+    it 'stores the simulation' do
+      sim = engine.simulate(event)
+      expect(engine.simulations).to include(sim)
+    end
+
+    it 'caps simulations at MAX_SIMULATIONS' do
+      max = Legion::Extensions::Agentic::Social::Mirror::Helpers::Constants::MAX_SIMULATIONS
+      (max + 5).times do
+        e = observe_event
+        engine.simulate(e)
+      end
+      expect(engine.simulations.size).to eq(max)
+    end
+
+    it 'uses provided confidence' do
+      sim = engine.simulate(event, confidence: 0.8)
+      expect(sim.confidence).to eq(0.8)
+    end
+  end
+
+  describe '#record_accuracy' do
+    it 'sets accuracy_score on the simulation' do
+      event = observe_event
+      sim   = engine.simulate(event)
+      engine.record_accuracy(sim.id, 0.9)
+      expect(sim.accuracy_score).to eq(0.9)
+    end
+
+    it 'returns true when simulation found' do
+      event = observe_event
+      sim   = engine.simulate(event)
+      expect(engine.record_accuracy(sim.id, 0.5)).to be(true)
+    end
+
+    it 'returns false when simulation not found' do
+      expect(engine.record_accuracy('nonexistent-id', 0.5)).to be(false)
+    end
+
+    it 'clamps accuracy to [0, 1]' do
+      event = observe_event
+      sim   = engine.simulate(event)
+      engine.record_accuracy(sim.id, 1.5)
+      expect(sim.accuracy_score).to eq(1.0)
+    end
+  end
+
+  describe '#empathic_resonance' do
+    it 'returns DEFAULT_RESONANCE for new agents' do
+      expect(engine.empathic_resonance('new-agent')).to eq(0.5)
+    end
+
+    it 'reflects boosted resonance after boost_resonance' do
+      engine.boost_resonance(agent_id)
+      expect(engine.empathic_resonance(agent_id)).to be > 0.5
+    end
+  end
+
+  describe '#boost_resonance' do
+    it 'increases resonance by RESONANCE_BOOST' do
+      engine.boost_resonance(agent_id)
+      expected = (0.5 + Legion::Extensions::Agentic::Social::Mirror::Helpers::Constants::RESONANCE_BOOST).round(10)
+      expect(engine.empathic_resonance(agent_id)).to be_within(0.0001).of(expected)
+    end
+
+    it 'does not exceed 1.0' do
+      10.times { engine.boost_resonance(agent_id) }
+      expect(engine.empathic_resonance(agent_id)).to be <= 1.0
+    end
+  end
+
+  describe '#decay_resonance' do
+    it 'decreases resonance by RESONANCE_DECAY' do
+      engine.boost_resonance(agent_id)
+      before = engine.empathic_resonance(agent_id)
+      engine.decay_resonance(agent_id)
+      expect(engine.empathic_resonance(agent_id)).to be < before
+    end
+
+    it 'does not go below 0.0' do
+      20.times { engine.decay_resonance(agent_id) }
+      expect(engine.empathic_resonance(agent_id)).to be >= 0.0
+    end
+  end
+
+  describe '#decay_all_resonances' do
+    it 'decays resonance for all tracked agents' do
+      engine.boost_resonance('agent-1')
+      engine.boost_resonance('agent-2')
+      before_first  = engine.empathic_resonance('agent-1')
+      before_second = engine.empathic_resonance('agent-2')
+      engine.decay_all_resonances
+      expect(engine.empathic_resonance('agent-1')).to be < before_first
+      expect(engine.empathic_resonance('agent-2')).to be < before_second
+    end
+  end
+
+  describe '#simulation_accuracy_for' do
+    it 'returns nil when no scored simulations' do
+      observe_event
+      expect(engine.simulation_accuracy_for(agent_id)).to be_nil
+    end
+
+    it 'returns average accuracy when scored' do
+      e1 = observe_event
+      e2 = observe_event
+      s1 = engine.simulate(e1)
+      s2 = engine.simulate(e2)
+      engine.record_accuracy(s1.id, 0.8)
+      engine.record_accuracy(s2.id, 0.6)
+      expect(engine.simulation_accuracy_for(agent_id)).to be_within(0.001).of(0.7)
+    end
+  end
+
+  describe '#events_for' do
+    it 'filters events by agent_id' do
+      observe_event
+      engine.observe(agent_id: 'other-agent', action_type: :movement)
+      expect(engine.events_for(agent_id).size).to eq(1)
+      expect(engine.events_for('other-agent').size).to eq(1)
+    end
+  end
+
+  describe '#simulations_for' do
+    it 'returns only simulations for a given agent' do
+      e = observe_event
+      engine.simulate(e)
+      other = engine.observe(agent_id: 'other', action_type: :movement)
+      engine.simulate(other)
+      expect(engine.simulations_for(agent_id).size).to eq(1)
+    end
+  end
+
+  describe '#simulation_history' do
+    it 'returns last N simulations as hashes' do
+      3.times do
+        e = observe_event
+        engine.simulate(e)
+      end
+      history = engine.simulation_history(limit: 2)
+      expect(history.size).to eq(2)
+      expect(history.first).to be_a(Hash)
+    end
+
+    it 'defaults to 20 entries' do
+      25.times do
+        e = observe_event
+        engine.simulate(e)
+      end
+      expect(engine.simulation_history.size).to eq(20)
+    end
+  end
+
+  describe '#known_agents' do
+    it 'returns agents with resonance entries' do
+      engine.boost_resonance('agent-a')
+      engine.boost_resonance('agent-b')
+      expect(engine.known_agents).to include('agent-a', 'agent-b')
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/mirror/helpers/mirror_event_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Mirror::Helpers::MirrorEvent do
+  let(:agent_id)    { 'agent-001' }
+  let(:action_type) { :communication }
+  let(:context)     { { message: 'hello', intent: 'greet' } }
+  let(:valence)     { 0.7 }
+
+  subject(:event) do
+    described_class.new(
+      agent_id:          agent_id,
+      action_type:       action_type,
+      context:           context,
+      emotional_valence: valence
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(event.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns agent_id' do
+      expect(event.agent_id).to eq('agent-001')
+    end
+
+    it 'normalizes known action_type' do
+      expect(event.action_type).to eq(:communication)
+    end
+
+    it 'normalizes unknown action_type to :unknown' do
+      e = described_class.new(agent_id: 'x', action_type: :nonexistent)
+      expect(e.action_type).to eq(:unknown)
+    end
+
+    it 'assigns string action_type by converting to symbol' do
+      e = described_class.new(agent_id: 'x', action_type: 'decision')
+      expect(e.action_type).to eq(:decision)
+    end
+
+    it 'assigns context hash' do
+      expect(event.context).to eq(context)
+    end
+
+    it 'treats non-hash context as empty hash' do
+      e = described_class.new(agent_id: 'x', action_type: :movement, context: 'not a hash')
+      expect(e.context).to eq({})
+    end
+
+    it 'clamps emotional_valence to [-1, 1]' do
+      e = described_class.new(agent_id: 'x', action_type: :movement, emotional_valence: 1.5)
+      expect(e.emotional_valence).to eq(1.0)
+    end
+
+    it 'clamps negative emotional_valence' do
+      e = described_class.new(agent_id: 'x', action_type: :movement, emotional_valence: -2.0)
+      expect(e.emotional_valence).to eq(-1.0)
+    end
+
+    it 'assigns observed_at as a Time' do
+      expect(event.observed_at).to be_a(Time)
+    end
+
+    it 'defaults context to empty hash' do
+      e = described_class.new(agent_id: 'x', action_type: :unknown)
+      expect(e.context).to eq({})
+    end
+
+    it 'defaults emotional_valence to 0.0' do
+      e = described_class.new(agent_id: 'x', action_type: :unknown)
+      expect(e.emotional_valence).to eq(0.0)
+    end
+  end
+
+  describe '#to_h' do
+    subject(:hash) { event.to_h }
+
+    it 'includes id' do
+      expect(hash[:id]).to eq(event.id)
+    end
+
+    it 'includes agent_id' do
+      expect(hash[:agent_id]).to eq('agent-001')
+    end
+
+    it 'includes action_type' do
+      expect(hash[:action_type]).to eq(:communication)
+    end
+
+    it 'includes context' do
+      expect(hash[:context]).to eq(context)
+    end
+
+    it 'includes emotional_valence' do
+      expect(hash[:emotional_valence]).to eq(0.7)
+    end
+
+    it 'includes observed_at' do
+      expect(hash[:observed_at]).to be_a(Time)
+    end
+  end
+end