lex-agentic-imagination 0.1.0

data/spec/legion/extensions/agentic/imagination/dream/integration_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Dream cycle integration' do
+  let(:memory_store) { Legion::Extensions::Memory::Helpers::Store.new }
+  let(:memory_client) { Legion::Extensions::Memory::Client.new(store: memory_store) }
+  let(:identity_client) { Legion::Extensions::Identity::Client.new }
+  let(:emotion_client) { Legion::Extensions::Emotion::Client.new }
+  let(:tick_client) { Legion::Extensions::Tick::Client.new(mode: :dormant) }
+  let(:dream_client) do
+    Legion::Extensions::Agentic::Imagination::Dream::Client.new(
+      memory: memory_client, identity: identity_client, emotion: emotion_client
+    )
+  end
+  let(:trace_helper) { Legion::Extensions::Memory::Helpers::Trace }
+
+  it 'runs a complete dream cycle with populated memory' do
+    # 1. Seed memory with 10 episodic traces (some unresolved)
+    10.times do |i|
+      t = trace_helper.new_trace(
+        type:                :episodic,
+        content_payload:     { event: "meeting_#{i}" },
+        emotional_intensity: rand,
+        emotional_valence:   rand(-1.0..1.0),
+        domain_tags:         ['work']
+      )
+      t[:unresolved] = true if i < 3
+      memory_store.store(t)
+    end
+
+    # 2. Add contradicting trust traces
+    t_pos = trace_helper.new_trace(type: :trust, content_payload: { assessment: 'reliable' },
+                                   domain_tags: ['partner'], emotional_valence: 0.9, emotional_intensity: 0.8)
+    t_neg = trace_helper.new_trace(type: :trust, content_payload: { assessment: 'unreliable' },
+                                   domain_tags: ['partner'], emotional_valence: -0.8, emotional_intensity: 0.3)
+    t_neg[:last_reinforced] = Time.now.utc - 172_800
+    memory_store.store(t_pos)
+    memory_store.store(t_neg)
+
+    # 3. Link traces for association walking
+    all_ids = memory_store.all_traces.map { |t| t[:trace_id] }
+    all_ids.each_cons(2) do |a, b|
+      ta = memory_store.get(a)
+      tb = memory_store.get(b)
+      ta[:associated_traces] << b
+      tb[:associated_traces] << a
+    end
+
+    # 4. Simulate tick transition to dormant_active
+    tick_state = tick_client.send(:tick_state)
+    allow(tick_state).to receive(:seconds_since_signal).and_return(1801.0)
+    transition = tick_client.evaluate_mode_transition(signals: [])
+    expect(transition[:new_mode]).to eq(:dormant_active)
+
+    # 5. Run dream cycle
+    result = dream_client.execute_dream_cycle
+    expect(result[:status]).to eq(:completed)
+
+    # 6. Verify each phase produced output
+    expect(result[:phases][:memory_audit][:decayed]).to be >= 0
+    expect(result[:phases][:memory_audit][:unresolved_count]).to be >= 3
+    expect(result[:phases][:association_walk]).to have_key(:walk_results)
+    expect(result[:phases][:contradiction_resolution][:detected]).to be >= 1
+    expect(result[:phases][:identity_entropy_check]).to have_key(:entropy)
+    expect(result[:phases][:agenda_formation]).to have_key(:agenda_items)
+    expect(result[:phases][:consolidation_commit][:dream_store_cleared]).to be true
+
+    # 7. Verify unresolved flags cleared after cycle
+    unresolved = memory_store.all_traces.select { |t| t[:unresolved] == true }
+    expect(unresolved).to be_empty
+
+    # 8. Verify dream-tagged semantic traces exist in memory (organic recall mechanism)
+    dream_traces = memory_store.all_traces.select { |t| t[:domain_tags].any? { |d| d.start_with?('dream:') } }
+    # May be 0 if no agenda items formed (depends on phase outputs), but structure should work
+    expect(dream_traces).to all(satisfy { |t| t[:trace_type] == :semantic })
+
+    # 9. Simulate return to dormant after dream completes
+    transition = tick_client.evaluate_mode_transition(signals: [], dream_complete: true)
+    expect(transition[:new_mode]).to eq(:dormant)
+  end
+
+  it 'handles empty memory gracefully' do
+    result = dream_client.execute_dream_cycle
+    expect(result[:status]).to eq(:completed)
+    expect(result[:phases][:memory_audit][:decayed]).to eq(0)
+    expect(result[:phases][:association_walk][:walk_results]).to be_empty
+    expect(result[:phases][:contradiction_resolution][:detected]).to eq(0)
+  end
+
+  it 'handles memory with no unresolved traces' do
+    5.times do |i|
+      memory_store.store(trace_helper.new_trace(type: :episodic, content_payload: { i: i }))
+    end
+    result = dream_client.execute_dream_cycle
+    expect(result[:status]).to eq(:completed)
+    expect(result[:phases][:association_walk][:walk_results]).to be_empty
+    expect(result[:phases][:association_walk][:start_trace]).to be_nil
+  end
+end

