lex-agentic-defense 0.1.0

data/spec/legion/extensions/agentic/defense/bias/helpers/bias_store_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/bias/helpers/constants'
+require 'legion/extensions/agentic/defense/bias/helpers/bias_event'
+require 'legion/extensions/agentic/defense/bias/helpers/bias_store'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Bias::Helpers::BiasStore do
+  subject(:store) { described_class.new }
+
+  let(:event) do
+    Legion::Extensions::Agentic::Defense::Bias::Helpers::BiasEvent.new(
+      bias_type: :anchoring,
+      domain:    :finance,
+      magnitude: 0.6
+    )
+  end
+
+  let(:event2) do
+    Legion::Extensions::Agentic::Defense::Bias::Helpers::BiasEvent.new(
+      bias_type: :confirmation,
+      domain:    :research,
+      magnitude: 0.4
+    )
+  end
+
+  describe '#record' do
+    it 'stores an event and returns it' do
+      result = store.record(event)
+      expect(result).to eq(event)
+    end
+
+    it 'trims events at MAX_BIAS_EVENTS' do
+      max = Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::MAX_BIAS_EVENTS
+      (max + 10).times do
+        store.record(Legion::Extensions::Agentic::Defense::Bias::Helpers::BiasEvent.new(
+                       bias_type: :recency,
+                       domain:    :test,
+                       magnitude: 0.1
+                     ))
+      end
+      expect(store.recent(max + 10).size).to eq(max)
+    end
+  end
+
+  describe '#recent' do
+    it 'returns the most recent events as hashes' do
+      store.record(event)
+      store.record(event2)
+      result = store.recent(2)
+      expect(result.size).to eq(2)
+      expect(result.first).to be_a(Hash)
+    end
+
+    it 'returns fewer than requested when not enough events' do
+      store.record(event)
+      expect(store.recent(10).size).to eq(1)
+    end
+  end
+
+  describe '#by_type' do
+    it 'returns only events matching bias_type' do
+      store.record(event)
+      store.record(event2)
+      result = store.by_type(:anchoring)
+      expect(result.size).to eq(1)
+      expect(result.first[:bias_type]).to eq(:anchoring)
+    end
+  end
+
+  describe '#by_domain' do
+    it 'returns only events matching domain' do
+      store.record(event)
+      store.record(event2)
+      result = store.by_domain(:finance)
+      expect(result.size).to eq(1)
+      expect(result.first[:domain]).to eq(:finance)
+    end
+  end
+
+  describe '#register_anchor and #anchors_for' do
+    it 'stores anchor values for a domain' do
+      store.register_anchor(:pricing, value: 99.99)
+      anchors = store.anchors_for(:pricing)
+      expect(anchors.size).to eq(1)
+      expect(anchors.first[:value]).to eq(99.99)
+    end
+
+    it 'returns empty array for unknown domain' do
+      expect(store.anchors_for(:nonexistent)).to eq([])
+    end
+
+    it 'trims anchors at MAX_ANCHORS' do
+      max = Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::MAX_ANCHORS
+      (max + 5).times { |i| store.register_anchor(:domain, value: i) }
+      expect(store.anchors_for(:domain).size).to eq(max)
+    end
+  end
+
+  describe '#decay_anchors' do
+    it 'reduces anchor influence' do
+      store.register_anchor(:pricing, value: 100.0, influence: 1.0)
+      store.decay_anchors
+      anchor = store.anchors_for(:pricing).first
+      expect(anchor[:influence]).to be < 1.0
+    end
+
+    it 'removes anchors with influence at or below 0' do
+      store.register_anchor(:pricing, value: 1.0, influence: 0.01)
+      store.decay_anchors
+      expect(store.anchors_for(:pricing)).to be_empty
+    end
+  end
+
+  describe '#stats' do
+    it 'returns total 0 with empty store' do
+      result = store.stats
+      expect(result[:total]).to eq(0)
+    end
+
+    it 'aggregates counts and avg_magnitude per type' do
+      store.record(event)
+      stats = store.stats
+      expect(stats[:by_type][:anchoring][:count]).to eq(1)
+      expect(stats[:by_type][:anchoring][:avg_magnitude]).to eq(0.6)
+    end
+
+    it 'aggregates by domain' do
+      store.record(event)
+      stats = store.stats
+      expect(stats[:by_domain][:finance][:count]).to eq(1)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns total_events and anchor_domains' do
+      store.record(event)
+      store.register_anchor(:pricing, value: 50.0)
+      h = store.to_h
+      expect(h[:total_events]).to eq(1)
+      expect(h[:anchor_domains]).to include(:pricing)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/bias/runners/bias_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/bias/client'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Bias::Runners::Bias do
+  let(:client) { Legion::Extensions::Agentic::Defense::Bias::Client.new }
+
+  describe '#record_anchor' do
+    it 'returns success: true' do
+      result = client.record_anchor(domain: :finance, value: 100.0)
+      expect(result[:success]).to be true
+      expect(result[:domain]).to eq(:finance)
+      expect(result[:value]).to eq(100.0)
+    end
+  end
+
+  describe '#check_for_bias' do
+    context 'with no decision context' do
+      it 'returns success: true with empty detected list' do
+        result = client.check_for_bias(domain: :test)
+        expect(result[:success]).to be true
+        expect(result[:detected]).to be_empty
+      end
+    end
+
+    context 'with anchoring context' do
+      before { client.record_anchor(domain: :finance, value: 100.0) }
+
+      it 'detects anchoring when current value is close to anchor' do
+        result = client.check_for_bias(
+          domain:           :finance,
+          decision_context: { current_value: 101.0 }
+        )
+        expect(result[:success]).to be true
+        anchoring = result[:all].find { |b| b[:bias_type] == :anchoring }
+        expect(anchoring).not_to be_nil
+        expect(anchoring[:magnitude]).to be > 0.0
+      end
+    end
+
+    context 'with confirmation bias context' do
+      it 'detects confirmation bias when evidence matches hypothesis' do
+        result = client.check_for_bias(
+          domain:           :research,
+          decision_context: {
+            evidence_direction:   :positive,
+            hypothesis_direction: :positive
+          }
+        )
+        confirmation = result[:all].find { |b| b[:bias_type] == :confirmation }
+        expect(confirmation[:magnitude]).to be > 0.0
+      end
+    end
+
+    context 'with availability bias context' do
+      it 'detects availability bias with recent events' do
+        result = client.check_for_bias(
+          domain:           :safety,
+          decision_context: { recent_events: Array.new(10, :incident) }
+        )
+        availability = result[:all].find { |b| b[:bias_type] == :availability }
+        expect(availability[:magnitude]).to be > 0.0
+      end
+    end
+
+    context 'with recency bias context' do
+      it 'detects recency bias with skewed data points' do
+        data = [1.0, 1.0, 1.0, 1.0, 9.0, 9.0, 9.0, 9.0]
+        result = client.check_for_bias(
+          domain:           :market,
+          decision_context: { data_points: data }
+        )
+        recency = result[:all].find { |b| b[:bias_type] == :recency }
+        expect(recency[:magnitude]).to be > 0.0
+      end
+    end
+
+    context 'with sunk cost bias context' do
+      it 'detects sunk cost bias with high investment and low return' do
+        result = client.check_for_bias(
+          domain:           :project,
+          decision_context: { invested: 1_000_000, expected_return: 100 }
+        )
+        sunk = result[:all].find { |b| b[:bias_type] == :sunk_cost }
+        expect(sunk[:magnitude]).to be > 0.0
+      end
+    end
+
+    it 'marks bias as corrected when magnitude exceeds threshold' do
+      client.record_anchor(domain: :finance, value: 100.0)
+      result = client.check_for_bias(
+        domain:           :finance,
+        decision_context: { current_value: 100.0 }
+      )
+      anchoring = result[:all].find { |b| b[:bias_type] == :anchoring }
+      if anchoring[:magnitude] >= Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::DETECTION_THRESHOLD
+        expect(anchoring[:corrected]).to be true
+        expect(anchoring[:correction_applied]).to be > 0.0
+      end
+    end
+  end
+
+  describe '#update_bias' do
+    it 'returns success: true' do
+      result = client.update_bias
+      expect(result[:success]).to be true
+    end
+
+    it 'decays anchor influence' do
+      client.record_anchor(domain: :pricing, value: 50.0)
+      client.update_bias
+    end
+  end
+
+  describe '#bias_report' do
+    it 'returns success: true with empty events on fresh client' do
+      result = client.bias_report
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'filters by domain when provided' do
+      client.record_anchor(domain: :finance, value: 100.0)
+      client.check_for_bias(domain: :finance, decision_context: { current_value: 100.0 })
+      result = client.bias_report(domain: :finance)
+      expect(result[:domain]).to eq(:finance)
+    end
+  end
+
+  describe '#susceptibility_profile' do
+    it 'returns success: true with susceptibility hash' do
+      result = client.susceptibility_profile
+      expect(result[:success]).to be true
+      expect(result[:susceptibility]).to be_a(Hash)
+      expect(result[:susceptibility].keys).to match_array(
+        Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::BIAS_TYPES
+      )
+    end
+  end
+
+  describe '#bias_stats' do
+    it 'returns success: true' do
+      result = client.bias_stats
+      expect(result[:success]).to be true
+      expect(result[:total]).to eq(0)
+    end
+
+    it 'reflects recorded events' do
+      client.record_anchor(domain: :finance, value: 100.0)
+      client.check_for_bias(domain: :finance, decision_context: { current_value: 100.0 })
+      result = client.bias_stats
+      expect(result[:total]).to be >= 0
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/confabulation/client_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/confabulation/client'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Confabulation::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to confabulation runner methods' do
+    expect(client).to respond_to(:register_claim)
+    expect(client).to respond_to(:verify_claim)
+    expect(client).to respond_to(:flag_confabulation)
+    expect(client).to respond_to(:confabulation_report)
+    expect(client).to respond_to(:high_risk_claims)
+    expect(client).to respond_to(:confabulation_status)
+  end
+
+  it 'starts with an empty engine' do
+    status = client.confabulation_status
+    expect(status[:engine][:claim_count]).to eq(0)
+  end
+
+  it 'persists claims across calls within the same instance' do
+    client.register_claim(content: 'persistent', claim_type: :factual,
+                          confidence: 0.7, evidence_strength: 0.3)
+    expect(client.confabulation_status[:engine][:claim_count]).to eq(1)
+  end
+
+  it 'maintains separate state between instances' do
+    client.register_claim(content: 'instance A claim', claim_type: :factual,
+                          confidence: 0.7, evidence_strength: 0.3)
+    other = described_class.new
+    expect(other.confabulation_status[:engine][:claim_count]).to eq(0)
+  end
+end

