lex-agentic-defense 0.1.0

data/spec/legion/extensions/agentic/defense/epistemic_vigilance/runners/epistemic_vigilance_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/epistemic_vigilance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::EpistemicVigilance::Runners::EpistemicVigilance do
+  let(:client) { Legion::Extensions::Agentic::Defense::EpistemicVigilance::Client.new }
+
+  let(:source_id) do
+    client.register_epistemic_source(name: 'TestSource', domain: :testing)[:id]
+  end
+
+  let(:claim_id) do
+    client.submit_epistemic_claim(content: 'test claim', source_id: source_id, domain: :testing)[:claim][:id]
+  end
+
+  describe '#register_epistemic_source' do
+    it 'returns a hash with id and name' do
+      result = client.register_epistemic_source(name: 'ScienceBot', domain: :science)
+      expect(result).to include(:id, :name, :domain)
+      expect(result[:name]).to eq('ScienceBot')
+    end
+  end
+
+  describe '#submit_epistemic_claim' do
+    it 'returns claim and assessment' do
+      result = client.submit_epistemic_claim(content: 'sky is blue', source_id: source_id, domain: :testing)
+      expect(result).to include(:claim, :assessment)
+    end
+
+    it 'returns error for unknown source' do
+      result = client.submit_epistemic_claim(content: 'x', source_id: 'bad', domain: :testing)
+      expect(result[:error]).to eq(:source_not_found)
+    end
+  end
+
+  describe '#assess_epistemic_claim' do
+    it 'returns assessment with all score fields' do
+      cid = claim_id
+      result = client.assess_epistemic_claim(claim_id: cid)
+      expect(result).to include(:source_score, :consistency_score, :coherence_score,
+                                :total_score, :recommended_verdict)
+    end
+
+    it 'returns error for unknown claim' do
+      result = client.assess_epistemic_claim(claim_id: 'bad')
+      expect(result[:error]).to eq(:claim_not_found)
+    end
+  end
+
+  describe '#support_epistemic_claim' do
+    it 'increments evidence_for' do
+      cid = claim_id
+      result = client.support_epistemic_claim(claim_id: cid)
+      expect(result[:evidence_for]).to eq(1)
+    end
+
+    it 'increases confidence' do
+      cid = claim_id
+      result = client.support_epistemic_claim(claim_id: cid)
+      expect(result[:confidence]).to be > 0.5
+    end
+  end
+
+  describe '#challenge_epistemic_claim' do
+    it 'increments evidence_against' do
+      cid = claim_id
+      result = client.challenge_epistemic_claim(claim_id: cid)
+      expect(result[:evidence_against]).to eq(1)
+    end
+
+    it 'decreases confidence' do
+      cid = claim_id
+      result = client.challenge_epistemic_claim(claim_id: cid)
+      expect(result[:confidence]).to be < 0.5
+    end
+  end
+
+  describe '#adjudicate_epistemic_claim' do
+    it 'sets the verdict to accepted' do
+      cid = claim_id
+      result = client.adjudicate_epistemic_claim(claim_id: cid, verdict: :accepted)
+      expect(result[:verdict]).to eq(:accepted)
+    end
+
+    it 'sets the verdict to rejected' do
+      cid = claim_id
+      result = client.adjudicate_epistemic_claim(claim_id: cid, verdict: :rejected)
+      expect(result[:verdict]).to eq(:rejected)
+    end
+  end
+
+  describe '#source_reliability_report' do
+    it 'returns reliability and label' do
+      sid = source_id
+      result = client.source_reliability_report(source_id: sid)
+      expect(result).to include(:reliability, :label)
+    end
+
+    it 'returns error for unknown source' do
+      result = client.source_reliability_report(source_id: 'bad')
+      expect(result[:error]).to eq(:source_not_found)
+    end
+  end
+
+  describe '#contested_claims_report' do
+    it 'returns contested claims list and count' do
+      result = client.contested_claims_report
+      expect(result).to include(:contested, :count)
+    end
+
+    it 'count matches contested array size' do
+      result = client.contested_claims_report
+      expect(result[:count]).to eq(result[:contested].size)
+    end
+  end
+
+  describe '#domain_vigilance_report' do
+    it 'returns domain, vigilance_level, claims, count' do
+      result = client.domain_vigilance_report(domain: :testing)
+      expect(result).to include(:domain, :vigilance_level, :claims, :count)
+    end
+
+    it 'includes submitted claims in domain' do
+      claim_id # force creation
+      result = client.domain_vigilance_report(domain: :testing)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#update_epistemic_vigilance' do
+    it 'returns decay and prune results' do
+      result = client.update_epistemic_vigilance
+      expect(result).to include(:decay, :prune)
+    end
+
+    it 'decays existing claims' do
+      claim_id # create a claim
+      result = client.update_epistemic_vigilance
+      expect(result[:decay][:decayed]).to be >= 1
+    end
+  end
+
+  describe '#epistemic_vigilance_stats' do
+    it 'returns stats hash' do
+      result = client.epistemic_vigilance_stats
+      expect(result).to include(:sources_count, :claims_count, :contested, :by_verdict)
+    end
+
+    it 'reflects registered sources and submitted claims' do
+      sid = source_id
+      client.submit_epistemic_claim(content: 'test', source_id: sid, domain: :testing)
+      stats = client.epistemic_vigilance_stats
+      expect(stats[:sources_count]).to be >= 1
+      expect(stats[:claims_count]).to be >= 1
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Erosion::Client do
+  let(:engine) { Legion::Extensions::Agentic::Defense::Erosion::Helpers::ErosionEngine.new }
+  let(:client) { described_class.new(engine: engine) }
+
+  describe '#initialize' do
+    it 'accepts injected engine' do
+      expect(client).to respond_to(:create_formation)
+    end
+
+    it 'creates its own engine when none injected' do
+      c = described_class.new
+      result = c.create_formation(material_type: :limestone, domain: 'd', content: 'c')
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '#create_formation' do
+    it 'creates a formation' do
+      result = client.create_formation(material_type: :sandstone, domain: 'morality', content: 'lying is wrong')
+      expect(result[:success]).to be(true)
+      expect(result[:formation_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+  end
+
+  describe '#erode' do
+    it 'erodes an existing formation' do
+      id = client.create_formation(material_type: :chalk, domain: 'taste', content: 'jazz is noise')[:formation_id]
+      result = client.erode(formation_id: id, agent: :water, force: 0.4)
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '#weather_all' do
+    it 'weathers all formations in the engine' do
+      client.create_formation(material_type: :clay, domain: 'd1', content: 'c1')
+      client.create_formation(material_type: :chalk, domain: 'd2', content: 'c2')
+      result = client.weather_all
+      expect(result[:weathered]).to eq(2)
+    end
+  end
+
+  describe '#deepest_channels' do
+    it 'returns channels' do
+      result = client.deepest_channels
+      expect(result[:channels]).to be_an(Array)
+    end
+  end
+
+  describe '#most_eroded' do
+    it 'returns formations' do
+      result = client.most_eroded
+      expect(result[:formations]).to be_an(Array)
+    end
+  end
+
+  describe '#erosion_report' do
+    it 'returns a report' do
+      result = client.erosion_report
+      expect(result[:success]).to be(true)
+      expect(result).to include(:total_formations, :total_channels)
+    end
+  end
+
+  describe 'full erosion lifecycle' do
+    it 'creates formation, erodes repeatedly, and reports canyon' do
+      id = client.create_formation(material_type: :clay, domain: 'belief', content: 'hard work always pays off')[:formation_id]
+
+      10.times { client.erode(formation_id: id, agent: :water, force: 0.8) }
+
+      report = client.erosion_report
+      expect(report[:canyons]).to be >= 1
+
+      channels = client.deepest_channels(limit: 3)
+      expect(channels[:channels].first[:depth]).to be > 0.3
+    end
+
+    it 'tracks multiple independent erosion channels per formation' do
+      id = client.create_formation(material_type: :limestone, domain: 'politics', content: 'markets self-regulate')[:formation_id]
+
+      client.erode(formation_id: id, agent: :water, force: 0.3)
+      client.erode(formation_id: id, agent: :wind, force: 0.3)
+      client.erode(formation_id: id, agent: :chemical, force: 0.3)
+
+      report = client.erosion_report
+      expect(report[:total_channels]).to be >= 3
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/erosion/helpers/channel_spec.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Erosion::Helpers::Channel do
+  let(:formation_id) { 'test-formation-uuid-1234' }
+  let(:channel) { described_class.new(formation_id: formation_id, agent: :water) }
+
+  describe '#initialize' do
+    it 'assigns a UUID channel_id' do
+      expect(channel.channel_id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets formation_id' do
+      expect(channel.formation_id).to eq(formation_id)
+    end
+
+    it 'sets agent' do
+      expect(channel.agent).to eq(:water)
+    end
+
+    it 'starts with depth 0.0' do
+      expect(channel.depth).to eq(0.0)
+    end
+
+    it 'starts with default width 0.1' do
+      expect(channel.width).to eq(0.1)
+    end
+
+    it 'starts with flow_rate 0.0' do
+      expect(channel.flow_rate).to eq(0.0)
+    end
+
+    it 'accepts custom initial depth' do
+      ch = described_class.new(formation_id: formation_id, agent: :wind, depth: 0.4)
+      expect(ch.depth).to eq(0.4)
+    end
+
+    it 'clamps depth to 0.0-1.0 range' do
+      ch = described_class.new(formation_id: formation_id, agent: :wind, depth: 5.0)
+      expect(ch.depth).to eq(1.0)
+    end
+
+    it 'raises ArgumentError for invalid agent' do
+      expect do
+        described_class.new(formation_id: formation_id, agent: :laser)
+      end.to raise_error(ArgumentError, /invalid agent/)
+    end
+
+    it 'last_active_at starts as nil' do
+      expect(channel.last_active_at).to be_nil
+    end
+  end
+
+  describe '#deepen!' do
+    it 'increases depth' do
+      channel.deepen!(0.3)
+      expect(channel.depth).to be > 0.0
+    end
+
+    it 'increases flow_rate' do
+      channel.deepen!(0.5)
+      expect(channel.flow_rate).to be > 0.0
+    end
+
+    it 'returns hash with depth and flow_rate' do
+      result = channel.deepen!(0.2)
+      expect(result).to include(:depth, :flow_rate)
+    end
+
+    it 'clamps force to 0.0 minimum' do
+      channel.deepen!(-1.0)
+      expect(channel.depth).to eq(0.0)
+    end
+
+    it 'clamps depth at 1.0 maximum' do
+      5.times { channel.deepen!(1.0) }
+      expect(channel.depth).to eq(1.0)
+    end
+
+    it 'sets last_active_at' do
+      channel.deepen!(0.1)
+      expect(channel.last_active_at).not_to be_nil
+    end
+
+    it 'updates updated_at' do
+      original = channel.updated_at
+      sleep(0.001)
+      channel.deepen!(0.1)
+      expect(channel.updated_at).to be >= original
+    end
+  end
+
+  describe '#widen!' do
+    it 'increases width' do
+      before = channel.width
+      channel.widen!
+      expect(channel.width).to be > before
+    end
+
+    it 'accepts custom amount' do
+      channel.widen!(0.2)
+      expect(channel.width).to be_within(0.001).of(0.3)
+    end
+
+    it 'clamps width at 1.0' do
+      10.times { channel.widen!(1.0) }
+      expect(channel.width).to eq(1.0)
+    end
+
+    it 'returns hash with width' do
+      result = channel.widen!
+      expect(result).to include(:width)
+    end
+  end
+
+  describe '#dormant?' do
+    it 'is true when never activated' do
+      expect(channel.dormant?).to be(true)
+    end
+
+    it 'is false immediately after deepen!' do
+      channel.deepen!(0.1)
+      expect(channel.dormant?).to be(false)
+    end
+  end
+
+  describe '#active?' do
+    it 'is false when never activated' do
+      expect(channel.active?).to be(false)
+    end
+
+    it 'is true immediately after deepen!' do
+      channel.deepen!(0.1)
+      expect(channel.active?).to be(true)
+    end
+  end
+
+  describe '#depth_label' do
+    it 'returns :surface_scratch for fresh channel' do
+      expect(channel.depth_label).to eq(:surface_scratch)
+    end
+
+    it 'returns :canyon for deeply carved channel' do
+      ch = described_class.new(formation_id: formation_id, agent: :water, depth: 0.95)
+      expect(ch.depth_label).to eq(:canyon)
+    end
+
+    it 'returns :carved_channel at mid depth' do
+      ch = described_class.new(formation_id: formation_id, agent: :ice, depth: 0.4)
+      expect(ch.depth_label).to eq(:carved_channel)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all required keys' do
+      h = channel.to_h
+      expect(h).to include(
+        :channel_id, :formation_id, :agent, :depth, :width,
+        :flow_rate, :depth_label, :dormant, :active, :created_at,
+        :updated_at, :last_active_at
+      )
+    end
+
+    it 'reflects current depth after deepen!' do
+      channel.deepen!(0.4)
+      expect(channel.to_h[:depth]).to be > 0.0
+    end
+
+    it 'reflects active state after deepen!' do
+      channel.deepen!(0.1)
+      expect(channel.to_h[:active]).to be(true)
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Erosion::Helpers::Constants do
+  describe 'MATERIAL_TYPES' do
+    it 'includes granite' do
+      expect(described_class::MATERIAL_TYPES).to include(:granite)
+    end
+
+    it 'includes sandstone' do
+      expect(described_class::MATERIAL_TYPES).to include(:sandstone)
+    end
+
+    it 'includes limestone' do
+      expect(described_class::MATERIAL_TYPES).to include(:limestone)
+    end
+
+    it 'includes chalk' do
+      expect(described_class::MATERIAL_TYPES).to include(:chalk)
+    end
+
+    it 'includes clay' do
+      expect(described_class::MATERIAL_TYPES).to include(:clay)
+    end
+
+    it 'is frozen' do
+      expect(described_class::MATERIAL_TYPES).to be_frozen
+    end
+
+    it 'has 5 material types' do
+      expect(described_class::MATERIAL_TYPES.size).to eq(5)
+    end
+  end
+
+  describe 'EROSION_AGENTS' do
+    it 'includes water' do
+      expect(described_class::EROSION_AGENTS).to include(:water)
+    end
+
+    it 'includes wind' do
+      expect(described_class::EROSION_AGENTS).to include(:wind)
+    end
+
+    it 'includes ice' do
+      expect(described_class::EROSION_AGENTS).to include(:ice)
+    end
+
+    it 'includes pressure' do
+      expect(described_class::EROSION_AGENTS).to include(:pressure)
+    end
+
+    it 'includes chemical' do
+      expect(described_class::EROSION_AGENTS).to include(:chemical)
+    end
+
+    it 'is frozen' do
+      expect(described_class::EROSION_AGENTS).to be_frozen
+    end
+
+    it 'has 5 agents' do
+      expect(described_class::EROSION_AGENTS.size).to eq(5)
+    end
+  end
+
+  describe 'RESISTANCE' do
+    it 'granite has highest resistance' do
+      expect(described_class::RESISTANCE[:granite]).to eq(0.9)
+    end
+
+    it 'clay has lowest resistance' do
+      expect(described_class::RESISTANCE[:clay]).to eq(0.1)
+    end
+
+    it 'sandstone resistance is between granite and limestone' do
+      expect(described_class::RESISTANCE[:sandstone]).to be_between(
+        described_class::RESISTANCE[:limestone],
+        described_class::RESISTANCE[:granite]
+      )
+    end
+
+    it 'chalk has lower resistance than limestone' do
+      expect(described_class::RESISTANCE[:chalk]).to be < described_class::RESISTANCE[:limestone]
+    end
+
+    it 'covers all material types' do
+      described_class::MATERIAL_TYPES.each do |mat|
+        expect(described_class::RESISTANCE).to have_key(mat)
+      end
+    end
+  end
+
+  describe 'MAX_FORMATIONS' do
+    it 'is 200' do
+      expect(described_class::MAX_FORMATIONS).to eq(200)
+    end
+  end
+
+  describe 'CHANNEL_DEPTH_LABELS' do
+    it 'labels depth 0.0 as surface_scratch' do
+      label = described_class::CHANNEL_DEPTH_LABELS.find { |range, _| range.cover?(0.0) }&.last
+      expect(label).to eq(:surface_scratch)
+    end
+
+    it 'labels depth 0.95 as canyon' do
+      label = described_class::CHANNEL_DEPTH_LABELS.find { |range, _| range.cover?(0.95) }&.last
+      expect(label).to eq(:canyon)
+    end
+
+    it 'labels depth 0.4 as carved_channel' do
+      label = described_class::CHANNEL_DEPTH_LABELS.find { |range, _| range.cover?(0.4) }&.last
+      expect(label).to eq(:carved_channel)
+    end
+
+    it 'covers the full 0.0-1.0 range' do
+      [0.0, 0.15, 0.35, 0.55, 0.75, 0.95, 1.0].each do |val|
+        found = described_class::CHANNEL_DEPTH_LABELS.any? { |range, _| range.cover?(val) }
+        expect(found).to be(true), "no label covers depth #{val}"
+      end
+    end
+  end
+
+  describe 'FORMATION_LABELS' do
+    it 'labels integrity 1.0 as pristine' do
+      label = described_class::FORMATION_LABELS.find { |range, _| range.cover?(1.0) }&.last
+      expect(label).to eq(:pristine)
+    end
+
+    it 'labels integrity 0.0 as ruins' do
+      label = described_class::FORMATION_LABELS.find { |range, _| range.cover?(0.0) }&.last
+      expect(label).to eq(:ruins)
+    end
+
+    it 'labels integrity 0.55 as weathered' do
+      label = described_class::FORMATION_LABELS.find { |range, _| range.cover?(0.55) }&.last
+      expect(label).to eq(:weathered)
+    end
+  end
+end