data/spec/legion/extensions/agentic/imagination/dream/runners/dream_cycle_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Dream::Runners::DreamCycle do
+  let(:memory_store)    { Legion::Extensions::Memory::Helpers::Store.new }
+  let(:memory_client)   { Legion::Extensions::Memory::Client.new(store: memory_store) }
+  let(:identity_client) { Legion::Extensions::Identity::Client.new }
+  let(:emotion_client)  { Legion::Extensions::Emotion::Client.new }
+  let(:client) do
+    Legion::Extensions::Agentic::Imagination::Dream::Client.new(
+      memory:   memory_client,
+      identity: identity_client,
+      emotion:  emotion_client
+    )
+  end
+  let(:trace_helper) { Legion::Extensions::Memory::Helpers::Trace }
+
+  describe '#execute_dream_cycle' do
+    it 'returns a result hash with all eight phases' do
+      result = client.execute_dream_cycle
+      expect(result[:phases].keys).to contain_exactly(
+        :memory_audit, :association_walk, :contradiction_resolution,
+        :identity_entropy_check, :agenda_formation, :consolidation_commit,
+        :dream_reflection, :dream_narration
+      )
+    end
+
+    it 'returns completed status' do
+      result = client.execute_dream_cycle
+      expect(result[:status]).to eq(:completed)
+    end
+  end
+
+  describe '#phase_memory_audit' do
+    before do
+      3.times { |i| memory_store.store(trace_helper.new_trace(type: :episodic, content_payload: { i: i })) }
+    end
+
+    it 'runs decay and migration' do
+      result = client.phase_memory_audit
+      expect(result).to have_key(:decayed)
+      expect(result).to have_key(:migrated)
+    end
+
+    it 'identifies consolidation candidates' do
+      t = trace_helper.new_trace(type: :episodic, content_payload: {})
+      t[:reinforcement_count] = 10
+      t[:strength] = 0.3
+      memory_store.store(t)
+      client.phase_memory_audit
+      expect(memory_store.get(t[:trace_id])[:consolidation_candidate]).to be true
+    end
+  end
+
+  describe '#phase_association_walk' do
+    it 'returns walk results when unresolved traces exist' do
+      t1 = trace_helper.new_trace(type: :episodic, content_payload: {}, emotional_intensity: 0.8, unresolved: true)
+      t2 = trace_helper.new_trace(type: :semantic, content_payload: {})
+      memory_store.store(t1)
+      memory_store.store(t2)
+      t1[:associated_traces] << t2[:trace_id]
+      t2[:associated_traces] << t1[:trace_id]
+      result = client.phase_association_walk
+      expect(result[:walk_results]).to be_an(Array)
+    end
+
+    it 'returns empty when no unresolved traces' do
+      memory_store.store(trace_helper.new_trace(type: :episodic, content_payload: {}))
+      result = client.phase_association_walk
+      expect(result[:walk_results]).to be_empty
+    end
+  end
+
+  describe '#phase_contradiction_resolution' do
+    it 'detects and resolves contradictions' do
+      t1 = trace_helper.new_trace(type: :trust, content_payload: {},
+                                  domain_tags: ['reliability'], emotional_valence: 0.8, emotional_intensity: 0.9)
+      t2 = trace_helper.new_trace(type: :trust, content_payload: {},
+                                  domain_tags: ['reliability'], emotional_valence: -0.7, emotional_intensity: 0.2)
+      t2[:last_reinforced] = Time.now.utc - 86_400
+      memory_store.store(t1)
+      memory_store.store(t2)
+      result = client.phase_contradiction_resolution
+      expect(result[:detected]).to be >= 1
+    end
+  end
+
+  describe '#phase_identity_entropy_check' do
+    it 'returns entropy assessment' do
+      result = client.phase_identity_entropy_check
+      expect(result).to have_key(:entropy)
+      expect(result).to have_key(:classification)
+    end
+  end
+
+  describe '#phase_agenda_formation' do
+    it 'builds agenda from collected phase data' do
+      t = trace_helper.new_trace(type: :episodic, content_payload: {}, unresolved: true, emotional_intensity: 0.7)
+      memory_store.store(t)
+      client.phase_memory_audit
+      client.phase_association_walk
+      client.phase_contradiction_resolution
+      client.phase_identity_entropy_check
+      result = client.phase_agenda_formation
+      expect(result).to have_key(:agenda_items)
+    end
+  end
+
+  describe '#phase_consolidation_commit' do
+    it 'writes agenda traces to memory and clears dream store' do
+      client.dream_store.add_agenda_item(type: :curious, content: { path: %w[a b] }, weight: 0.8)
+      result = client.phase_consolidation_commit
+      expect(result[:traces_written]).to be >= 0
+      expect(result[:dream_store_cleared]).to be true
+    end
+  end
+end

