lex-agentic-defense 0.1.0

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::Claim do
+  subject(:claim) do
+    described_class.new(content: 'the sky is blue', source_id: 'src-1', domain: :weather, confidence: 0.5)
+  end
+
+  describe '#initialize' do
+    it 'generates a UUID id' do
+      expect(claim.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts with :suspended verdict' do
+      expect(claim.verdict).to eq(:suspended)
+    end
+
+    it 'starts with zero evidence' do
+      expect(claim.evidence_for).to eq(0)
+      expect(claim.evidence_against).to eq(0)
+    end
+
+    it 'clamps confidence to 0..1' do
+      over = described_class.new(content: 'x', source_id: 's', domain: :d, confidence: 1.5)
+      under = described_class.new(content: 'x', source_id: 's', domain: :d, confidence: -0.5)
+      expect(over.confidence).to eq(1.0)
+      expect(under.confidence).to eq(0.0)
+    end
+  end
+
+  describe '#support!' do
+    it 'increments evidence_for' do
+      expect { claim.support! }.to change(claim, :evidence_for).by(1)
+    end
+
+    it 'increases confidence by 0.05' do
+      before = claim.confidence
+      claim.support!
+      expect(claim.confidence).to be_within(0.001).of(before + 0.05)
+    end
+
+    it 'clamps confidence at 1.0' do
+      strong = described_class.new(content: 'x', source_id: 's', domain: :d, confidence: 0.98)
+      strong.support!
+      expect(strong.confidence).to eq(1.0)
+    end
+  end
+
+  describe '#challenge!' do
+    it 'increments evidence_against' do
+      expect { claim.challenge! }.to change(claim, :evidence_against).by(1)
+    end
+
+    it 'decreases confidence by 0.08' do
+      before = claim.confidence
+      claim.challenge!
+      expect(claim.confidence).to be_within(0.001).of(before - 0.08)
+    end
+
+    it 'clamps confidence at 0.0' do
+      weak = described_class.new(content: 'x', source_id: 's', domain: :d, confidence: 0.03)
+      weak.challenge!
+      expect(weak.confidence).to eq(0.0)
+    end
+  end
+
+  describe '#credibility_ratio' do
+    it 'returns 0.0 with no evidence' do
+      expect(claim.credibility_ratio).to eq(0.0 / 1.0)
+    end
+
+    it 'is higher with more evidence_for' do
+      3.times { claim.support! }
+      claim.challenge!
+      expect(claim.credibility_ratio).to be > 0.5
+    end
+  end
+
+  describe '#contested?' do
+    it 'is false with no challenges' do
+      3.times { claim.support! }
+      expect(claim.contested?).to be false
+    end
+
+    it 'is true when challenged and credibility_ratio < 0.6' do
+      claim.support!
+      3.times { claim.challenge! }
+      expect(claim.contested?).to be true
+    end
+  end
+
+  describe '#well_supported?' do
+    it 'is false initially' do
+      expect(claim.well_supported?).to be false
+    end
+
+    it 'is true with 3+ for and credibility > 0.7' do
+      4.times { claim.support! }
+      expect(claim.well_supported?).to be true
+    end
+
+    it 'is false when challenged enough to lower credibility_ratio' do
+      3.times { claim.support! }
+      5.times { claim.challenge! }
+      expect(claim.well_supported?).to be false
+    end
+  end
+
+  describe '#adjudicate!' do
+    it 'sets the verdict' do
+      claim.adjudicate!(verdict: :accepted)
+      expect(claim.verdict).to eq(:accepted)
+    end
+
+    it 'can be set to rejected' do
+      claim.adjudicate!(verdict: :rejected)
+      expect(claim.verdict).to eq(:rejected)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = claim.to_h
+      expect(h).to include(:id, :content, :source_id, :domain, :confidence, :verdict,
+                           :evidence_for, :evidence_against, :credibility_ratio,
+                           :contested, :well_supported, :created_at)
+    end
+
+    it 'reflects current state' do
+      claim.support!
+      h = claim.to_h
+      expect(h[:evidence_for]).to eq(1)
+      expect(h[:confidence]).to be > 0.5
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::Constants do
+  subject(:mod) { described_class }
+
+  describe 'VIGILANCE_LEVELS' do
+    it 'defines four levels in order' do
+      expect(mod::VIGILANCE_LEVELS).to eq(%i[trusting cautious skeptical hostile])
+    end
+
+    it 'is frozen' do
+      expect(mod::VIGILANCE_LEVELS).to be_frozen
+    end
+  end
+
+  describe 'VIGILANCE_THRESHOLDS' do
+    it 'defines trusting at 0.8' do
+      expect(mod::VIGILANCE_THRESHOLDS[:trusting]).to eq(0.8)
+    end
+
+    it 'defines hostile at 0.0' do
+      expect(mod::VIGILANCE_THRESHOLDS[:hostile]).to eq(0.0)
+    end
+  end
+
+  describe 'CLAIM_VERDICTS' do
+    it 'includes accepted and rejected' do
+      expect(mod::CLAIM_VERDICTS).to include(:accepted, :rejected)
+    end
+
+    it 'is frozen' do
+      expect(mod::CLAIM_VERDICTS).to be_frozen
+    end
+  end
+
+  describe 'SOURCE_RELIABILITY_LABELS' do
+    it 'maps 0.9 to highly_reliable' do
+      label = mod::SOURCE_RELIABILITY_LABELS.find { |range, _| range.include?(0.9) }&.last
+      expect(label).to eq(:highly_reliable)
+    end
+
+    it 'maps 0.1 to deceptive' do
+      label = mod::SOURCE_RELIABILITY_LABELS.find { |range, _| range.include?(0.1) }&.last
+      expect(label).to eq(:deceptive)
+    end
+
+    it 'maps 0.5 to uncertain' do
+      label = mod::SOURCE_RELIABILITY_LABELS.find { |range, _| range.include?(0.5) }&.last
+      expect(label).to eq(:uncertain)
+    end
+  end
+
+  describe 'weights' do
+    it 'weights sum to 1.0' do
+      total = mod::CONSISTENCY_WEIGHT + mod::SOURCE_WEIGHT + mod::COHERENCE_WEIGHT
+      expect(total).to be_within(0.001).of(1.0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/epistemic_vigilance/helpers/source_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::Source do
+  subject(:source) { described_class.new(name: 'NewsBot', domain: :news) }
+
+  let(:boost)   { Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::Constants::RELIABILITY_BOOST }
+  let(:penalty) { Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::Constants::RELIABILITY_PENALTY }
+  let(:default) { Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::Constants::DEFAULT_SOURCE_RELIABILITY }
+
+  describe '#initialize' do
+    it 'generates a UUID id' do
+      expect(source.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts with default reliability 0.5' do
+      expect(source.reliability).to eq(default)
+    end
+
+    it 'starts with zero claim counts' do
+      expect(source.claims_made).to eq(0)
+      expect(source.claims_verified).to eq(0)
+      expect(source.claims_refuted).to eq(0)
+    end
+  end
+
+  describe '#record_verified!' do
+    it 'increments claims_verified' do
+      expect { source.record_verified! }.to change(source, :claims_verified).by(1)
+    end
+
+    it 'boosts reliability' do
+      before = source.reliability
+      source.record_verified!
+      expect(source.reliability).to be_within(0.001).of(before + boost)
+    end
+
+    it 'clamps reliability at 1.0' do
+      high = described_class.new(name: 'top', domain: :d)
+      high.reliability = 0.99
+      high.record_verified!
+      expect(high.reliability).to eq(1.0)
+    end
+  end
+
+  describe '#record_refuted!' do
+    it 'increments claims_refuted' do
+      expect { source.record_refuted! }.to change(source, :claims_refuted).by(1)
+    end
+
+    it 'penalizes reliability' do
+      before = source.reliability
+      source.record_refuted!
+      expect(source.reliability).to be_within(0.001).of(before - penalty)
+    end
+
+    it 'clamps reliability at 0.0' do
+      low = described_class.new(name: 'spammer', domain: :d)
+      low.reliability = 0.05
+      low.record_refuted!
+      expect(low.reliability).to eq(0.0)
+    end
+
+    it 'penalizes more than boost (asymmetric)' do
+      expect(penalty).to be > boost
+    end
+  end
+
+  describe '#reliability_label' do
+    it 'returns :highly_reliable at 0.9' do
+      source.reliability = 0.9
+      expect(source.reliability_label).to eq(:highly_reliable)
+    end
+
+    it 'returns :deceptive at 0.1' do
+      source.reliability = 0.1
+      expect(source.reliability_label).to eq(:deceptive)
+    end
+
+    it 'returns :uncertain at 0.5' do
+      expect(source.reliability_label).to eq(:uncertain)
+    end
+
+    it 'returns :reliable at 0.7' do
+      source.reliability = 0.7
+      expect(source.reliability_label).to eq(:reliable)
+    end
+
+    it 'returns :unreliable at 0.3' do
+      source.reliability = 0.3
+      expect(source.reliability_label).to eq(:unreliable)
+    end
+  end
+
+  describe '#track_record' do
+    it 'returns 0.0 / 1.0 with no activity' do
+      expect(source.track_record).to be_within(0.001).of(0.0)
+    end
+
+    it 'improves with verifications' do
+      3.times { source.record_verified! }
+      expect(source.track_record).to be > 0.5
+    end
+
+    it 'decreases with refutations' do
+      3.times { source.record_refuted! }
+      expect(source.track_record).to be_within(0.001).of(0.0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = source.to_h
+      expect(h).to include(:id, :name, :domain, :reliability, :reliability_label,
+                           :claims_made, :claims_verified, :claims_refuted, :track_record)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/epistemic_vigilance/helpers/vigilance_engine_spec.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::VigilanceEngine do
+  subject(:engine) { described_class.new }
+
+  let(:source_result) { engine.register_source(name: 'ResearchBot', domain: :science) }
+  let(:source_id) { source_result[:id] }
+
+  describe '#register_source' do
+    it 'returns a hash with id, name, domain' do
+      expect(source_result).to include(:id, :name, :domain)
+    end
+
+    it 'sets name and domain' do
+      expect(source_result[:name]).to eq('ResearchBot')
+      expect(source_result[:domain]).to eq(:science)
+    end
+
+    it 'starts with default reliability' do
+      expect(source_result[:reliability]).to eq(0.5)
+    end
+  end
+
+  describe '#submit_claim' do
+    it 'returns error when source not found' do
+      result = engine.submit_claim(content: 'x', source_id: 'bad', domain: :d)
+      expect(result[:error]).to eq(:source_not_found)
+    end
+
+    it 'returns claim and assessment' do
+      result = engine.submit_claim(content: 'water boils at 100C', source_id: source_id, domain: :science)
+      expect(result).to include(:claim, :assessment)
+    end
+
+    it 'includes recommended_verdict in assessment' do
+      result = engine.submit_claim(content: 'water boils at 100C', source_id: source_id, domain: :science)
+      expect(result[:assessment]).to include(:recommended_verdict)
+    end
+
+    it 'increments source claims_made' do
+      engine.submit_claim(content: 'water boils at 100C', source_id: source_id, domain: :science)
+      report = engine.source_reliability(source_id: source_id)
+      expect(report[:reliability]).to be >= 0.5
+    end
+  end
+
+  describe '#assess_claim' do
+    it 'returns error for missing claim' do
+      result = engine.assess_claim(claim_id: 'nonexistent')
+      expect(result[:error]).to eq(:claim_not_found)
+    end
+
+    it 'returns all score components' do
+      claim_result = engine.submit_claim(content: 'test', source_id: source_id, domain: :science)
+      claim_id = claim_result[:claim][:id]
+      assessment = engine.assess_claim(claim_id: claim_id)
+      expect(assessment).to include(:source_score, :consistency_score, :coherence_score,
+                                    :total_score, :recommended_verdict)
+    end
+
+    it 'source_score reflects source weight' do
+      claim_result = engine.submit_claim(content: 'test', source_id: source_id, domain: :science)
+      claim_id = claim_result[:claim][:id]
+      assessment = engine.assess_claim(claim_id: claim_id)
+      expected = 0.5 * Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::Constants::SOURCE_WEIGHT
+      expect(assessment[:source_score]).to be_within(0.001).of(expected)
+    end
+  end
+
+  describe '#support_claim' do
+    let(:claim_id) do
+      engine.submit_claim(content: 'test', source_id: source_id, domain: :science)[:claim][:id]
+    end
+
+    it 'returns error for unknown claim' do
+      expect(engine.support_claim(claim_id: 'bad')[:error]).to eq(:claim_not_found)
+    end
+
+    it 'increments evidence_for' do
+      result = engine.support_claim(claim_id: claim_id)
+      expect(result[:evidence_for]).to eq(1)
+    end
+
+    it 'increases confidence' do
+      engine.submit_claim(content: 'test', source_id: source_id, domain: :science)
+      result = engine.support_claim(claim_id: claim_id)
+      expect(result[:confidence]).to be > 0.5
+    end
+
+    it 'boosts source reliability' do
+      before = engine.source_reliability(source_id: source_id)[:reliability]
+      engine.support_claim(claim_id: claim_id)
+      after = engine.source_reliability(source_id: source_id)[:reliability]
+      expect(after).to be > before
+    end
+  end
+
+  describe '#challenge_claim' do
+    let(:claim_id) do
+      engine.submit_claim(content: 'test', source_id: source_id, domain: :science)[:claim][:id]
+    end
+
+    it 'returns error for unknown claim' do
+      expect(engine.challenge_claim(claim_id: 'bad')[:error]).to eq(:claim_not_found)
+    end
+
+    it 'increments evidence_against' do
+      result = engine.challenge_claim(claim_id: claim_id)
+      expect(result[:evidence_against]).to eq(1)
+    end
+
+    it 'decreases confidence' do
+      result = engine.challenge_claim(claim_id: claim_id)
+      expect(result[:confidence]).to be < 0.5
+    end
+
+    it 'penalizes source reliability' do
+      before = engine.source_reliability(source_id: source_id)[:reliability]
+      engine.challenge_claim(claim_id: claim_id)
+      after = engine.source_reliability(source_id: source_id)[:reliability]
+      expect(after).to be < before
+    end
+  end
+
+  describe '#adjudicate_claim' do
+    let(:claim_id) do
+      engine.submit_claim(content: 'test', source_id: source_id, domain: :science)[:claim][:id]
+    end
+
+    it 'returns error for unknown claim' do
+      expect(engine.adjudicate_claim(claim_id: 'bad', verdict: :accepted)[:error]).to eq(:claim_not_found)
+    end
+
+    it 'sets the verdict' do
+      result = engine.adjudicate_claim(claim_id: claim_id, verdict: :accepted)
+      expect(result[:verdict]).to eq(:accepted)
+    end
+
+    it 'boosts source reliability on accepted' do
+      before = engine.source_reliability(source_id: source_id)[:reliability]
+      engine.adjudicate_claim(claim_id: claim_id, verdict: :accepted)
+      after = engine.source_reliability(source_id: source_id)[:reliability]
+      expect(after).to be > before
+    end
+
+    it 'penalizes source reliability on rejected' do
+      before = engine.source_reliability(source_id: source_id)[:reliability]
+      engine.adjudicate_claim(claim_id: claim_id, verdict: :rejected)
+      after = engine.source_reliability(source_id: source_id)[:reliability]
+      expect(after).to be < before
+    end
+  end
+
+  describe '#source_reliability' do
+    it 'returns error for unknown source' do
+      expect(engine.source_reliability(source_id: 'bad')[:error]).to eq(:source_not_found)
+    end
+
+    it 'returns reliability and label' do
+      result = engine.source_reliability(source_id: source_id)
+      expect(result).to include(:reliability, :label)
+    end
+  end
+
+  describe '#contested_claims' do
+    it 'returns empty when no contested claims' do
+      expect(engine.contested_claims).to eq([])
+    end
+
+    it 'returns claims that are contested' do
+      claim_id = engine.submit_claim(content: 'test', source_id: source_id, domain: :science)[:claim][:id]
+      engine.support_claim(claim_id: claim_id)
+      3.times { engine.challenge_claim(claim_id: claim_id) }
+      contested = engine.contested_claims
+      expect(contested.size).to eq(1)
+    end
+  end
+
+  describe '#claims_by_source' do
+    it 'returns claims for the given source' do
+      engine.submit_claim(content: 'a', source_id: source_id, domain: :science)
+      engine.submit_claim(content: 'b', source_id: source_id, domain: :science)
+      result = engine.claims_by_source(source_id: source_id)
+      expect(result.size).to eq(2)
+    end
+
+    it 'returns empty for unknown source' do
+      expect(engine.claims_by_source(source_id: 'nobody')).to eq([])
+    end
+  end
+
+  describe '#claims_by_domain' do
+    it 'returns claims for the given domain' do
+      engine.submit_claim(content: 'x', source_id: source_id, domain: :science)
+      engine.submit_claim(content: 'y', source_id: source_id, domain: :science)
+      result = engine.claims_by_domain(domain: :science)
+      expect(result.size).to eq(2)
+    end
+
+    it 'filters by domain' do
+      engine.submit_claim(content: 'x', source_id: source_id, domain: :science)
+      result = engine.claims_by_domain(domain: :other)
+      expect(result).to eq([])
+    end
+  end
+
+  describe '#domain_vigilance_level' do
+    it 'returns :skeptical for empty domain' do
+      expect(engine.domain_vigilance_level(domain: :unknown)).to eq(:skeptical)
+    end
+
+    it 'returns a valid vigilance level' do
+      engine.submit_claim(content: 'test', source_id: source_id, domain: :science)
+      level = engine.domain_vigilance_level(domain: :science)
+      expect(Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::Constants::VIGILANCE_LEVELS).to include(level)
+    end
+
+    it 'returns :hostile for low-confidence domain' do
+      claim_id = engine.submit_claim(content: 'test', source_id: source_id,
+                                     domain: :science, initial_confidence: 0.05)[:claim][:id]
+      5.times { engine.challenge_claim(claim_id: claim_id) }
+      level = engine.domain_vigilance_level(domain: :science)
+      expect(%i[skeptical hostile]).to include(level)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns count of decayed claims' do
+      engine.submit_claim(content: 'test', source_id: source_id, domain: :science)
+      result = engine.decay_all
+      expect(result[:decayed]).to eq(1)
+    end
+
+    it 'reduces claim confidence' do
+      engine.submit_claim(content: 'test', source_id: source_id, domain: :science)[:claim][:id]
+      before = engine.claims_by_domain(domain: :science).first[:confidence]
+      engine.decay_all
+      after = engine.claims_by_domain(domain: :science).first[:confidence]
+      expect(after).to be < before
+    end
+  end
+
+  describe '#prune_rejected' do
+    it 'removes rejected claims below 0.1 confidence' do
+      claim_id = engine.submit_claim(content: 'garbage', source_id: source_id,
+                                     domain: :science, initial_confidence: 0.05)[:claim][:id]
+      engine.adjudicate_claim(claim_id: claim_id, verdict: :rejected)
+      result = engine.prune_rejected
+      expect(result[:pruned]).to eq(1)
+    end
+
+    it 'keeps rejected claims above 0.1 confidence' do
+      claim_id = engine.submit_claim(content: 'maybe', source_id: source_id,
+                                     domain: :science, initial_confidence: 0.5)[:claim][:id]
+      engine.adjudicate_claim(claim_id: claim_id, verdict: :rejected)
+      engine.prune_rejected
+      expect(engine.claims_by_domain(domain: :science).size).to eq(1)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash' do
+      result = engine.to_h
+      expect(result).to include(:sources_count, :claims_count, :contested, :by_verdict)
+    end
+
+    it 'reflects current state' do
+      engine.submit_claim(content: 'test', source_id: source_id, domain: :science)
+      expect(engine.to_h[:claims_count]).to eq(1)
+      expect(engine.to_h[:sources_count]).to eq(1)
+    end
+  end
+end