lex-agentic-imagination 0.1.0

data/spec/legion/extensions/agentic/imagination/lucidity/runners/cognitive_lucidity_spec.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::Lucidity::Runners::CognitiveLucidity do
+  let(:engine) { Legion::Extensions::Agentic::Imagination::Lucidity::Helpers::LucidityEngine.new }
+  let(:client) { Legion::Extensions::Agentic::Imagination::Lucidity::Client.new(engine: engine) }
+
+  describe '#begin_dream' do
+    it 'returns success: true' do
+      result = client.begin_dream(theme: :space, content: 'floating among stars', engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a dream_id' do
+      result = client.begin_dream(theme: :space, content: 'floating', engine: engine)
+      expect(result[:dream_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns the theme' do
+      result = client.begin_dream(theme: :jungle, content: 'tall trees', engine: engine)
+      expect(result[:theme]).to eq(:jungle)
+    end
+
+    it 'uses injected engine via keyword arg' do
+      custom_engine = Legion::Extensions::Agentic::Imagination::Lucidity::Helpers::LucidityEngine.new
+      result = client.begin_dream(theme: :test, content: 'x', engine: custom_engine)
+      expect(custom_engine.all_dreams.map(&:id)).to include(result[:dream_id])
+    end
+  end
+
+  describe '#reality_test' do
+    let(:dream_id) do
+      client.begin_dream(theme: :clouds, content: 'drifting', engine: engine)[:dream_id]
+    end
+
+    it 'returns a result hash' do
+      result = client.reality_test(dream_id: dream_id, test_type: :hand_check, engine: engine)
+      expect(result).to be_a(Hash)
+    end
+
+    it 'returns success: false for unknown test type' do
+      result = client.reality_test(dream_id: dream_id, test_type: :bogus, engine: engine)
+      expect(result[:success]).to be false
+    end
+
+    it 'returns success: false for unknown dream' do
+      result = client.reality_test(dream_id: 'no-such-id', test_type: :hand_check, engine: engine)
+      expect(result[:success]).to be false
+    end
+
+    it 'includes lucidity_level in result for valid test' do
+      result = client.reality_test(dream_id: dream_id, test_type: :logic_check, engine: engine)
+      expect(result).to have_key(:lucidity_level)
+    end
+  end
+
+  describe '#steer_dream' do
+    it 'returns success: false when lucidity too low' do
+      dream_id = client.begin_dream(theme: :test, content: 'x', lucidity_level: 0.0, engine: engine)[:dream_id]
+      result = client.steer_dream(dream_id: dream_id, direction: :fly, engine: engine)
+      expect(result[:success]).to be false
+    end
+
+    it 'succeeds when lucidity is sufficient' do
+      dream_id = client.begin_dream(theme: :test, content: 'x', lucidity_level: 0.7, engine: engine)[:dream_id]
+      result = client.steer_dream(dream_id: dream_id, direction: :transform, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns success: false for unknown dream' do
+      result = client.steer_dream(dream_id: 'nope', direction: :fly, engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#end_dream' do
+    let(:dream_id) do
+      client.begin_dream(theme: :ocean, content: 'waves', engine: engine)[:dream_id]
+    end
+
+    it 'returns success: true' do
+      result = client.end_dream(dream_id: dream_id, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'creates a journal entry' do
+      client.end_dream(dream_id: dream_id, engine: engine)
+      expect(engine.journal).not_to be_empty
+    end
+
+    it 'returns success: false for already-ended dream' do
+      client.end_dream(dream_id: dream_id, engine: engine)
+      result = client.end_dream(dream_id: dream_id, engine: engine)
+      expect(result[:success]).to be false
+    end
+
+    it 'accepts insights keyword' do
+      client.end_dream(dream_id: dream_id, insights: ['lucidity felt natural'], engine: engine)
+      expect(engine.journal.last.insights).to include('lucidity felt natural')
+    end
+  end
+
+  describe '#lucidity_status' do
+    it 'returns success: true' do
+      result = client.lucidity_status(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns nil active_dream when none active' do
+      result = client.lucidity_status(engine: engine)
+      expect(result[:active_dream]).to be_nil
+    end
+
+    it 'returns active_dream info when a dream is running' do
+      client.begin_dream(theme: :starfield, content: 'infinite', engine: engine)
+      result = client.lucidity_status(engine: engine)
+      expect(result[:active_dream]).not_to be_nil
+      expect(result[:active_dream]).to have_key(:lucidity_label)
+    end
+
+    it 'includes report with total_dreams' do
+      result = client.lucidity_status(engine: engine)
+      expect(result[:report]).to have_key(:total_dreams)
+    end
+  end
+
+  describe '#journal_entries' do
+    before do
+      dream_id = client.begin_dream(theme: :wind, content: 'rustling', engine: engine)[:dream_id]
+      client.end_dream(dream_id: dream_id, engine: engine)
+    end
+
+    it 'returns success: true' do
+      result = client.journal_entries(engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns a count' do
+      result = client.journal_entries(engine: engine)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns entries array' do
+      result = client.journal_entries(engine: engine)
+      expect(result[:entries]).to be_an(Array)
+    end
+
+    it 'respects limit param' do
+      3.times do
+        id = client.begin_dream(theme: :extra, content: 'x', engine: engine)[:dream_id]
+        client.end_dream(dream_id: id, engine: engine)
+      end
+      result = client.journal_entries(limit: 2, engine: engine)
+      expect(result[:entries].size).to be <= 2
+    end
+  end
+end

data/spec/legion/extensions/agentic/imagination/mental_simulation/helpers/constants_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::MentalSimulation::Helpers::Constants do
+  describe 'SIMULATION_STATES' do
+    it 'is frozen' do
+      expect(described_class::SIMULATION_STATES).to be_frozen
+    end
+
+    it 'contains expected states' do
+      expect(described_class::SIMULATION_STATES).to include(:pending, :running, :completed, :failed, :aborted)
+    end
+  end
+
+  describe 'STEP_OUTCOMES' do
+    it 'is frozen' do
+      expect(described_class::STEP_OUTCOMES).to be_frozen
+    end
+
+    it 'contains expected outcomes' do
+      expect(described_class::STEP_OUTCOMES).to include(:success, :partial_success, :failure, :unknown)
+    end
+  end
+
+  describe 'CONFIDENCE_LABELS' do
+    it 'labels 0.9 as very_confident' do
+      match = described_class::CONFIDENCE_LABELS.find { |r, _| r.cover?(0.9) }&.last
+      expect(match).to eq(:very_confident)
+    end
+
+    it 'labels 0.7 as confident' do
+      match = described_class::CONFIDENCE_LABELS.find { |r, _| r.cover?(0.7) }&.last
+      expect(match).to eq(:confident)
+    end
+
+    it 'labels 0.5 as uncertain' do
+      match = described_class::CONFIDENCE_LABELS.find { |r, _| r.cover?(0.5) }&.last
+      expect(match).to eq(:uncertain)
+    end
+
+    it 'labels 0.3 as doubtful' do
+      match = described_class::CONFIDENCE_LABELS.find { |r, _| r.cover?(0.3) }&.last
+      expect(match).to eq(:doubtful)
+    end
+
+    it 'labels 0.1 as very_doubtful' do
+      match = described_class::CONFIDENCE_LABELS.find { |r, _| r.cover?(0.1) }&.last
+      expect(match).to eq(:very_doubtful)
+    end
+  end
+
+  describe 'RISK_LABELS' do
+    it 'labels 0.9 as critical' do
+      match = described_class::RISK_LABELS.find { |r, _| r.cover?(0.9) }&.last
+      expect(match).to eq(:critical)
+    end
+
+    it 'labels 0.7 as high' do
+      match = described_class::RISK_LABELS.find { |r, _| r.cover?(0.7) }&.last
+      expect(match).to eq(:high)
+    end
+
+    it 'labels 0.5 as moderate' do
+      match = described_class::RISK_LABELS.find { |r, _| r.cover?(0.5) }&.last
+      expect(match).to eq(:moderate)
+    end
+
+    it 'labels 0.3 as low' do
+      match = described_class::RISK_LABELS.find { |r, _| r.cover?(0.3) }&.last
+      expect(match).to eq(:low)
+    end
+
+    it 'labels 0.1 as negligible' do
+      match = described_class::RISK_LABELS.find { |r, _| r.cover?(0.1) }&.last
+      expect(match).to eq(:negligible)
+    end
+  end
+
+  describe 'numeric constants' do
+    it 'MAX_SIMULATIONS is 100' do
+      expect(described_class::MAX_SIMULATIONS).to eq(100)
+    end
+
+    it 'MAX_STEPS_PER_SIM is 50' do
+      expect(described_class::MAX_STEPS_PER_SIM).to eq(50)
+    end
+
+    it 'MAX_HISTORY is 500' do
+      expect(described_class::MAX_HISTORY).to eq(500)
+    end
+
+    it 'DEFAULT_CONFIDENCE is 0.5' do
+      expect(described_class::DEFAULT_CONFIDENCE).to eq(0.5)
+    end
+
+    it 'CONFIDENCE_BOOST is 0.1' do
+      expect(described_class::CONFIDENCE_BOOST).to eq(0.1)
+    end
+
+    it 'CONFIDENCE_PENALTY is 0.15' do
+      expect(described_class::CONFIDENCE_PENALTY).to eq(0.15)
+    end
+
+    it 'RISK_ACCUMULATION_RATE is 0.1' do
+      expect(described_class::RISK_ACCUMULATION_RATE).to eq(0.1)
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::MentalSimulation::Helpers::SimulationEngine do
+  subject(:engine) { described_class.new }
+
+  let(:label)  { 'deploy pipeline' }
+  let(:domain) { :infrastructure }
+
+  def build_favorable_simulation
+    sim = engine.create_simulation(label: label, domain: domain)
+    engine.add_simulation_step(simulation_id: sim.id, action: 'check', confidence: 0.9, risk: 0.05)
+    engine.add_simulation_step(simulation_id: sim.id, action: 'deploy', confidence: 0.85, risk: 0.05)
+    sim
+  end
+
+  def build_risky_simulation
+    sim = engine.create_simulation(label: 'risky plan', domain: :security)
+    engine.add_simulation_step(simulation_id: sim.id, action: 'dangerous op', confidence: 0.9, risk: 0.8)
+    sim
+  end
+
+  describe '#create_simulation' do
+    it 'creates a simulation and returns it' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      expect(sim).to be_a(Legion::Extensions::Agentic::Imagination::MentalSimulation::Helpers::Simulation)
+    end
+
+    it 'stores the simulation internally' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      expect(engine.assess_simulation(simulation_id: sim.id)[:label]).to eq(label)
+    end
+  end
+
+  describe '#add_simulation_step' do
+    it 'returns added: true on success' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      result = engine.add_simulation_step(simulation_id: sim.id, action: 'check prereqs')
+      expect(result[:added]).to be true
+    end
+
+    it 'returns step_id' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      result = engine.add_simulation_step(simulation_id: sim.id, action: 'check')
+      expect(result[:step_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns error for unknown simulation_id' do
+      result = engine.add_simulation_step(simulation_id: 'no-such-id', action: 'go')
+      expect(result[:error]).to eq(:simulation_not_found)
+    end
+
+    it 'returns error when max steps reached' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      Legion::Extensions::Agentic::Imagination::MentalSimulation::Helpers::Constants::MAX_STEPS_PER_SIM.times do |i|
+        engine.add_simulation_step(simulation_id: sim.id, action: "step #{i}")
+      end
+      result = engine.add_simulation_step(simulation_id: sim.id, action: 'one too many')
+      expect(result[:error]).to eq(:max_steps_reached)
+    end
+  end
+
+  describe '#run_simulation' do
+    it 'returns state after running' do
+      sim = build_favorable_simulation
+      result = engine.run_simulation(simulation_id: sim.id)
+      expect(result[:state]).to be_a(Symbol)
+    end
+
+    it 'returns favorable: true for a good plan' do
+      sim = build_favorable_simulation
+      result = engine.run_simulation(simulation_id: sim.id)
+      expect(result[:favorable]).to be true
+    end
+
+    it 'returns error for unknown simulation' do
+      result = engine.run_simulation(simulation_id: 'ghost')
+      expect(result[:error]).to eq(:simulation_not_found)
+    end
+
+    it 'returns overall_confidence in result' do
+      sim = build_favorable_simulation
+      result = engine.run_simulation(simulation_id: sim.id)
+      expect(result[:overall_confidence]).to be > 0
+    end
+
+    it 'returns cumulative_risk in result' do
+      sim = build_favorable_simulation
+      result = engine.run_simulation(simulation_id: sim.id)
+      expect(result[:cumulative_risk]).to be >= 0
+    end
+  end
+
+  describe '#abort_simulation' do
+    it 'aborts a simulation and returns aborted: true' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      result = engine.abort_simulation(simulation_id: sim.id)
+      expect(result[:aborted]).to be true
+      expect(result[:state]).to eq(:aborted)
+    end
+
+    it 'returns error for unknown simulation' do
+      result = engine.abort_simulation(simulation_id: 'ghost')
+      expect(result[:error]).to eq(:simulation_not_found)
+    end
+  end
+
+  describe '#assess_simulation' do
+    it 'returns full assessment without running' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      engine.add_simulation_step(simulation_id: sim.id, action: 'assess me')
+      result = engine.assess_simulation(simulation_id: sim.id)
+      expect(result[:state]).to eq(:pending)
+      expect(result[:steps].size).to eq(1)
+    end
+
+    it 'returns error for unknown simulation' do
+      result = engine.assess_simulation(simulation_id: 'ghost')
+      expect(result[:error]).to eq(:simulation_not_found)
+    end
+
+    it 'includes confidence and risk in assessment' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      engine.add_simulation_step(simulation_id: sim.id, action: 'step', confidence: 0.7, risk: 0.2)
+      result = engine.assess_simulation(simulation_id: sim.id)
+      expect(result[:overall_confidence]).to eq(0.7)
+      expect(result[:cumulative_risk]).to be_within(0.001).of(0.2)
+    end
+  end
+
+  describe '#favorable_simulations' do
+    it 'returns only favorable simulations' do
+      sim = build_favorable_simulation
+      engine.run_simulation(simulation_id: sim.id)
+      favs = engine.favorable_simulations
+      expect(favs).not_to be_empty
+      expect(favs.all?(&:favorable?)).to be true
+    end
+
+    it 'excludes non-favorable simulations' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      engine.add_simulation_step(simulation_id: sim.id, action: 'low conf', confidence: 0.2, risk: 0.1)
+      engine.run_simulation(simulation_id: sim.id)
+      favs = engine.favorable_simulations
+      expect(favs.map(&:id)).not_to include(sim.id)
+    end
+  end
+
+  describe '#failed_simulations' do
+    it 'returns simulations in :failed state' do
+      sim = engine.create_simulation(label: label, domain: domain)
+      engine.add_simulation_step(simulation_id: sim.id, action: 'low conf', confidence: 0.2, risk: 0.1)
+      engine.run_simulation(simulation_id: sim.id)
+      failed = engine.failed_simulations
+      expect(failed.map(&:id)).to include(sim.id)
+    end
+  end
+
+  describe '#simulations_by_domain' do
+    it 'returns simulations for the specified domain' do
+      sim_a = engine.create_simulation(label: 'a', domain: :networking)
+      sim_b = engine.create_simulation(label: 'b', domain: :security)
+      result = engine.simulations_by_domain(domain: :networking)
+      expect(result.map(&:id)).to include(sim_a.id)
+      expect(result.map(&:id)).not_to include(sim_b.id)
+    end
+
+    it 'handles domain as string by converting to symbol' do
+      sim = engine.create_simulation(label: 'str domain', domain: :cloud)
+      result = engine.simulations_by_domain(domain: 'cloud')
+      expect(result.map(&:id)).to include(sim.id)
+    end
+  end
+
+  describe '#riskiest_simulations' do
+    it 'returns simulations sorted by descending cumulative_risk' do
+      low_risk_sim = engine.create_simulation(label: 'safe', domain: :app)
+      engine.add_simulation_step(simulation_id: low_risk_sim.id, action: 'safe', risk: 0.1)
+
+      high_risk_sim = build_risky_simulation
+
+      result = engine.riskiest_simulations(limit: 2)
+      expect(result.first.id).to eq(high_risk_sim.id)
+    end
+
+    it 'respects the limit parameter' do
+      3.times { |i| engine.create_simulation(label: "sim #{i}", domain: :test) }
+      expect(engine.riskiest_simulations(limit: 2).size).to be <= 2
+    end
+  end
+
+  describe '#most_confident' do
+    it 'returns simulations sorted by descending overall_confidence' do
+      low_conf_sim = engine.create_simulation(label: 'uncertain', domain: :app)
+      engine.add_simulation_step(simulation_id: low_conf_sim.id, action: 'maybe', confidence: 0.2)
+
+      high_conf_sim = engine.create_simulation(label: 'sure', domain: :app)
+      engine.add_simulation_step(simulation_id: high_conf_sim.id, action: 'definitely', confidence: 0.95)
+
+      result = engine.most_confident(limit: 2)
+      expect(result.first.id).to eq(high_conf_sim.id)
+    end
+
+    it 'respects the limit parameter' do
+      4.times { |i| engine.create_simulation(label: "sim #{i}", domain: :test) }
+      expect(engine.most_confident(limit: 2).size).to be <= 2
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns engine summary hash' do
+      engine.create_simulation(label: label, domain: domain)
+      h = engine.to_h
+      expect(h).to include(:total_simulations, :history_size, :favorable_count, :failed_count, :simulations)
+      expect(h[:total_simulations]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Imagination::MentalSimulation::Helpers::Simulation do
+  subject(:sim) { described_class.new(label: 'test plan', domain: :infrastructure) }
+
+  describe '#initialize' do
+    it 'generates a UUID id' do
+      expect(sim.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores the label' do
+      expect(sim.label).to eq('test plan')
+    end
+
+    it 'stores the domain as a symbol' do
+      expect(sim.domain).to eq(:infrastructure)
+    end
+
+    it 'starts with no steps' do
+      expect(sim.steps).to be_empty
+    end
+
+    it 'starts in :pending state' do
+      expect(sim.state).to eq(:pending)
+    end
+
+    it 'records created_at' do
+      expect(sim.created_at).to be_a(Time)
+    end
+
+    it 'has nil completed_at initially' do
+      expect(sim.completed_at).to be_nil
+    end
+  end
+
+  describe '#add_step' do
+    it 'adds a SimulationStep and returns it' do
+      step = sim.add_step(action: 'check health')
+      expect(step).to be_a(Legion::Extensions::Agentic::Imagination::MentalSimulation::Helpers::SimulationStep)
+    end
+
+    it 'increments step_count' do
+      sim.add_step(action: 'step one')
+      sim.add_step(action: 'step two')
+      expect(sim.step_count).to eq(2)
+    end
+
+    it 'passes parameters through to the step' do
+      step = sim.add_step(action: 'deploy', predicted_outcome: :failure, confidence: 0.3, risk: 0.8)
+      expect(step.predicted_outcome).to eq(:failure)
+      expect(step.confidence).to eq(0.3)
+      expect(step.risk).to eq(0.8)
+    end
+  end
+
+  describe '#overall_confidence' do
+    it 'returns 0.0 when no steps' do
+      expect(sim.overall_confidence).to eq(0.0)
+    end
+
+    it 'returns product of step confidences' do
+      sim.add_step(action: 'a', confidence: 0.8)
+      sim.add_step(action: 'b', confidence: 0.5)
+      expect(sim.overall_confidence).to be_within(0.001).of(0.4)
+    end
+
+    it 'returns single step confidence when only one step' do
+      sim.add_step(action: 'a', confidence: 0.75)
+      expect(sim.overall_confidence).to eq(0.75)
+    end
+  end
+
+  describe '#cumulative_risk' do
+    it 'returns 0.0 when no steps' do
+      expect(sim.cumulative_risk).to eq(0.0)
+    end
+
+    it 'computes combined risk correctly' do
+      sim.add_step(action: 'a', risk: 0.2)
+      sim.add_step(action: 'b', risk: 0.3)
+      # 1 - (0.8 * 0.7) = 1 - 0.56 = 0.44
+      expect(sim.cumulative_risk).to be_within(0.001).of(0.44)
+    end
+
+    it 'returns high risk when steps have high individual risk' do
+      sim.add_step(action: 'a', risk: 0.9)
+      sim.add_step(action: 'b', risk: 0.9)
+      expect(sim.cumulative_risk).to be > 0.9
+    end
+  end
+
+  describe '#run!' do
+    context 'with favorable steps' do
+      before do
+        sim.add_step(action: 'check prereqs', confidence: 0.9, risk: 0.1)
+        sim.add_step(action: 'deploy', confidence: 0.8, risk: 0.1)
+      end
+
+      it 'sets state to :completed' do
+        sim.run!
+        expect(sim.state).to eq(:completed)
+      end
+
+      it 'sets completed_at' do
+        sim.run!
+        expect(sim.completed_at).to be_a(Time)
+      end
+    end
+
+    context 'when a step predicts failure with high confidence' do
+      before do
+        sim.add_step(action: 'safe step', confidence: 0.9, risk: 0.1)
+        sim.add_step(action: 'dangerous step', predicted_outcome: :failure, confidence: 0.8, risk: 0.5)
+      end
+
+      it 'aborts the simulation' do
+        sim.run!
+        expect(sim.state).to eq(:aborted)
+      end
+    end
+
+    context 'with low overall confidence' do
+      before do
+        sim.add_step(action: 'a', confidence: 0.3, risk: 0.1)
+        sim.add_step(action: 'b', confidence: 0.3, risk: 0.1)
+      end
+
+      it 'sets state to :failed' do
+        sim.run!
+        expect(sim.state).to eq(:failed)
+      end
+    end
+
+    context 'with high cumulative risk' do
+      before do
+        sim.add_step(action: 'a', confidence: 0.9, risk: 0.7)
+        sim.add_step(action: 'b', confidence: 0.9, risk: 0.7)
+      end
+
+      it 'sets state to :failed when cumulative risk >= 0.6' do
+        sim.run!
+        expect(sim.state).to eq(:failed)
+      end
+    end
+
+    it 'sets state to :running briefly and transitions' do
+      sim.add_step(action: 'a', confidence: 0.9, risk: 0.1)
+      sim.run!
+      expect(%i[completed failed aborted]).to include(sim.state)
+    end
+  end
+
+  describe '#abort!' do
+    it 'sets state to :aborted' do
+      sim.abort!
+      expect(sim.state).to eq(:aborted)
+    end
+
+    it 'sets completed_at' do
+      sim.abort!
+      expect(sim.completed_at).to be_a(Time)
+    end
+  end
+
+  describe '#favorable?' do
+    it 'returns false for pending simulation' do
+      sim.add_step(action: 'a', confidence: 0.9, risk: 0.1)
+      expect(sim.favorable?).to be false
+    end
+
+    it 'returns true for completed simulation with good confidence and low risk' do
+      sim.add_step(action: 'a', confidence: 0.9, risk: 0.1)
+      sim.add_step(action: 'b', confidence: 0.9, risk: 0.1)
+      sim.run!
+      expect(sim.favorable?).to be true
+    end
+
+    it 'returns false for aborted simulation' do
+      sim.add_step(action: 'a', predicted_outcome: :failure, confidence: 0.9, risk: 0.5)
+      sim.run!
+      expect(sim.favorable?).to be false
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns :very_confident for high overall confidence' do
+      sim.add_step(action: 'a', confidence: 0.95)
+      expect(sim.confidence_label).to eq(:very_confident)
+    end
+
+    it 'returns :very_doubtful when no steps' do
+      expect(sim.confidence_label).to eq(:very_doubtful)
+    end
+  end
+
+  describe '#risk_label' do
+    it 'returns :negligible for low risk' do
+      sim.add_step(action: 'a', risk: 0.1)
+      expect(sim.risk_label).to eq(:negligible)
+    end
+
+    it 'returns :critical for very high risk' do
+      sim.add_step(action: 'a', risk: 0.95)
+      sim.add_step(action: 'b', risk: 0.95)
+      expect(sim.risk_label).to eq(:critical)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a complete hash' do
+      sim.add_step(action: 'test step')
+      h = sim.to_h
+      expect(h).to include(:id, :label, :domain, :state, :step_count, :overall_confidence,
+                           :cumulative_risk, :confidence_label, :risk_label, :favorable, :steps)
+    end
+
+    it 'includes step hashes' do
+      sim.add_step(action: 'step one')
+      h = sim.to_h
+      expect(h[:steps].first[:action]).to eq('step one')
+    end
+  end
+end