data/spec/legion/extensions/agentic/defense/confabulation/helpers/claim_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Confabulation::Helpers::Claim do
+  let(:claim) do
+    described_class.new(
+      content:           'The sky is green',
+      claim_type:        :factual,
+      confidence:        0.8,
+      evidence_strength: 0.3
+    )
+  end
+
+  describe '#initialize' do
+    it 'generates a UUID id' do
+      expect(claim.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores content' do
+      expect(claim.content).to eq('The sky is green')
+    end
+
+    it 'stores claim_type' do
+      expect(claim.claim_type).to eq(:factual)
+    end
+
+    it 'clamps confidence to [0, 1]' do
+      c = described_class.new(content: 'x', claim_type: :factual, confidence: 1.5, evidence_strength: 0.0)
+      expect(c.confidence).to eq(1.0)
+    end
+
+    it 'clamps evidence_strength to [0, 1]' do
+      c = described_class.new(content: 'x', claim_type: :factual, confidence: 0.5, evidence_strength: -0.5)
+      expect(c.evidence_strength).to eq(0.0)
+    end
+
+    it 'starts unverified' do
+      expect(claim.verified).to be false
+    end
+
+    it 'starts not confabulated' do
+      expect(claim.confabulated).to be false
+    end
+
+    it 'sets created_at to utc time' do
+      expect(claim.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#confabulation_risk' do
+    it 'computes the gap between confidence and evidence_strength' do
+      expect(claim.confabulation_risk).to be_within(0.001).of(0.5)
+    end
+
+    it 'clamps to 0.0 when evidence >= confidence' do
+      c = described_class.new(content: 'x', claim_type: :factual, confidence: 0.3, evidence_strength: 0.9)
+      expect(c.confabulation_risk).to eq(0.0)
+    end
+
+    it 'clamps to 1.0 when gap exceeds 1.0' do
+      c = described_class.new(content: 'x', claim_type: :factual, confidence: 1.0, evidence_strength: 0.0)
+      expect(c.confabulation_risk).to eq(1.0)
+    end
+  end
+
+  describe '#verify!' do
+    it 'marks the claim as verified' do
+      claim.verify!
+      expect(claim.verified).to be true
+    end
+
+    it 'returns self' do
+      expect(claim.verify!).to eq(claim)
+    end
+  end
+
+  describe '#mark_confabulated!' do
+    it 'marks the claim as confabulated' do
+      claim.mark_confabulated!
+      expect(claim.confabulated).to be true
+    end
+
+    it 'returns self' do
+      expect(claim.mark_confabulated!).to eq(claim)
+    end
+  end
+
+  describe '#risk_label' do
+    it 'returns :extreme for risk >= 0.8' do
+      c = described_class.new(content: 'x', claim_type: :factual, confidence: 1.0, evidence_strength: 0.1)
+      expect(c.risk_label).to eq(:extreme)
+    end
+
+    it 'returns :minimal for risk <= 0.2' do
+      c = described_class.new(content: 'x', claim_type: :factual, confidence: 0.2, evidence_strength: 0.1)
+      expect(c.risk_label).to eq(:minimal)
+    end
+
+    it 'returns :moderate for mid-range risk' do
+      c = described_class.new(content: 'x', claim_type: :factual, confidence: 0.7, evidence_strength: 0.25)
+      expect(c.risk_label).to eq(:moderate)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = claim.to_h
+      expect(h.keys).to include(
+        :id, :content, :claim_type, :confidence, :evidence_strength,
+        :confabulation_risk, :risk_label, :verified, :confabulated, :created_at
+      )
+    end
+
+    it 'rounds numeric fields to 10 decimal places' do
+      h = claim.to_h
+      expect(h[:confidence]).to eq(0.8)
+      expect(h[:confabulation_risk]).to be_a(Float)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/confabulation/helpers/confabulation_engine_spec.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Confabulation::Helpers::ConfabulationEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#register_claim' do
+    it 'stores the claim and returns a Claim object' do
+      claim = engine.register_claim(content: 'Cats can fly', claim_type: :factual,
+                                    confidence: 0.9, evidence_strength: 0.1)
+      expect(claim).to be_a(Legion::Extensions::Agentic::Defense::Confabulation::Helpers::Claim)
+      expect(engine.claims.size).to eq(1)
+    end
+
+    it 'assigns the claim an id' do
+      claim = engine.register_claim(content: 'test', claim_type: :causal,
+                                    confidence: 0.5, evidence_strength: 0.5)
+      expect(claim.id).not_to be_nil
+    end
+
+    it 'defaults claim_type to :factual for unknown types' do
+      claim = engine.register_claim(content: 'x', claim_type: :unknown,
+                                    confidence: 0.5, evidence_strength: 0.5)
+      expect(claim.claim_type).to eq(:factual)
+    end
+
+    it 'accepts all valid claim types' do
+      Legion::Extensions::Agentic::Defense::Confabulation::Helpers::Constants::CLAIM_TYPES.each do |type|
+        claim = engine.register_claim(content: 'x', claim_type: type,
+                                      confidence: 0.5, evidence_strength: 0.5)
+        expect(claim.claim_type).to eq(type)
+      end
+    end
+  end
+
+  describe '#verify_claim' do
+    it 'marks claim as verified' do
+      claim = engine.register_claim(content: 'x', claim_type: :factual,
+                                    confidence: 0.5, evidence_strength: 0.5)
+      result = engine.verify_claim(claim_id: claim.id)
+      expect(result[:found]).to be true
+      expect(result[:verified]).to be true
+      expect(engine.claims[claim.id].verified).to be true
+    end
+
+    it 'returns found: false for unknown id' do
+      result = engine.verify_claim(claim_id: 'no-such-id')
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#flag_confabulation' do
+    it 'marks claim as confabulated' do
+      claim = engine.register_claim(content: 'x', claim_type: :factual,
+                                    confidence: 0.9, evidence_strength: 0.1)
+      result = engine.flag_confabulation(claim_id: claim.id)
+      expect(result[:found]).to be true
+      expect(result[:confabulated]).to be true
+      expect(engine.claims[claim.id].confabulated).to be true
+    end
+
+    it 'returns found: false for unknown id' do
+      result = engine.flag_confabulation(claim_id: 'no-such-id')
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#high_risk_claims' do
+    it 'returns claims above the confabulation threshold' do
+      engine.register_claim(content: 'risky', claim_type: :factual, confidence: 0.9, evidence_strength: 0.1)
+      engine.register_claim(content: 'safe',  claim_type: :factual, confidence: 0.4, evidence_strength: 0.4)
+      high_risk = engine.high_risk_claims
+      expect(high_risk.size).to eq(1)
+      expect(high_risk.first.content).to eq('risky')
+    end
+
+    it 'returns empty array when no high-risk claims exist' do
+      engine.register_claim(content: 'safe', claim_type: :factual, confidence: 0.3, evidence_strength: 0.3)
+      expect(engine.high_risk_claims).to be_empty
+    end
+  end
+
+  describe '#verified_claims' do
+    it 'returns only verified claims' do
+      c1 = engine.register_claim(content: 'verified', claim_type: :factual, confidence: 0.5, evidence_strength: 0.5)
+      engine.register_claim(content: 'unverified', claim_type: :factual, confidence: 0.5, evidence_strength: 0.5)
+      engine.verify_claim(claim_id: c1.id)
+      expect(engine.verified_claims.size).to eq(1)
+    end
+  end
+
+  describe '#confabulation_rate' do
+    it 'returns 0.0 when no claims' do
+      expect(engine.confabulation_rate).to eq(0.0)
+    end
+
+    it 'returns fraction of confabulated claims' do
+      c1 = engine.register_claim(content: 'a', claim_type: :factual, confidence: 0.9, evidence_strength: 0.1)
+      engine.register_claim(content: 'b', claim_type: :factual, confidence: 0.4, evidence_strength: 0.4)
+      engine.flag_confabulation(claim_id: c1.id)
+      expect(engine.confabulation_rate).to be_within(0.001).of(0.5)
+    end
+  end
+
+  describe '#average_calibration' do
+    it 'returns 0.0 when no claims' do
+      expect(engine.average_calibration).to eq(0.0)
+    end
+
+    it 'returns 1.0 when all claims are perfectly calibrated' do
+      engine.register_claim(content: 'x', claim_type: :factual, confidence: 0.5, evidence_strength: 0.5)
+      expect(engine.average_calibration).to eq(1.0)
+    end
+
+    it 'returns lower value when confidence mismatches evidence' do
+      engine.register_claim(content: 'x', claim_type: :factual, confidence: 1.0, evidence_strength: 0.0)
+      expect(engine.average_calibration).to be < 1.0
+    end
+  end
+
+  describe '#confabulation_report' do
+    it 'returns a comprehensive report hash' do
+      engine.register_claim(content: 'x', claim_type: :factual, confidence: 0.8, evidence_strength: 0.2)
+      report = engine.confabulation_report
+      expect(report.keys).to include(
+        :total_claims, :high_risk_claims, :verified_claims,
+        :confabulated_claims, :confabulation_rate, :average_calibration,
+        :overall_risk, :risk_label
+      )
+    end
+
+    it 'risk_label is a symbol' do
+      report = engine.confabulation_report
+      expect(report[:risk_label]).to be_a(Symbol)
+    end
+
+    it 'totals match registered claims' do
+      2.times { |i| engine.register_claim(content: "claim#{i}", claim_type: :factual, confidence: 0.5, evidence_strength: 0.5) }
+      expect(engine.confabulation_report[:total_claims]).to eq(2)
+    end
+  end
+
+  describe '#prune_if_needed' do
+    it 'prunes oldest claim when at MAX_CLAIMS capacity' do
+      max = Legion::Extensions::Agentic::Defense::Confabulation::Helpers::Constants::MAX_CLAIMS
+      first_claim = engine.register_claim(content: 'first', claim_type: :factual, confidence: 0.5, evidence_strength: 0.5)
+      (max - 1).times { |i| engine.register_claim(content: "claim#{i}", claim_type: :factual, confidence: 0.5, evidence_strength: 0.5) }
+      expect(engine.claims.size).to eq(max)
+      engine.register_claim(content: 'overflow', claim_type: :factual, confidence: 0.5, evidence_strength: 0.5)
+      expect(engine.claims.size).to eq(max)
+      expect(engine.claims[first_claim.id]).to be_nil
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a summary hash' do
+      engine.register_claim(content: 'x', claim_type: :factual, confidence: 0.5, evidence_strength: 0.5)
+      h = engine.to_h
+      expect(h).to have_key(:claim_count)
+      expect(h).to have_key(:confabulation_rate)
+      expect(h).to have_key(:average_calibration)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/confabulation/helpers/constants_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Confabulation::Helpers::Constants do
+  describe 'MAX_CLAIMS' do
+    it 'is 500' do
+      expect(described_class::MAX_CLAIMS).to eq(500)
+    end
+  end
+
+  describe 'CONFABULATION_THRESHOLD' do
+    it 'is 0.6' do
+      expect(described_class::CONFABULATION_THRESHOLD).to eq(0.6)
+    end
+  end
+
+  describe 'EVIDENCE_DECAY' do
+    it 'is 0.02' do
+      expect(described_class::EVIDENCE_DECAY).to eq(0.02)
+    end
+  end
+
+  describe 'RISK_LABELS' do
+    it 'covers the full 0.0-1.0 range' do
+      expect(described_class::RISK_LABELS.keys.map(&:min).min).to eq(0.0)
+      expect(described_class::RISK_LABELS.keys.map(&:max).max).to eq(1.0)
+    end
+
+    it 'includes all five risk levels' do
+      labels = described_class::RISK_LABELS.values
+      expect(labels).to include(:minimal, :low, :moderate, :high, :extreme)
+    end
+
+    it 'maps 0.0 to minimal' do
+      label = described_class::RISK_LABELS.find { |range, _| range.cover?(0.0) }&.last
+      expect(label).to eq(:minimal)
+    end
+
+    it 'maps 0.9 to extreme' do
+      label = described_class::RISK_LABELS.find { |range, _| range.cover?(0.9) }&.last
+      expect(label).to eq(:extreme)
+    end
+  end
+
+  describe 'CLAIM_TYPES' do
+    it 'includes all five types' do
+      expect(described_class::CLAIM_TYPES).to include(
+        :factual, :causal, :explanatory, :predictive, :autobiographical
+      )
+    end
+
+    it 'is frozen' do
+      expect(described_class::CLAIM_TYPES).to be_frozen
+    end
+  end
+end