lex-agentic-learning 0.1.0

data/spec/legion/extensions/agentic/learning/curiosity/client_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Curiosity::Client do
+  subject(:client) { described_class.new }
+
+  it 'initializes with a default wonder store' do
+    expect(client.wonder_store).to be_a(Legion::Extensions::Agentic::Learning::Curiosity::Helpers::WonderStore)
+  end
+
+  it 'accepts an injected store' do
+    custom_store = Legion::Extensions::Agentic::Learning::Curiosity::Helpers::WonderStore.new
+    client = described_class.new(store: custom_store)
+    expect(client.wonder_store).to be(custom_store)
+  end
+
+  it 'includes the Curiosity runner' do
+    expect(client).to respond_to(:detect_gaps)
+    expect(client).to respond_to(:generate_wonder)
+    expect(client).to respond_to(:explore_wonder)
+    expect(client).to respond_to(:resolve_wonder)
+    expect(client).to respond_to(:curiosity_intensity)
+    expect(client).to respond_to(:top_wonders)
+    expect(client).to respond_to(:form_agenda)
+    expect(client).to respond_to(:wonder_stats)
+    expect(client).to respond_to(:decay_wonders)
+  end
+end

data/spec/legion/extensions/agentic/learning/curiosity/helpers/gap_detector_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Curiosity::Helpers::GapDetector do
+  describe '.detect' do
+    context 'with empty prior results' do
+      it 'returns empty array' do
+        expect(described_class.detect({})).to eq([])
+      end
+    end
+
+    context 'with memory gaps' do
+      it 'detects unknown domain when few traces returned' do
+        prior = {
+          memory_retrieval: { traces: [], domain: :kubernetes }
+        }
+        gaps = described_class.detect(prior)
+        expect(gaps.size).to be >= 1
+        unknown = gaps.find { |g| g[:gap_type] == :unknown }
+        expect(unknown).not_to be_nil
+        expect(unknown[:domain]).to eq(:kubernetes)
+      end
+
+      it 'detects incomplete knowledge with low-strength traces' do
+        prior = {
+          memory_retrieval: {
+            traces: [
+              { trace_id: 'a', strength: 0.1 },
+              { trace_id: 'b', strength: 0.2 },
+              { trace_id: 'c', strength: 0.9 }
+            ],
+            domain: :consul
+          }
+        }
+        gaps = described_class.detect(prior)
+        incomplete = gaps.find { |g| g[:gap_type] == :incomplete }
+        expect(incomplete).not_to be_nil
+        expect(incomplete[:source_trace_ids]).to contain_exactly('a', 'b')
+      end
+    end
+
+    context 'with prediction gaps' do
+      it 'detects low-confidence predictions' do
+        prior = {
+          prediction_engine: { confidence: 0.3, domain: :vault }
+        }
+        gaps = described_class.detect(prior)
+        uncertain = gaps.find { |g| g[:gap_type] == :uncertain }
+        expect(uncertain).not_to be_nil
+        expect(uncertain[:domain]).to eq(:vault)
+      end
+
+      it 'detects failed predictions' do
+        prior = {
+          prediction_engine: { status: :failed, domain: :terraform }
+        }
+        gaps = described_class.detect(prior)
+        uncertain = gaps.find { |g| g[:gap_type] == :uncertain }
+        expect(uncertain).not_to be_nil
+        expect(uncertain[:salience]).to eq(0.8)
+      end
+    end
+
+    context 'with emotional gaps' do
+      it 'detects novel unfamiliar stimuli' do
+        prior = {
+          emotional_evaluation: {
+            valence: { novelty: 0.9, familiarity: 0.1 },
+            domain:  :new_domain
+          }
+        }
+        gaps = described_class.detect(prior)
+        unknown = gaps.find { |g| g[:gap_type] == :unknown }
+        expect(unknown).not_to be_nil
+        expect(unknown[:salience]).to eq(0.9)
+      end
+
+      it 'does not trigger for familiar novel stimuli' do
+        prior = {
+          emotional_evaluation: {
+            valence: { novelty: 0.9, familiarity: 0.8 }
+          }
+        }
+        gaps = described_class.detect(prior)
+        expect(gaps.select { |g| g[:gap_type] == :unknown }).to be_empty
+      end
+    end
+
+    context 'with contradiction gaps' do
+      it 'detects active conflicts' do
+        prior = {
+          contradiction_resolution: {
+            active_conflicts: [
+              { domain: :vault, trace_ids: %w[x y] }
+            ]
+          }
+        }
+        gaps = described_class.detect(prior)
+        contradictory = gaps.find { |g| g[:gap_type] == :contradictory }
+        expect(contradictory).not_to be_nil
+        expect(contradictory[:domain]).to eq(:vault)
+      end
+    end
+
+    context 'with information gain threshold' do
+      it 'filters out low-gain gaps' do
+        prior = {
+          memory_retrieval: { traces: [{ trace_id: 'a', strength: 0.25 }], domain: :general }
+        }
+        gaps = described_class.detect(prior)
+        # The incomplete gap has info gain 0.5 which is above threshold
+        # But there may be low-gain gaps filtered out
+        gaps.each do |g|
+          expect(g[:information_gain]).to be >= Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Constants::INFORMATION_GAIN_THRESHOLD
+        end
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/curiosity/helpers/wonder_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Wonder do
+  describe '.new_wonder' do
+    it 'creates a wonder with required fields' do
+      wonder = described_class.new_wonder(question: 'Why is the sky blue?')
+      expect(wonder[:wonder_id]).to be_a(String)
+      expect(wonder[:question]).to eq('Why is the sky blue?')
+      expect(wonder[:domain]).to eq(:general)
+      expect(wonder[:gap_type]).to eq(:unknown)
+      expect(wonder[:salience]).to eq(0.5)
+      expect(wonder[:information_gain]).to eq(0.5)
+      expect(wonder[:attempts]).to eq(0)
+      expect(wonder[:resolved]).to be false
+      expect(wonder[:created_at]).to be_a(Time)
+    end
+
+    it 'accepts custom fields' do
+      wonder = described_class.new_wonder(
+        question:         'Why do predictions fail here?',
+        domain:           :terraform,
+        gap_type:         :uncertain,
+        salience:         0.9,
+        information_gain: 0.8,
+        source_trace_ids: ['abc-123']
+      )
+      expect(wonder[:domain]).to eq(:terraform)
+      expect(wonder[:gap_type]).to eq(:uncertain)
+      expect(wonder[:salience]).to eq(0.9)
+      expect(wonder[:source_trace_ids]).to eq(['abc-123'])
+    end
+
+    it 'clamps salience to [0.0, 1.0]' do
+      wonder = described_class.new_wonder(question: 'test', salience: 1.5)
+      expect(wonder[:salience]).to eq(1.0)
+    end
+
+    it 'raises on invalid gap_type' do
+      expect { described_class.new_wonder(question: 'test', gap_type: :invalid) }
+        .to raise_error(ArgumentError, /invalid gap_type/)
+    end
+
+    it 'converts domain to symbol' do
+      wonder = described_class.new_wonder(question: 'test', domain: 'vault')
+      expect(wonder[:domain]).to eq(:vault)
+    end
+  end
+
+  describe '.score' do
+    it 'combines salience and information gain' do
+      wonder = described_class.new_wonder(question: 'test', salience: 1.0, information_gain: 1.0)
+      expect(described_class.score(wonder)).to eq(1.0)
+    end
+
+    it 'returns 0.0 for resolved wonders' do
+      wonder = described_class.new_wonder(question: 'test').merge(resolved: true)
+      expect(described_class.score(wonder)).to eq(0.0)
+    end
+
+    it 'applies attempt penalty' do
+      wonder = described_class.new_wonder(question: 'test', salience: 1.0, information_gain: 1.0)
+      score_fresh = described_class.score(wonder)
+      score_tried = described_class.score(wonder.merge(attempts: 3))
+      expect(score_tried).to be < score_fresh
+    end
+
+    it 'caps attempt penalty at 0.5' do
+      wonder = described_class.new_wonder(question: 'test', salience: 1.0, information_gain: 1.0)
+      score = described_class.score(wonder.merge(attempts: 100))
+      expect(score).to eq(0.5)
+    end
+  end
+
+  describe '.stale?' do
+    it 'returns false for recent wonders' do
+      wonder = described_class.new_wonder(question: 'test')
+      expect(described_class.stale?(wonder)).to be false
+    end
+
+    it 'returns true for old wonders' do
+      old_time = Time.now.utc - (Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Constants::WONDER_STALE_THRESHOLD + 1)
+      wonder = described_class.new_wonder(question: 'test').merge(created_at: old_time)
+      expect(described_class.stale?(wonder)).to be true
+    end
+  end
+
+  describe '.explorable?' do
+    it 'returns true for fresh wonders' do
+      wonder = described_class.new_wonder(question: 'test')
+      expect(described_class.explorable?(wonder)).to be true
+    end
+
+    it 'returns false for resolved wonders' do
+      wonder = described_class.new_wonder(question: 'test').merge(resolved: true)
+      expect(described_class.explorable?(wonder)).to be false
+    end
+
+    it 'returns false when max attempts reached' do
+      wonder = described_class.new_wonder(question: 'test')
+                              .merge(attempts: Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Constants::MAX_EXPLORATION_ATTEMPTS)
+      expect(described_class.explorable?(wonder)).to be false
+    end
+
+    it 'respects exploration cooldown' do
+      wonder = described_class.new_wonder(question: 'test')
+                              .merge(attempts: 1, last_explored_at: Time.now.utc)
+      expect(described_class.explorable?(wonder)).to be false
+    end
+  end
+
+  describe '.decay_salience' do
+    it 'reduces salience over time' do
+      wonder = described_class.new_wonder(question: 'test', salience: 1.0)
+      decayed = described_class.decay_salience(wonder, hours_elapsed: 5.0)
+      expect(decayed[:salience]).to be < 1.0
+    end
+
+    it 'does not go below 0.0' do
+      wonder = described_class.new_wonder(question: 'test', salience: 0.01)
+      decayed = described_class.decay_salience(wonder, hours_elapsed: 100.0)
+      expect(decayed[:salience]).to eq(0.0)
+    end
+
+    it 'skips resolved wonders' do
+      wonder = described_class.new_wonder(question: 'test', salience: 1.0).merge(resolved: true)
+      decayed = described_class.decay_salience(wonder, hours_elapsed: 100.0)
+      expect(decayed[:salience]).to eq(1.0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/curiosity/helpers/wonder_store_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Curiosity::Helpers::WonderStore do
+  subject(:store) { described_class.new }
+
+  let(:wonder) do
+    Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Wonder.new_wonder(
+      question: 'Why does this fail?',
+      domain:   :terraform,
+      gap_type: :uncertain,
+      salience: 0.8
+    )
+  end
+
+  describe '#store' do
+    it 'stores and retrieves a wonder' do
+      store.store(wonder)
+      expect(store.get(wonder[:wonder_id])).to eq(wonder)
+    end
+
+    it 'increments total_generated' do
+      store.store(wonder)
+      expect(store.total_generated).to eq(1)
+    end
+
+    it 'prunes lowest-scored wonder when full' do
+      low_wonder = Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Wonder.new_wonder(
+        question: 'low priority', salience: 0.01, information_gain: 0.01
+      )
+      store.store(low_wonder)
+
+      Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Constants::MAX_WONDERS.times do |i|
+        w = Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Wonder.new_wonder(
+          question: "wonder #{i}", salience: 0.9
+        )
+        store.store(w)
+      end
+
+      expect(store.get(low_wonder[:wonder_id])).to be_nil
+    end
+  end
+
+  describe '#active_wonders and #resolved_wonders' do
+    it 'separates active from resolved' do
+      store.store(wonder)
+      expect(store.active_wonders.size).to eq(1)
+      expect(store.resolved_wonders.size).to eq(0)
+
+      store.mark_resolved(wonder[:wonder_id], resolution: 'found the answer')
+      expect(store.active_wonders.size).to eq(0)
+      expect(store.resolved_wonders.size).to eq(1)
+    end
+  end
+
+  describe '#top_balanced' do
+    it 'returns wonders sorted by score with domain balancing' do
+      3.times do |i|
+        w = Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Wonder.new_wonder(
+          question: "terraform #{i}", domain: :terraform, salience: 0.8
+        )
+        store.store(w)
+      end
+
+      other = Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Wonder.new_wonder(
+        question: 'vault question', domain: :vault, salience: 0.7
+      )
+      store.store(other)
+
+      top = store.top_balanced(limit: 2)
+      domains = top.map { |w| w[:domain] }
+      expect(domains).to include(:vault)
+    end
+  end
+
+  describe '#mark_resolved' do
+    it 'marks wonder as resolved with resolution text' do
+      store.store(wonder)
+      resolved = store.mark_resolved(wonder[:wonder_id], resolution: 'TTL was 30 minutes', actual_gain: 0.8)
+      expect(resolved[:resolved]).to be true
+      expect(resolved[:resolution]).to eq('TTL was 30 minutes')
+      expect(store.resolved_count).to eq(1)
+    end
+
+    it 'returns nil for unknown wonder' do
+      expect(store.mark_resolved('nonexistent', resolution: 'nope')).to be_nil
+    end
+  end
+
+  describe '#decay_all' do
+    it 'reduces salience and prunes exhausted wonders' do
+      low = Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Wonder.new_wonder(
+        question: 'fading', salience: 0.01
+      )
+      store.store(low)
+      pruned = store.decay_all(hours_elapsed: 10.0)
+      expect(pruned).to eq(1)
+      expect(store.get(low[:wonder_id])).to be_nil
+    end
+
+    it 'preserves resolved wonders' do
+      store.store(wonder)
+      store.mark_resolved(wonder[:wonder_id], resolution: 'done')
+      store.decay_all(hours_elapsed: 1000.0)
+      expect(store.get(wonder[:wonder_id])).not_to be_nil
+    end
+  end
+
+  describe '#domain_stats' do
+    it 'reports per-domain counts' do
+      store.store(wonder)
+      w2 = Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Wonder.new_wonder(
+        question: 'another', domain: :terraform
+      )
+      store.store(w2)
+      store.mark_resolved(w2[:wonder_id], resolution: 'resolved')
+
+      stats = store.domain_stats
+      expect(stats[:terraform][:active]).to eq(1)
+      expect(stats[:terraform][:resolved]).to eq(1)
+    end
+  end
+
+  describe '#resolution_rate' do
+    it 'returns 0.0 when no wonders generated' do
+      expect(store.resolution_rate).to eq(0.0)
+    end
+
+    it 'computes fraction of resolved wonders' do
+      store.store(wonder)
+      w2 = Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Wonder.new_wonder(question: 'other')
+      store.store(w2)
+      store.mark_resolved(wonder[:wonder_id], resolution: 'done')
+      expect(store.resolution_rate).to eq(0.5)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/curiosity/runners/curiosity_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Curiosity::Runners::Curiosity do
+  let(:client) { Legion::Extensions::Agentic::Learning::Curiosity::Client.new }
+
+  describe '#detect_gaps' do
+    it 'returns gap detection results' do
+      result = client.detect_gaps(prior_results: {})
+      expect(result[:gaps_detected]).to eq(0)
+      expect(result[:wonders_created]).to eq(0)
+      expect(result[:curiosity_intensity]).to eq(0.0)
+    end
+
+    it 'creates wonders from detected gaps' do
+      prior = {
+        memory_retrieval:  { traces: [], domain: :unknown_domain },
+        prediction_engine: { confidence: 0.2, domain: :uncertain_domain }
+      }
+      result = client.detect_gaps(prior_results: prior)
+      expect(result[:gaps_detected]).to be >= 2
+      expect(result[:wonders_created]).to be >= 1
+      expect(result[:curiosity_intensity]).to be > 0.0
+    end
+
+    it 'does not create duplicate wonders' do
+      prior = {
+        memory_retrieval: { traces: [], domain: :repeated }
+      }
+      client.detect_gaps(prior_results: prior)
+      result = client.detect_gaps(prior_results: prior)
+      expect(result[:wonders_created]).to eq(0)
+    end
+  end
+
+  describe '#generate_wonder' do
+    it 'manually creates a wonder' do
+      wonder = client.generate_wonder(
+        question: 'How does Consul ACL work?',
+        domain:   :consul,
+        gap_type: :unknown
+      )
+      expect(wonder[:wonder_id]).to be_a(String)
+      expect(wonder[:question]).to eq('How does Consul ACL work?')
+      expect(wonder[:domain]).to eq(:consul)
+    end
+  end
+
+  describe '#explore_wonder' do
+    let(:wonder) do
+      client.generate_wonder(question: 'test?', domain: :test)
+    end
+
+    it 'marks a wonder as being explored' do
+      result = client.explore_wonder(wonder_id: wonder[:wonder_id])
+      expect(result[:exploring]).to be true
+      expect(result[:attempt]).to eq(1)
+    end
+
+    it 'returns error for unknown wonder' do
+      result = client.explore_wonder(wonder_id: 'nonexistent')
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'returns error for resolved wonder' do
+      client.resolve_wonder(wonder_id: wonder[:wonder_id], resolution: 'done')
+      result = client.explore_wonder(wonder_id: wonder[:wonder_id])
+      expect(result[:error]).to eq(:already_resolved)
+    end
+  end
+
+  describe '#resolve_wonder' do
+    let(:wonder) do
+      client.generate_wonder(question: 'test?', domain: :test, information_gain: 0.7)
+    end
+
+    it 'resolves with reward calculation' do
+      result = client.resolve_wonder(
+        wonder_id:   wonder[:wonder_id],
+        resolution:  'Found the answer in the docs',
+        actual_gain: 0.8
+      )
+      expect(result[:resolved]).to be true
+      expect(result[:actual_gain]).to eq(0.8)
+      expect(result[:expected_gain]).to eq(0.7)
+      expect(result[:reward]).to eq(0.8 * Legion::Extensions::Agentic::Learning::Curiosity::Helpers::Constants::CURIOSITY_REWARD_MULTIPLIER)
+    end
+
+    it 'returns error for unknown wonder' do
+      result = client.resolve_wonder(wonder_id: 'nope', resolution: 'x')
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'returns error for already resolved wonder' do
+      client.resolve_wonder(wonder_id: wonder[:wonder_id], resolution: 'first')
+      result = client.resolve_wonder(wonder_id: wonder[:wonder_id], resolution: 'second')
+      expect(result[:error]).to eq(:already_resolved)
+    end
+  end
+
+  describe '#curiosity_intensity' do
+    it 'returns 0.0 with no wonders' do
+      result = client.curiosity_intensity
+      expect(result[:intensity]).to eq(0.0)
+    end
+
+    it 'increases with more wonders' do
+      5.times { |i| client.generate_wonder(question: "q#{i}?", domain: :test) }
+      result = client.curiosity_intensity
+      expect(result[:intensity]).to be > 0.0
+      expect(result[:active_wonders]).to eq(5)
+    end
+  end
+
+  describe '#top_wonders' do
+    it 'returns top wonders by balanced score' do
+      client.generate_wonder(question: 'high?', domain: :a, salience: 0.9)
+      client.generate_wonder(question: 'low?', domain: :b, salience: 0.2)
+      result = client.top_wonders(limit: 5)
+      expect(result[:wonders].first[:question]).to eq('high?')
+    end
+  end
+
+  describe '#form_agenda' do
+    it 'converts top wonders to agenda items' do
+      client.generate_wonder(question: 'Why?', domain: :test)
+      result = client.form_agenda
+      expect(result[:agenda_items].size).to eq(1)
+      expect(result[:agenda_items].first[:type]).to eq(:curious)
+      expect(result[:agenda_items].first[:source]).to eq(:curiosity)
+    end
+
+    it 'returns empty agenda with no wonders' do
+      result = client.form_agenda
+      expect(result[:agenda_items]).to be_empty
+    end
+  end
+
+  describe '#wonder_stats' do
+    it 'returns comprehensive statistics' do
+      client.generate_wonder(question: 'q1?', domain: :a)
+      w = client.generate_wonder(question: 'q2?', domain: :b)
+      client.resolve_wonder(wonder_id: w[:wonder_id], resolution: 'done')
+
+      stats = client.wonder_stats
+      expect(stats[:total_generated]).to eq(2)
+      expect(stats[:active]).to eq(1)
+      expect(stats[:resolved]).to eq(1)
+      expect(stats[:resolution_rate]).to eq(0.5)
+    end
+  end
+
+  describe '#decay_wonders' do
+    it 'prunes exhausted wonders' do
+      client.generate_wonder(question: 'fading?', salience: 0.01)
+      result = client.decay_wonders(hours_elapsed: 10.0)
+      expect(result[:pruned]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/epistemic_curiosity/client_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/epistemic_curiosity/client'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::EpistemicCuriosity::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to create_gap' do
+    expect(client).to respond_to(:create_gap)
+  end
+
+  it 'responds to explore_gap' do
+    expect(client).to respond_to(:explore_gap)
+  end
+
+  it 'responds to satisfy_gap' do
+    expect(client).to respond_to(:satisfy_gap)
+  end
+
+  it 'responds to resolve_gap' do
+    expect(client).to respond_to(:resolve_gap)
+  end
+
+  it 'responds to most_urgent_gaps' do
+    expect(client).to respond_to(:most_urgent_gaps)
+  end
+
+  it 'responds to gaps_by_domain' do
+    expect(client).to respond_to(:gaps_by_domain)
+  end
+
+  it 'responds to gaps_by_type' do
+    expect(client).to respond_to(:gaps_by_type)
+  end
+
+  it 'responds to decay_gaps' do
+    expect(client).to respond_to(:decay_gaps)
+  end
+
+  it 'responds to curiosity_report' do
+    expect(client).to respond_to(:curiosity_report)
+  end
+
+  it 'responds to curiosity_status' do
+    expect(client).to respond_to(:curiosity_status)
+  end
+end

data/spec/legion/extensions/agentic/learning/epistemic_curiosity/helpers/constants_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::EpistemicCuriosity::Helpers::Constants do
+  it 'defines MAX_GAPS' do
+    expect(described_class::MAX_GAPS).to eq(300)
+  end
+
+  it 'defines DEFAULT_URGENCY' do
+    expect(described_class::DEFAULT_URGENCY).to eq(0.5)
+  end
+
+  it 'defines URGENCY_BOOST' do
+    expect(described_class::URGENCY_BOOST).to eq(0.08)
+  end
+
+  it 'defines URGENCY_DECAY' do
+    expect(described_class::URGENCY_DECAY).to eq(0.03)
+  end
+
+  it 'defines SATISFACTION_THRESHOLD' do
+    expect(described_class::SATISFACTION_THRESHOLD).to eq(0.8)
+  end
+
+  it 'defines all five GAP_TYPES' do
+    expect(described_class::GAP_TYPES).to contain_exactly(:factual, :conceptual, :procedural, :causal, :relational)
+  end
+
+  it 'GAP_TYPES is frozen' do
+    expect(described_class::GAP_TYPES).to be_frozen
+  end
+
+  it 'URGENCY_LABELS covers burning range' do
+    entry = described_class::URGENCY_LABELS.find { |e| e[:label] == :burning }
+    expect(entry[:range]).to cover(0.9)
+  end
+
+  it 'URGENCY_LABELS covers satisfied range' do
+    entry = described_class::URGENCY_LABELS.find { |e| e[:label] == :satisfied }
+    expect(entry[:range]).to cover(0.1)
+  end
+
+  it 'URGENCY_LABELS has five entries' do
+    expect(described_class::URGENCY_LABELS.size).to eq(5)
+  end
+end