data/spec/legion/extensions/agentic/imagination/embodied_simulation/client_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::EmbodiedSimulation::Client do
+  subject(:client) { described_class.new }
+
+  it 'creates and evaluates a simulation lifecycle' do
+    result = client.create_simulation(simulation_type: :action_rehearsal, domain: :nav, initial_state: {})
+    expect(result[:success]).to be true
+    sim_id = result[:simulation_id]
+
+    client.add_simulation_step(sim_id: sim_id, action: :move, expected_state: { pos: 1 },
+                               confidence: 0.8, somatic_signal: 0.4)
+    eval_result = client.evaluate_simulation(sim_id: sim_id)
+    expect(eval_result[:recommendation]).to eq(:proceed)
+
+    client.complete_simulation(sim_id: sim_id, valence: :positive)
+    cal = client.calibrate_simulation(sim_id: sim_id, actual_valence: :positive)
+    expect(cal[:calibration]).to be > 0.5
+  end
+
+  it 'runs rehearsal and counterfactual' do
+    rehearsal = client.rehearse_action(
+      domain:          :task,
+      action_sequence: [
+        { action: :step_one, expected_state: { done: true }, confidence: 0.9, somatic_signal: 0.3 }
+      ]
+    )
+    expect(rehearsal[:success]).to be true
+
+    counter = client.run_counterfactual(
+      domain:              :decision,
+      actual_outcome:      :failure,
+      alternative_actions: [{ action: :alt_path, expected_state: { done: true } }]
+    )
+    expect(counter[:success]).to be true
+  end
+
+  it 'accepts injected engine' do
+    engine = Legion::Extensions::Agentic::Imagination::EmbodiedSimulation::Helpers::SimulationEngine.new
+    c = described_class.new(engine: engine)
+    c.create_simulation(simulation_type: :exploratory, domain: :x, initial_state: {})
+    expect(engine.simulations.size).to eq(1)
+  end
+end

