lex-agentic-social 0.1.0

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Mirror::Helpers::Simulation do
+  let(:event_id) { 'event-uuid-001' }
+  let(:outcome)  { { action_type: :communication, predicted_intent: :inform_or_persuade } }
+
+  subject(:sim) do
+    described_class.new(
+      event_id:            event_id,
+      simulated_outcome:   outcome,
+      confidence:          0.7,
+      emotional_resonance: 0.6
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(sim.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns event_id' do
+      expect(sim.event_id).to eq(event_id)
+    end
+
+    it 'assigns simulated_outcome' do
+      expect(sim.simulated_outcome).to eq(outcome)
+    end
+
+    it 'clamps confidence to [0, 1]' do
+      s = described_class.new(event_id: 'x', simulated_outcome: {}, confidence: 1.5)
+      expect(s.confidence).to eq(1.0)
+    end
+
+    it 'clamps emotional_resonance to [0, 1]' do
+      s = described_class.new(event_id: 'x', simulated_outcome: {}, emotional_resonance: -0.3)
+      expect(s.emotional_resonance).to eq(0.0)
+    end
+
+    it 'defaults accuracy_score to nil' do
+      expect(sim.accuracy_score).to be_nil
+    end
+
+    it 'assigns simulated_at as a Time' do
+      expect(sim.simulated_at).to be_a(Time)
+    end
+
+    it 'uses SIMULATION_CONFIDENCE_DEFAULT when confidence not given' do
+      s = described_class.new(event_id: 'x', simulated_outcome: {})
+      expect(s.confidence).to eq(
+        Legion::Extensions::Agentic::Social::Mirror::Helpers::Constants::SIMULATION_CONFIDENCE_DEFAULT
+      )
+    end
+
+    it 'uses DEFAULT_RESONANCE when emotional_resonance not given' do
+      s = described_class.new(event_id: 'x', simulated_outcome: {})
+      expect(s.emotional_resonance).to eq(
+        Legion::Extensions::Agentic::Social::Mirror::Helpers::Constants::DEFAULT_RESONANCE
+      )
+    end
+  end
+
+  describe '#accuracy_score=' do
+    it 'allows setting accuracy_score' do
+      sim.accuracy_score = 0.85
+      expect(sim.accuracy_score).to eq(0.85)
+    end
+  end
+
+  describe '#to_h' do
+    subject(:hash) { sim.to_h }
+
+    it 'includes id' do
+      expect(hash[:id]).to eq(sim.id)
+    end
+
+    it 'includes event_id' do
+      expect(hash[:event_id]).to eq(event_id)
+    end
+
+    it 'includes simulated_outcome' do
+      expect(hash[:simulated_outcome]).to eq(outcome)
+    end
+
+    it 'includes confidence' do
+      expect(hash[:confidence]).to eq(0.7)
+    end
+
+    it 'includes emotional_resonance' do
+      expect(hash[:emotional_resonance]).to eq(0.6)
+    end
+
+    it 'includes simulated_at' do
+      expect(hash[:simulated_at]).to be_a(Time)
+    end
+
+    it 'includes accuracy_score as nil initially' do
+      expect(hash[:accuracy_score]).to be_nil
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/mirror/runners/observe_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Mirror::Runners::Observe do
+  let(:engine) { Legion::Extensions::Agentic::Social::Mirror::Helpers::MirrorEngine.new }
+
+  let(:host) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#observe_action' do
+    it 'returns success: true' do
+      result = host.observe_action(agent_id: 'agent-1', action_type: :communication, engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns the observed event hash' do
+      result = host.observe_action(agent_id: 'agent-1', action_type: :decision, engine: engine)
+      expect(result[:event]).to be_a(Hash)
+      expect(result[:event][:action_type]).to eq(:decision)
+    end
+
+    it 'returns a resonance_tier symbol' do
+      result = host.observe_action(agent_id: 'agent-1', action_type: :communication, engine: engine)
+      expect(result[:resonance_tier]).to be_a(Symbol)
+    end
+
+    it 'accepts unknown action_type gracefully' do
+      result = host.observe_action(agent_id: 'agent-1', action_type: :something_weird, engine: engine)
+      expect(result[:success]).to be(true)
+      expect(result[:event][:action_type]).to eq(:unknown)
+    end
+
+    it 'passes emotional_valence to the event' do
+      result = host.observe_action(
+        agent_id: 'agent-1', action_type: :emotional_expression,
+        emotional_valence: 0.8, engine: engine
+      )
+      expect(result[:event][:emotional_valence]).to eq(0.8)
+    end
+
+    it 'passes context to the event' do
+      ctx = { detail: 'test' }
+      result = host.observe_action(
+        agent_id: 'agent-1', action_type: :communication,
+        context: ctx, engine: engine
+      )
+      expect(result[:event][:context]).to eq(ctx)
+    end
+  end
+
+  describe '#list_events' do
+    before do
+      host.observe_action(agent_id: 'agent-1', action_type: :communication, engine: engine)
+      host.observe_action(agent_id: 'agent-2', action_type: :decision, engine: engine)
+    end
+
+    it 'returns all events when no agent_id given' do
+      result = host.list_events(engine: engine)
+      expect(result[:success]).to be(true)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'filters by agent_id' do
+      result = host.list_events(agent_id: 'agent-1', engine: engine)
+      expect(result[:count]).to eq(1)
+      expect(result[:events].first[:agent_id]).to eq('agent-1')
+    end
+
+    it 'returns empty list for unknown agent' do
+      result = host.list_events(agent_id: 'nobody', engine: engine)
+      expect(result[:count]).to eq(0)
+      expect(result[:events]).to be_empty
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/mirror/runners/resonance_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Mirror::Runners::Resonance do
+  let(:engine) { Legion::Extensions::Agentic::Social::Mirror::Helpers::MirrorEngine.new }
+
+  let(:host) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#empathic_resonance' do
+    it 'returns success: true' do
+      result = host.empathic_resonance(agent_id: 'agent-1', engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns resonance value in [0, 1]' do
+      result = host.empathic_resonance(agent_id: 'agent-1', engine: engine)
+      expect(result[:resonance]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns resonance_label and empathy_label symbols' do
+      result = host.empathic_resonance(agent_id: 'agent-1', engine: engine)
+      expect(result[:resonance_label]).to be_a(Symbol)
+      expect(result[:empathy_label]).to be_a(Symbol)
+    end
+
+    it 'returns accuracy as nil for new agent with no simulations' do
+      result = host.empathic_resonance(agent_id: 'brand-new', engine: engine)
+      expect(result[:accuracy]).to be_nil
+    end
+
+    it 'returns event_count and simulation_count' do
+      event = engine.observe(agent_id: 'agent-1', action_type: :communication)
+      engine.simulate(event)
+      result = host.empathic_resonance(agent_id: 'agent-1', engine: engine)
+      expect(result[:event_count]).to eq(1)
+      expect(result[:simulation_count]).to eq(1)
+    end
+
+    it 'returns :moderate label for DEFAULT_RESONANCE' do
+      result = host.empathic_resonance(agent_id: 'new-agent', engine: engine)
+      expect(result[:resonance_label]).to eq(:moderate)
+    end
+  end
+
+  describe '#decay_resonances' do
+    context 'with agent_id specified' do
+      before { engine.boost_resonance('agent-1') }
+
+      it 'returns success: true' do
+        result = host.decay_resonances(agent_id: 'agent-1', engine: engine)
+        expect(result[:success]).to be(true)
+      end
+
+      it 'returns resonance_after' do
+        before = engine.empathic_resonance('agent-1')
+        result = host.decay_resonances(agent_id: 'agent-1', engine: engine)
+        expect(result[:resonance_after]).to be < before
+      end
+
+      it 'returns agent_id in response' do
+        result = host.decay_resonances(agent_id: 'agent-1', engine: engine)
+        expect(result[:agent_id]).to eq('agent-1')
+      end
+    end
+
+    context 'without agent_id (global decay)' do
+      before do
+        engine.boost_resonance('agent-a')
+        engine.boost_resonance('agent-b')
+      end
+
+      it 'returns success: true' do
+        result = host.decay_resonances(engine: engine)
+        expect(result[:success]).to be(true)
+      end
+
+      it 'returns agents_decayed count' do
+        result = host.decay_resonances(engine: engine)
+        expect(result[:agents_decayed]).to eq(2)
+      end
+
+      it 'returns resonances hash' do
+        result = host.decay_resonances(engine: engine)
+        expect(result[:resonances]).to be_a(Hash)
+        expect(result[:resonances].keys).to include('agent-a', 'agent-b')
+      end
+    end
+  end
+
+  describe '#resonance_summary' do
+    before do
+      engine.boost_resonance('agent-x')
+      engine.boost_resonance('agent-y')
+    end
+
+    it 'returns success: true' do
+      result = host.resonance_summary(engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'lists all known agents' do
+      result = host.resonance_summary(engine: engine)
+      expect(result[:total]).to eq(2)
+    end
+
+    it 'includes empathy_label for each agent' do
+      result = host.resonance_summary(engine: engine)
+      result[:agents].each do |entry|
+        expect(entry[:empathy_label]).to be_a(Symbol)
+      end
+    end
+
+    it 'returns empty when no agents' do
+      fresh_engine = Legion::Extensions::Agentic::Social::Mirror::Helpers::MirrorEngine.new
+      result = host.resonance_summary(engine: fresh_engine)
+      expect(result[:total]).to eq(0)
+      expect(result[:agents]).to be_empty
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/mirror/runners/simulate_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::Mirror::Runners::Simulate do
+  let(:engine) { Legion::Extensions::Agentic::Social::Mirror::Helpers::MirrorEngine.new }
+
+  let(:host) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  let(:event) do
+    engine.observe(agent_id: 'agent-1', action_type: :communication, emotional_valence: 0.5)
+  end
+
+  describe '#simulate_action' do
+    it 'returns success: true for known event_id' do
+      result = host.simulate_action(event_id: event.id, engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns simulation hash' do
+      result = host.simulate_action(event_id: event.id, engine: engine)
+      expect(result[:simulation]).to be_a(Hash)
+      expect(result[:simulation][:event_id]).to eq(event.id)
+    end
+
+    it 'returns a confidence_tier symbol' do
+      result = host.simulate_action(event_id: event.id, engine: engine)
+      expect(result[:confidence_tier]).to be_a(Symbol)
+    end
+
+    it 'returns success: false for unknown event_id' do
+      result = host.simulate_action(event_id: 'nonexistent', engine: engine)
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to eq('event not found')
+    end
+
+    it 'respects provided confidence' do
+      result = host.simulate_action(event_id: event.id, confidence: 0.9, engine: engine)
+      expect(result[:simulation][:confidence]).to eq(0.9)
+    end
+
+    it 'boosts agent resonance after simulation' do
+      before = engine.empathic_resonance('agent-1')
+      host.simulate_action(event_id: event.id, engine: engine)
+      expect(engine.empathic_resonance('agent-1')).to be > before
+    end
+  end
+
+  describe '#record_simulation_accuracy' do
+    let(:sim) { engine.simulate(event) }
+
+    it 'returns success: true when simulation found' do
+      result = host.record_simulation_accuracy(simulation_id: sim.id, accuracy: 0.8, engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'records the accuracy value' do
+      host.record_simulation_accuracy(simulation_id: sim.id, accuracy: 0.75, engine: engine)
+      expect(sim.accuracy_score).to eq(0.75)
+    end
+
+    it 'returns success: false for unknown simulation' do
+      result = host.record_simulation_accuracy(simulation_id: 'nope', accuracy: 0.5, engine: engine)
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to eq('simulation not found')
+    end
+
+    it 'clamps accuracy to [0, 1]' do
+      result = host.record_simulation_accuracy(simulation_id: sim.id, accuracy: 1.5, engine: engine)
+      expect(result[:accuracy]).to eq(1.0)
+    end
+  end
+
+  describe '#simulation_history' do
+    before do
+      3.times do
+        e = engine.observe(agent_id: 'agent-1', action_type: :decision)
+        engine.simulate(e)
+      end
+    end
+
+    it 'returns success: true' do
+      expect(host.simulation_history(engine: engine)[:success]).to be(true)
+    end
+
+    it 'returns simulation hashes' do
+      result = host.simulation_history(engine: engine)
+      expect(result[:simulations]).to all(be_a(Hash))
+    end
+
+    it 'respects limit parameter' do
+      result = host.simulation_history(limit: 2, engine: engine)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'returns all when limit exceeds available' do
+      result = host.simulation_history(limit: 100, engine: engine)
+      expect(result[:count]).to eq(3)
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MirrorSystem::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes Runners::Mirror' do
+    expect(described_class.ancestors).to include(Legion::Extensions::Agentic::Social::MirrorSystem::Runners::Mirror)
+  end
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:observe_behavior, :imitate_behavior, :report_imitation_outcome)
+    expect(client).to respond_to(:strongest_mirrors, :observations_for, :observations_in)
+    expect(client).to respond_to(:repertoire_status, :update_mirror, :mirror_stats)
+  end
+
+  it 'supports full mirror lifecycle' do
+    # Observe another agent deploying successfully
+    client.observe_behavior(agent_id: 'expert', action: :canary_deploy, domain: :production, outcome: :success)
+    client.observe_behavior(agent_id: 'expert', action: :canary_deploy, domain: :production, outcome: :success)
+
+    # Imitate the behavior
+    result = client.imitate_behavior(action: :canary_deploy, domain: :production)
+    expect(result[:imitated]).to be true
+    expect(result[:source]).to eq('expert')
+
+    # Report outcome
+    client.report_imitation_outcome(action: :canary_deploy, domain: :production, success_flag: true)
+
+    # Check repertoire
+    rep = client.repertoire_status
+    expect(rep[:size]).to eq(1)
+
+    # Tick
+    client.update_mirror
+
+    # Stats
+    stats = client.mirror_stats
+    expect(stats[:stats][:mirrored_agents]).to eq(1)
+  end
+end

data/spec/legion/extensions/agentic/social/mirror_system/helpers/mirror_system_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::MirrorSystem do
+  subject(:system) { described_class.new }
+
+  describe '#observe' do
+    it 'creates a new observation' do
+      obs = system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      expect(obs).to be_a(Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::ObservedBehavior)
+      expect(system.observation_count).to eq(1)
+    end
+
+    it 'increments count on repeated observation' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      obs = system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      expect(obs.observation_count).to eq(2)
+      expect(system.observation_count).to eq(1)
+    end
+
+    it 'boosts familiarity when behavior is in repertoire' do
+      system.add_to_repertoire(:deploy, :infra)
+      obs = system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      default = Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::DEFAULT_RESONANCE
+      boost = Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::FAMILIARITY_BOOST
+      expect(obs.resonance).to be_within(0.001).of(default + boost)
+    end
+
+    it 'tracks separate observations per agent' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      system.observe(agent_id: 'bob', action: :deploy, domain: :infra)
+      expect(system.observation_count).to eq(2)
+    end
+  end
+
+  describe '#imitate' do
+    it 'returns nil when no observations exist' do
+      expect(system.imitate(action: :deploy, domain: :infra)).to be_nil
+    end
+
+    it 'imitates observed behavior and adds to repertoire' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      result = system.imitate(action: :deploy, domain: :infra)
+      expect(result).not_to be_nil
+      expect(result[:observation].agent_id).to eq('alice')
+      expect(result[:fidelity]).to be_a(Float)
+      expect(system.repertoire_includes?(:deploy, :infra)).to be true
+    end
+
+    it 'filters by source_agent when specified' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      system.observe(agent_id: 'bob', action: :deploy, domain: :infra)
+      result = system.imitate(action: :deploy, domain: :infra, source_agent: 'alice')
+      expect(result[:observation].agent_id).to eq('alice')
+    end
+
+    it 'picks highest resonance observation' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      obs_bob = system.observe(agent_id: 'bob', action: :deploy, domain: :infra)
+      obs_bob.resonance = 0.9
+      result = system.imitate(action: :deploy, domain: :infra)
+      expect(result[:observation].agent_id).to eq('bob')
+    end
+  end
+
+  describe '#update_fidelity' do
+    it 'increases fidelity on success' do
+      before = system.fidelity_for(:deploy, :infra)
+      system.update_fidelity(action: :deploy, domain: :infra, success: true)
+      expect(system.fidelity_for(:deploy, :infra)).to be > before
+    end
+
+    it 'decreases fidelity on failure' do
+      before = system.fidelity_for(:deploy, :infra)
+      system.update_fidelity(action: :deploy, domain: :infra, success: false)
+      expect(system.fidelity_for(:deploy, :infra)).to be < before
+    end
+
+    it 'clamps to 0..1' do
+      20.times { system.update_fidelity(action: :deploy, domain: :infra, success: true) }
+      expect(system.fidelity_for(:deploy, :infra)).to be <= 1.0
+    end
+  end
+
+  describe '#observations_for_agent' do
+    it 'returns observations by specific agent' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      system.observe(agent_id: 'alice', action: :test, domain: :infra)
+      system.observe(agent_id: 'bob', action: :deploy, domain: :infra)
+      expect(system.observations_for_agent('alice').size).to eq(2)
+    end
+  end
+
+  describe '#observations_in_domain' do
+    it 'returns observations in domain' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      system.observe(agent_id: 'alice', action: :test, domain: :code)
+      expect(system.observations_in_domain(:infra).size).to eq(1)
+    end
+  end
+
+  describe '#strongest_mirrors' do
+    it 'returns top N by resonance' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      obs = system.observe(agent_id: 'bob', action: :test, domain: :code)
+      obs.resonance = 0.9
+      top = system.strongest_mirrors(1)
+      expect(top.size).to eq(1)
+      expect(top.first.agent_id).to eq('bob')
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all observations' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      before = system.observations.values.first.resonance
+      system.decay_all
+      after = system.observations.values.first&.resonance
+      expect(after).to be < before if after
+    end
+
+    it 'prunes faded observations' do
+      obs = system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      obs.resonance = Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::RESONANCE_FLOOR + 0.005
+      system.decay_all
+      expect(system.observation_count).to eq(0)
+    end
+  end
+
+  describe '#mirrored_agents' do
+    it 'lists unique observed agents' do
+      system.observe(agent_id: 'alice', action: :deploy, domain: :infra)
+      system.observe(agent_id: 'bob', action: :test, domain: :code)
+      system.observe(agent_id: 'alice', action: :test, domain: :code)
+      expect(system.mirrored_agents).to contain_exactly('alice', 'bob')
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash' do
+      h = system.to_h
+      expect(h).to include(:observations, :repertoire_size, :mirrored_agents, :history_size)
+    end
+  end
+end

data/spec/legion/extensions/agentic/social/mirror_system/helpers/observed_behavior_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::ObservedBehavior do
+  subject(:obs) { described_class.new(agent_id: 'alice', action: :deploy, domain: :infra) }
+
+  describe '#initialize' do
+    it 'assigns fields' do
+      expect(obs.agent_id).to eq('alice')
+      expect(obs.action).to eq(:deploy)
+      expect(obs.domain).to eq(:infra)
+      expect(obs.observation_count).to eq(1)
+    end
+
+    it 'assigns uuid and timestamp' do
+      expect(obs.id).to match(/\A[0-9a-f-]{36}\z/)
+      expect(obs.created_at).to be_a(Time)
+    end
+
+    it 'defaults resonance to DEFAULT_RESONANCE' do
+      expect(obs.resonance).to eq(Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::DEFAULT_RESONANCE)
+    end
+
+    it 'clamps resonance' do
+      high = described_class.new(agent_id: 'a', action: :x, domain: :d, resonance: 5.0)
+      expect(high.resonance).to eq(Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::MAX_RESONANCE)
+    end
+  end
+
+  describe '#observe_again' do
+    it 'increments observation count' do
+      obs.observe_again
+      expect(obs.observation_count).to eq(2)
+    end
+
+    it 'boosts resonance by REPETITION_BOOST' do
+      before = obs.resonance
+      obs.observe_again
+      expect(obs.resonance).to be > before
+    end
+  end
+
+  describe '#boost_familiarity' do
+    it 'boosts resonance by FAMILIARITY_BOOST' do
+      before = obs.resonance
+      obs.boost_familiarity
+      boost = Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::FAMILIARITY_BOOST
+      expect(obs.resonance).to be_within(0.001).of(before + boost)
+    end
+
+    it 'caps at MAX_RESONANCE' do
+      obs.resonance = 0.95
+      obs.boost_familiarity
+      expect(obs.resonance).to eq(Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::MAX_RESONANCE)
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces resonance' do
+      before = obs.resonance
+      obs.decay
+      expect(obs.resonance).to be < before
+    end
+
+    it 'does not drop below RESONANCE_FLOOR' do
+      50.times { obs.decay }
+      expect(obs.resonance).to be >= Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::RESONANCE_FLOOR
+    end
+  end
+
+  describe '#faded?' do
+    it 'returns false for strong observation' do
+      expect(obs.faded?).to be false
+    end
+
+    it 'returns true at floor' do
+      obs.resonance = Legion::Extensions::Agentic::Social::MirrorSystem::Helpers::Constants::RESONANCE_FLOOR
+      expect(obs.faded?).to be true
+    end
+  end
+
+  describe '#label' do
+    it 'returns :faint for default resonance' do
+      expect(obs.label).to eq(:faint)
+    end
+
+    it 'returns :strong_mirror for high resonance' do
+      obs.resonance = 0.9
+      expect(obs.label).to eq(:strong_mirror)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with all fields' do
+      h = obs.to_h
+      expect(h).to include(:id, :agent_id, :action, :domain, :resonance, :observation_count, :label, :created_at)
+    end
+  end
+end