data/spec/legion/extensions/agentic/imagination/embodied_simulation/helpers/simulation_engine_spec.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::EmbodiedSimulation::Helpers::SimulationEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_simulation' do
+    it 'creates a simulation' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :nav, initial_state: {})
+      expect(sim).to be_a(Legion::Extensions::Agentic::Imagination::EmbodiedSimulation::Helpers::Simulation)
+      expect(sim.id).to be_a(Symbol)
+    end
+
+    it 'rejects invalid types' do
+      expect(engine.create_simulation(simulation_type: :bogus, domain: :x, initial_state: {})).to be_nil
+    end
+
+    it 'enforces MAX_SIMULATIONS' do
+      30.times { |i| engine.create_simulation(simulation_type: :predictive, domain: :"d_#{i}", initial_state: {}) }
+      expect(engine.create_simulation(simulation_type: :predictive, domain: :overflow, initial_state: {})).to be_nil
+    end
+  end
+
+  describe '#add_step' do
+    it 'adds step to existing simulation' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      step = engine.add_step(sim_id: sim.id, action: :go, expected_state: { pos: 1 })
+      expect(step.action).to eq(:go)
+    end
+
+    it 'returns nil for unknown sim' do
+      expect(engine.add_step(sim_id: :bogus, action: :go, expected_state: {})).to be_nil
+    end
+  end
+
+  describe '#complete_simulation' do
+    it 'completes and records in history' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.complete_simulation(sim_id: sim.id, valence: :positive)
+      expect(engine.history.size).to eq(1)
+      expect(engine.history.first[:valence]).to eq(:positive)
+    end
+
+    it 'returns nil for unknown sim' do
+      expect(engine.complete_simulation(sim_id: :bogus, valence: :positive)).to be_nil
+    end
+  end
+
+  describe '#abort_simulation' do
+    it 'aborts a simulation' do
+      sim = engine.create_simulation(simulation_type: :exploratory, domain: :x, initial_state: {})
+      engine.abort_simulation(sim_id: sim.id)
+      expect(sim.state).to eq(:aborted)
+    end
+  end
+
+  describe '#rehearse' do
+    it 'creates and runs an action rehearsal' do
+      actions = [
+        { action: :step_one, expected_state: { pos: 1 }, confidence: 0.8, somatic_signal: 0.3 },
+        { action: :step_two, expected_state: { pos: 2 }, confidence: 0.6, somatic_signal: -0.1 }
+      ]
+      sim = engine.rehearse(domain: :navigation, action_sequence: actions)
+      expect(sim.simulation_type).to eq(:action_rehearsal)
+      expect(sim.step_count).to eq(2)
+    end
+
+    it 'returns nil when limit reached' do
+      30.times { |i| engine.create_simulation(simulation_type: :predictive, domain: :"d_#{i}", initial_state: {}) }
+      expect(engine.rehearse(domain: :x, action_sequence: [{ action: :a }])).to be_nil
+    end
+  end
+
+  describe '#counterfactual' do
+    it 'creates a counterfactual simulation' do
+      alts = [{ action: :alt_a, expected_state: { result: :better } }]
+      sim = engine.counterfactual(domain: :decision, actual_outcome: :bad, alternative_actions: alts)
+      expect(sim.simulation_type).to eq(:counterfactual)
+      expect(sim.initial_state[:actual_outcome]).to eq(:bad)
+    end
+  end
+
+  describe '#evaluate_simulation' do
+    it 'evaluates a simulation with steps' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.add_step(sim_id: sim.id, action: :go, expected_state: {}, confidence: 0.8, somatic_signal: 0.5)
+      result = engine.evaluate_simulation(sim_id: sim.id)
+      expect(result[:recommendation]).to eq(:proceed)
+    end
+
+    it 'returns :insufficient_data for empty sim' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      result = engine.evaluate_simulation(sim_id: sim.id)
+      expect(result[:recommendation]).to eq(:insufficient_data)
+    end
+
+    it 'returns :abort for very negative somatic' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.add_step(sim_id: sim.id, action: :bad, expected_state: {}, somatic_signal: -0.8)
+      result = engine.evaluate_simulation(sim_id: sim.id)
+      expect(result[:recommendation]).to eq(:abort)
+    end
+
+    it 'returns :proceed_with_caution for mixed signals' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.add_step(sim_id: sim.id, action: :ok, expected_state: {}, somatic_signal: 0.5, confidence: 0.8)
+      engine.add_step(sim_id: sim.id, action: :risky, expected_state: {}, somatic_signal: -0.4, confidence: 0.6)
+      result = engine.evaluate_simulation(sim_id: sim.id)
+      expect(result[:recommendation]).to eq(:proceed_with_caution)
+    end
+
+    it 'returns nil for unknown sim' do
+      expect(engine.evaluate_simulation(sim_id: :bogus)).to be_nil
+    end
+  end
+
+  describe '#compare_simulations' do
+    it 'ranks simulations by combined score' do
+      sim_a = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.add_step(sim_id: sim_a.id, action: :a, expected_state: {}, confidence: 0.9, somatic_signal: 0.8)
+      sim_b = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.add_step(sim_id: sim_b.id, action: :b, expected_state: {}, confidence: 0.3, somatic_signal: -0.2)
+
+      ranked = engine.compare_simulations(sim_a.id, sim_b.id)
+      expect(ranked.first[:id]).to eq(sim_a.id)
+    end
+
+    it 'returns empty for no matches' do
+      expect(engine.compare_simulations(:x, :y)).to eq([])
+    end
+  end
+
+  describe '#simulations_for' do
+    it 'filters by domain' do
+      engine.create_simulation(simulation_type: :predictive, domain: :nav, initial_state: {})
+      engine.create_simulation(simulation_type: :predictive, domain: :social, initial_state: {})
+      expect(engine.simulations_for(domain: :nav).size).to eq(1)
+    end
+  end
+
+  describe '#active_simulations' do
+    it 'returns running simulations' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.add_step(sim_id: sim.id, action: :go, expected_state: {})
+      expect(engine.active_simulations.size).to eq(1)
+    end
+  end
+
+  describe '#completed_simulations' do
+    it 'returns completed simulations' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.complete_simulation(sim_id: sim.id, valence: :positive)
+      expect(engine.completed_simulations.size).to eq(1)
+    end
+  end
+
+  describe '#calibrate' do
+    it 'increases calibration on correct prediction' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.complete_simulation(sim_id: sim.id, valence: :positive)
+      initial = engine.calibration
+      engine.calibrate(sim_id: sim.id, actual_valence: :positive)
+      expect(engine.calibration).to be > initial
+    end
+
+    it 'decreases calibration on incorrect prediction' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      engine.complete_simulation(sim_id: sim.id, valence: :positive)
+      initial = engine.calibration
+      engine.calibrate(sim_id: sim.id, actual_valence: :negative)
+      expect(engine.calibration).to be < initial
+    end
+
+    it 'returns nil for incomplete sim' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {})
+      expect(engine.calibrate(sim_id: sim.id, actual_valence: :positive)).to be_nil
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays fidelity on all simulations' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {}, fidelity: 0.3)
+      original = sim.fidelity
+      engine.decay_all
+      expect(sim.fidelity).to be < original
+    end
+
+    it 'removes faded completed simulations' do
+      sim = engine.create_simulation(simulation_type: :action_rehearsal, domain: :x, initial_state: {}, fidelity: 0.11)
+      engine.complete_simulation(sim_id: sim.id, valence: :neutral)
+      engine.decay_all
+      expect(engine.simulations).to be_empty
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = engine.to_h
+      expect(h).to include(:simulation_count, :active_count, :completed_count, :calibration, :history_size)
+    end
+  end
+end

data/spec/legion/extensions/agentic/imagination/embodied_simulation/helpers/simulation_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::EmbodiedSimulation::Helpers::Simulation do
+  subject(:sim) do
+    described_class.new(
+      id: :sim_one, simulation_type: :action_rehearsal,
+      domain: :navigation, initial_state: { pos: 0 }
+    )
+  end
+
+  describe '#initialize' do
+    it 'sets id and type' do
+      expect(sim.id).to eq(:sim_one)
+      expect(sim.simulation_type).to eq(:action_rehearsal)
+    end
+
+    it 'starts in pending state' do
+      expect(sim.state).to eq(:pending)
+    end
+
+    it 'starts with empty steps' do
+      expect(sim.steps).to be_empty
+    end
+
+    it 'rejects invalid simulation type' do
+      expect do
+        described_class.new(id: :x, simulation_type: :bogus, domain: :d, initial_state: {})
+      end.to raise_error(ArgumentError)
+    end
+
+    it 'clamps fidelity to floor' do
+      s = described_class.new(id: :x, simulation_type: :predictive, domain: :d, initial_state: {}, fidelity: 0.0)
+      expect(s.fidelity).to eq(0.1)
+    end
+  end
+
+  describe '#add_step' do
+    it 'adds a step and transitions to running' do
+      step = sim.add_step(action: :go, expected_state: { pos: 1 })
+      expect(step).to be_a(Legion::Extensions::Agentic::Imagination::EmbodiedSimulation::Helpers::SimulationStep)
+      expect(sim.state).to eq(:running)
+    end
+
+    it 'enforces MAX_STEPS_PER_SIM' do
+      20.times { |i| sim.add_step(action: :"step_#{i}", expected_state: {}) }
+      expect(sim.add_step(action: :overflow, expected_state: {})).to be_nil
+    end
+
+    it 'rejects steps after completion' do
+      sim.complete(valence: :positive)
+      expect(sim.add_step(action: :late, expected_state: {})).to be_nil
+    end
+  end
+
+  describe '#complete' do
+    it 'sets state to completed and records valence' do
+      sim.complete(valence: :positive)
+      expect(sim.completed?).to be true
+      expect(sim.outcome_valence).to eq(:positive)
+    end
+
+    it 'rejects invalid valence' do
+      expect(sim.complete(valence: :bogus)).to be_nil
+    end
+
+    it 'rejects completing an already completed simulation' do
+      sim.complete(valence: :positive)
+      expect(sim.complete(valence: :negative)).to be_nil
+    end
+  end
+
+  describe '#abort_simulation' do
+    it 'sets state to aborted' do
+      sim.abort_simulation
+      expect(sim.state).to eq(:aborted)
+    end
+
+    it 'does not abort completed sim' do
+      sim.complete(valence: :neutral)
+      expect(sim.abort_simulation).to be_nil
+    end
+  end
+
+  describe '#fail_simulation' do
+    it 'sets state to failed' do
+      sim.fail_simulation
+      expect(sim.state).to eq(:failed)
+    end
+  end
+
+  describe '#aggregate_somatic' do
+    it 'returns 0.0 for empty steps' do
+      expect(sim.aggregate_somatic).to eq(0.0)
+    end
+
+    it 'averages somatic signals' do
+      sim.add_step(action: :a, expected_state: {}, somatic_signal: 0.5)
+      sim.add_step(action: :b, expected_state: {}, somatic_signal: -0.5)
+      expect(sim.aggregate_somatic).to eq(0.0)
+    end
+  end
+
+  describe '#aggregate_confidence' do
+    it 'averages step confidences' do
+      sim.add_step(action: :a, expected_state: {}, confidence: 0.8)
+      sim.add_step(action: :b, expected_state: {}, confidence: 0.4)
+      expect(sim.aggregate_confidence).to be_within(0.001).of(0.6)
+    end
+  end
+
+  describe '#negative_signals?' do
+    it 'returns false without negative steps' do
+      sim.add_step(action: :a, expected_state: {}, somatic_signal: 0.5)
+      expect(sim.negative_signals?).to be false
+    end
+
+    it 'returns true with a negative step' do
+      sim.add_step(action: :a, expected_state: {}, somatic_signal: -0.5)
+      expect(sim.negative_signals?).to be true
+    end
+  end
+
+  describe '#successful?' do
+    it 'returns true for completed + positive' do
+      sim.complete(valence: :positive)
+      expect(sim.successful?).to be true
+    end
+
+    it 'returns false for completed + negative' do
+      sim.complete(valence: :negative)
+      expect(sim.successful?).to be false
+    end
+  end
+
+  describe 'type predicates' do
+    it 'rehearsal? for action_rehearsal' do
+      expect(sim.rehearsal?).to be true
+      expect(sim.counterfactual?).to be false
+    end
+
+    it 'counterfactual?' do
+      s = described_class.new(id: :x, simulation_type: :counterfactual, domain: :d, initial_state: {})
+      expect(s.counterfactual?).to be true
+    end
+
+    it 'empathic?' do
+      s = described_class.new(id: :x, simulation_type: :empathic, domain: :d, initial_state: {})
+      expect(s.empathic?).to be true
+    end
+  end
+
+  describe '#fidelity_label' do
+    it 'returns a symbol' do
+      expect(sim.fidelity_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#decay_fidelity' do
+    it 'reduces fidelity' do
+      original = sim.fidelity
+      sim.decay_fidelity
+      expect(sim.fidelity).to be < original
+    end
+
+    it 'does not go below floor' do
+      50.times { sim.decay_fidelity }
+      expect(sim.fidelity).to eq(0.1)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = sim.to_h
+      expect(h).to include(:id, :simulation_type, :domain, :state, :step_count,
+                           :outcome_valence, :fidelity, :fidelity_label)
+    end
+  end
+end