lex-agentic-defense 0.1.0

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

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Erosion::Helpers::ErosionEngine do
+  let(:engine) { described_class.new }
+
+  let(:limestone_id) do
+    result = engine.create_formation(material_type: :limestone, domain: 'politics', content: 'taxes are necessary')
+    result[:formation_id]
+  end
+
+  let(:clay_id) do
+    result = engine.create_formation(material_type: :clay, domain: 'taste', content: 'pineapple on pizza is wrong')
+    result[:formation_id]
+  end
+
+  describe '#create_formation' do
+    it 'returns success: true' do
+      result = engine.create_formation(material_type: :granite, domain: 'science', content: 'gravity exists')
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns formation_id' do
+      result = engine.create_formation(material_type: :sandstone, domain: 'd', content: 'c')
+      expect(result[:formation_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns formation hash' do
+      result = engine.create_formation(material_type: :chalk, domain: 'd', content: 'c')
+      expect(result[:formation]).to include(:formation_id, :material_type, :integrity)
+    end
+
+    it 'tracks formation_count' do
+      engine.create_formation(material_type: :limestone, domain: 'd', content: 'c')
+      expect(engine.formation_count).to eq(1)
+    end
+
+    it 'returns error for invalid material_type' do
+      result = engine.create_formation(material_type: :marble, domain: 'd', content: 'c')
+      expect(result[:success]).to be(false)
+    end
+
+    it 'returns error when MAX_FORMATIONS is reached' do
+      stub_const('Legion::Extensions::Agentic::Defense::Erosion::Helpers::Constants::MAX_FORMATIONS', 2)
+      engine.create_formation(material_type: :chalk, domain: 'd', content: 'c')
+      engine.create_formation(material_type: :clay, domain: 'd2', content: 'c2')
+      result = engine.create_formation(material_type: :granite, domain: 'd3', content: 'c3')
+      expect(result[:success]).to be(false)
+    end
+  end
+
+  describe '#erode' do
+    it 'returns success: true for valid erosion' do
+      id = limestone_id
+      result = engine.erode(formation_id: id, agent: :water, force: 0.3)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns erosion details' do
+      id = limestone_id
+      result = engine.erode(formation_id: id, agent: :water, force: 0.3)
+      expect(result[:erosion]).to include(:effective_force, :integrity)
+    end
+
+    it 'returns channel details' do
+      id = limestone_id
+      result = engine.erode(formation_id: id, agent: :water, force: 0.3)
+      expect(result[:channel]).to include(:depth, :agent)
+    end
+
+    it 'returns formation_not_found for unknown id' do
+      result = engine.erode(formation_id: 'nope', agent: :water, force: 0.3)
+      expect(result[:error]).to eq(:formation_not_found)
+    end
+
+    it 'returns invalid_agent for bad agent' do
+      id = limestone_id
+      result = engine.erode(formation_id: id, agent: :laser, force: 0.3)
+      expect(result[:error]).to eq(:invalid_agent)
+    end
+
+    it 'creates a channel on first erosion' do
+      id = limestone_id
+      engine.erode(formation_id: id, agent: :wind, force: 0.2)
+      expect(engine.channel_count).to be >= 1
+    end
+
+    it 'deepens existing channel on repeated erosion' do
+      id = limestone_id
+      engine.erode(formation_id: id, agent: :water, force: 0.2)
+      result1 = engine.erode(formation_id: id, agent: :water, force: 0.2)
+      result2 = engine.erode(formation_id: id, agent: :water, force: 0.2)
+      expect(result2[:channel][:depth]).to be >= result1[:channel][:depth]
+    end
+
+    it 'does not create duplicate channels for same agent' do
+      id = limestone_id
+      3.times { engine.erode(formation_id: id, agent: :water, force: 0.1) }
+      expect(engine.channel_count).to eq(1)
+    end
+  end
+
+  describe '#carve_channel' do
+    it 'creates a new channel' do
+      id = limestone_id
+      engine.carve_channel(formation_id: id, agent: :ice, force: 0.3)
+      expect(engine.channel_count).to be >= 1
+    end
+
+    it 'returns channel hash' do
+      id = limestone_id
+      result = engine.carve_channel(formation_id: id, agent: :wind)
+      expect(result).to include(:channel_id, :depth, :agent)
+    end
+
+    it 'reuses existing channel for same agent' do
+      id = limestone_id
+      engine.carve_channel(formation_id: id, agent: :water)
+      engine.carve_channel(formation_id: id, agent: :water)
+      expect(engine.channel_count).to eq(1)
+    end
+
+    it 'widens channel when depth >= 0.3' do
+      id = clay_id
+      engine.carve_channel(formation_id: id, agent: :water, force: 0.5)
+      engine.carve_channel(formation_id: id, agent: :water, force: 0.5)
+      result = engine.carve_channel(formation_id: id, agent: :water, force: 0.5)
+      expect(result[:width]).to be > 0.1
+    end
+  end
+
+  describe '#weather_all!' do
+    it 'weathers all formations' do
+      3.times { |i| engine.create_formation(material_type: :chalk, domain: "d#{i}", content: "c#{i}") }
+      result = engine.weather_all!
+      expect(result[:weathered]).to eq(3)
+    end
+
+    it 'returns success: true' do
+      engine.create_formation(material_type: :limestone, domain: 'd', content: 'c')
+      result = engine.weather_all!
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns empty results when no formations' do
+      result = engine.weather_all!
+      expect(result[:weathered]).to eq(0)
+    end
+
+    it 'reduces integrity of formations' do
+      id = limestone_id
+      before = engine.get_formation(id)[:formation][:integrity]
+      engine.weather_all!(force: 0.5, agent: :wind)
+      after = engine.get_formation(id)[:formation][:integrity]
+      expect(after).to be < before
+    end
+  end
+
+  describe '#deepest_channels' do
+    before do
+      id1 = engine.create_formation(material_type: :clay, domain: 'd1', content: 'c1')[:formation_id]
+      id2 = engine.create_formation(material_type: :chalk, domain: 'd2', content: 'c2')[:formation_id]
+      3.times { engine.erode(formation_id: id1, agent: :water, force: 0.4) }
+      engine.erode(formation_id: id2, agent: :wind, force: 0.1)
+    end
+
+    it 'returns channels sorted deepest first' do
+      channels = engine.deepest_channels(limit: 5)
+      depths = channels.map { |c| c[:depth] }
+      expect(depths).to eq(depths.sort.reverse)
+    end
+
+    it 'respects limit' do
+      channels = engine.deepest_channels(limit: 1)
+      expect(channels.size).to eq(1)
+    end
+
+    it 'returns channel hashes' do
+      channels = engine.deepest_channels
+      expect(channels.first).to include(:depth, :agent, :formation_id)
+    end
+  end
+
+  describe '#most_eroded' do
+    before do
+      id1 = engine.create_formation(material_type: :clay, domain: 'd1', content: 'c1')[:formation_id]
+      id2 = engine.create_formation(material_type: :granite, domain: 'd2', content: 'c2')[:formation_id]
+      5.times { engine.erode(formation_id: id1, agent: :water, force: 0.5) }
+      engine.erode(formation_id: id2, agent: :water, force: 0.1)
+    end
+
+    it 'returns formations sorted by erosion_depth descending' do
+      formations = engine.most_eroded(limit: 5)
+      depths = formations.map { |f| f[:erosion_depth] }
+      expect(depths).to eq(depths.sort.reverse)
+    end
+
+    it 'respects limit' do
+      formations = engine.most_eroded(limit: 1)
+      expect(formations.size).to eq(1)
+    end
+  end
+
+  describe '#erosion_report' do
+    it 'returns success: true' do
+      result = engine.erosion_report
+      expect(result[:success]).to be(true)
+    end
+
+    it 'includes total_formations count' do
+      engine.create_formation(material_type: :limestone, domain: 'd', content: 'c')
+      result = engine.erosion_report
+      expect(result[:total_formations]).to eq(1)
+    end
+
+    it 'includes total_channels count' do
+      id = limestone_id
+      engine.erode(formation_id: id, agent: :water, force: 0.2)
+      result = engine.erosion_report
+      expect(result[:total_channels]).to be >= 1
+    end
+
+    it 'counts canyons correctly' do
+      id = clay_id
+      10.times { engine.erode(formation_id: id, agent: :water, force: 1.0) }
+      result = engine.erosion_report
+      expect(result[:canyons]).to be >= 1
+    end
+
+    it 'includes average_depth' do
+      result = engine.erosion_report
+      expect(result).to have_key(:average_depth)
+    end
+
+    it 'reports average_depth 0.0 with no formations' do
+      result = engine.erosion_report
+      expect(result[:average_depth]).to eq(0.0)
+    end
+
+    it 'includes deepest_channels and most_eroded' do
+      result = engine.erosion_report
+      expect(result).to include(:deepest_channels, :most_eroded)
+    end
+  end
+
+  describe '#get_formation' do
+    it 'returns found: true for existing formation' do
+      id = limestone_id
+      result = engine.get_formation(id)
+      expect(result[:found]).to be(true)
+    end
+
+    it 'returns formation hash' do
+      id = limestone_id
+      result = engine.get_formation(id)
+      expect(result[:formation]).to include(:formation_id, :material_type)
+    end
+
+    it 'returns found: false for unknown id' do
+      result = engine.get_formation('nonexistent')
+      expect(result[:found]).to be(false)
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Erosion::Helpers::Formation do
+  let(:formation) { described_class.new(material_type: :limestone, domain: 'politics', content: 'taxes are bad') }
+  let(:granite_formation) { described_class.new(material_type: :granite, domain: 'science', content: 'gravity is real') }
+  let(:clay_formation) { described_class.new(material_type: :clay, domain: 'taste', content: 'chocolate is best') }
+
+  describe '#initialize' do
+    it 'assigns a UUID formation_id' do
+      expect(formation.formation_id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets material_type' do
+      expect(formation.material_type).to eq(:limestone)
+    end
+
+    it 'sets domain' do
+      expect(formation.domain).to eq('politics')
+    end
+
+    it 'sets content' do
+      expect(formation.content).to eq('taxes are bad')
+    end
+
+    it 'sets resistance from constants by default' do
+      expect(formation.resistance).to eq(
+        Legion::Extensions::Agentic::Defense::Erosion::Helpers::Constants::RESISTANCE[:limestone]
+      )
+    end
+
+    it 'accepts an explicit resistance override' do
+      f = described_class.new(material_type: :chalk, domain: 'd', content: 'c', resistance: 0.75)
+      expect(f.resistance).to eq(0.75)
+    end
+
+    it 'starts with integrity 1.0' do
+      expect(formation.integrity).to eq(1.0)
+    end
+
+    it 'starts with erosion_depth 0.0' do
+      expect(formation.erosion_depth).to eq(0.0)
+    end
+
+    it 'raises ArgumentError for invalid material_type' do
+      expect do
+        described_class.new(material_type: :diamond, domain: 'd', content: 'c')
+      end.to raise_error(ArgumentError, /invalid material_type/)
+    end
+  end
+
+  describe '#erode!' do
+    it 'reduces integrity' do
+      before_integrity = formation.integrity
+      formation.erode!(:water, 0.5)
+      expect(formation.integrity).to be < before_integrity
+    end
+
+    it 'increases erosion_depth' do
+      formation.erode!(:water, 0.5)
+      expect(formation.erosion_depth).to be > 0.0
+    end
+
+    it 'returns a result hash with effective_force' do
+      result = formation.erode!(:wind, 0.3)
+      expect(result).to include(:agent, :force, :effective_force, :integrity, :erosion_depth)
+    end
+
+    it 'clamps force to 1.0 max' do
+      result = formation.erode!(:water, 5.0)
+      expect(result[:force]).to eq(1.0)
+    end
+
+    it 'clamps force to 0.0 min' do
+      result = formation.erode!(:water, -1.0)
+      expect(result[:force]).to eq(0.0)
+    end
+
+    it 'granite resists more than clay' do
+      granite_result = granite_formation.erode!(:water, 0.5)
+      clay_result    = clay_formation.erode!(:water, 0.5)
+      expect(granite_result[:effective_force]).to be < clay_result[:effective_force]
+    end
+
+    it 'raises ArgumentError for invalid agent' do
+      expect { formation.erode!(:laser, 0.5) }.to raise_error(ArgumentError, /invalid agent/)
+    end
+
+    it 'does not reduce integrity below 0.0' do
+      10.times { formation.erode!(:chemical, 1.0) }
+      expect(formation.integrity).to be >= 0.0
+    end
+
+    it 'does not increase erosion_depth above 1.0' do
+      10.times { formation.erode!(:chemical, 1.0) }
+      expect(formation.erosion_depth).to be <= 1.0
+    end
+
+    it 'updates updated_at' do
+      original = formation.updated_at
+      sleep(0.001)
+      formation.erode!(:water, 0.1)
+      expect(formation.updated_at).to be >= original
+    end
+  end
+
+  describe '#resist!' do
+    it 'increases integrity' do
+      formation.erode!(:water, 0.5)
+      before = formation.integrity
+      formation.resist!
+      expect(formation.integrity).to be > before
+    end
+
+    it 'accepts a custom recovery amount' do
+      formation.erode!(:water, 0.5)
+      before = formation.integrity
+      formation.resist!(0.2)
+      expect(formation.integrity).to be_within(0.001).of(before + 0.2)
+    end
+
+    it 'clamps integrity to 1.0' do
+      formation.resist!(2.0)
+      expect(formation.integrity).to eq(1.0)
+    end
+
+    it 'returns a hash with integrity and recovered' do
+      result = formation.resist!
+      expect(result).to include(:integrity, :recovered)
+    end
+  end
+
+  describe '#weathered?' do
+    it 'returns false for pristine formation' do
+      expect(formation.weathered?).to be(false)
+    end
+
+    it 'returns true after significant erosion' do
+      formation.erode!(:chemical, 1.0)
+      formation.erode!(:chemical, 1.0)
+      formation.erode!(:chemical, 1.0)
+      expect(formation.weathered?).to be(true)
+    end
+  end
+
+  describe '#canyon?' do
+    it 'returns false for fresh formation' do
+      expect(formation.canyon?).to be(false)
+    end
+
+    it 'returns true when erosion_depth >= 0.7' do
+      10.times { clay_formation.erode!(:water, 1.0) }
+      expect(clay_formation.canyon?).to be(true)
+    end
+  end
+
+  describe '#pristine?' do
+    it 'returns true for new formation' do
+      expect(formation.pristine?).to be(true)
+    end
+
+    it 'returns false after erosion reduces integrity below 0.9' do
+      formation.erode!(:chemical, 1.0)
+      expect(formation.pristine?).to be(false)
+    end
+  end
+
+  describe '#integrity_label' do
+    it 'returns :pristine for new formation' do
+      expect(formation.integrity_label).to eq(:pristine)
+    end
+
+    it 'returns :ruins for fully eroded formation' do
+      10.times { clay_formation.erode!(:chemical, 1.0) }
+      expect(clay_formation.integrity_label).to eq(:ruins)
+    end
+  end
+
+  describe '#depth_label' do
+    it 'returns :surface_scratch for new formation' do
+      expect(formation.depth_label).to eq(:surface_scratch)
+    end
+
+    it 'returns :canyon for deeply eroded clay' do
+      10.times { clay_formation.erode!(:water, 1.0) }
+      expect(clay_formation.depth_label).to eq(:canyon)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all required keys' do
+      h = formation.to_h
+      expect(h).to include(
+        :formation_id, :material_type, :domain, :content, :resistance,
+        :integrity, :erosion_depth, :integrity_label, :depth_label,
+        :weathered, :canyon, :pristine, :created_at, :updated_at
+      )
+    end
+
+    it 'reflects current state' do
+      formation.erode!(:water, 0.3)
+      h = formation.to_h
+      expect(h[:integrity]).to be < 1.0
+      expect(h[:erosion_depth]).to be > 0.0
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/erosion/runners/cognitive_erosion_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Erosion::Runners::CognitiveErosion do
+  let(:engine) { Legion::Extensions::Agentic::Defense::Erosion::Helpers::ErosionEngine.new }
+
+  let(:formation_id) do
+    described_class.create_formation(
+      material_type: :limestone, domain: 'economy', content: 'growth is always good', engine: engine
+    )[:formation_id]
+  end
+
+  describe '.create_formation' do
+    it 'returns success: true' do
+      result = described_class.create_formation(
+        material_type: :granite, domain: 'science', content: 'vaccines work', engine: engine
+      )
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns formation_id' do
+      result = described_class.create_formation(
+        material_type: :chalk, domain: 'culture', content: 'tradition matters', engine: engine
+      )
+      expect(result[:formation_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns failure for invalid material_type' do
+      result = described_class.create_formation(
+        material_type: :diamond, domain: 'd', content: 'c', engine: engine
+      )
+      expect(result[:success]).to be(false)
+    end
+  end
+
+  describe '.erode' do
+    it 'returns success: true' do
+      id = formation_id
+      result = described_class.erode(formation_id: id, agent: :water, force: 0.3, engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns erosion details' do
+      id = formation_id
+      result = described_class.erode(formation_id: id, agent: :wind, force: 0.2, engine: engine)
+      expect(result[:erosion]).to include(:effective_force)
+    end
+
+    it 'returns failure for unknown formation' do
+      result = described_class.erode(formation_id: 'nope', agent: :water, force: 0.3, engine: engine)
+      expect(result[:success]).to be(false)
+    end
+
+    it 'returns failure for invalid agent' do
+      id = formation_id
+      result = described_class.erode(formation_id: id, agent: :laser, force: 0.3, engine: engine)
+      expect(result[:success]).to be(false)
+    end
+  end
+
+  describe '.weather_all' do
+    it 'returns success: true' do
+      result = described_class.weather_all(engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'weathers all formations' do
+      described_class.create_formation(material_type: :chalk, domain: 'd1', content: 'c1', engine: engine)
+      described_class.create_formation(material_type: :clay, domain: 'd2', content: 'c2', engine: engine)
+      result = described_class.weather_all(engine: engine)
+      expect(result[:weathered]).to eq(2)
+    end
+
+    it 'accepts custom force and agent' do
+      described_class.create_formation(material_type: :sandstone, domain: 'd', content: 'c', engine: engine)
+      result = described_class.weather_all(force: 0.3, agent: :ice, engine: engine)
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '.deepest_channels' do
+    it 'returns success: true' do
+      result = described_class.deepest_channels(engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns channels array' do
+      result = described_class.deepest_channels(engine: engine)
+      expect(result[:channels]).to be_an(Array)
+    end
+
+    it 'includes count' do
+      result = described_class.deepest_channels(engine: engine)
+      expect(result).to have_key(:count)
+    end
+
+    it 'returns populated channels after erosion' do
+      id = formation_id
+      described_class.erode(formation_id: id, agent: :water, force: 0.4, engine: engine)
+      result = described_class.deepest_channels(limit: 5, engine: engine)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '.most_eroded' do
+    it 'returns success: true' do
+      result = described_class.most_eroded(engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns formations array' do
+      result = described_class.most_eroded(engine: engine)
+      expect(result[:formations]).to be_an(Array)
+    end
+
+    it 'returns populated formations after erosion' do
+      id = formation_id
+      3.times { described_class.erode(formation_id: id, agent: :water, force: 0.5, engine: engine) }
+      result = described_class.most_eroded(limit: 5, engine: engine)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '.erosion_report' do
+    it 'returns success: true' do
+      result = described_class.erosion_report(engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'includes formation and channel counts' do
+      result = described_class.erosion_report(engine: engine)
+      expect(result).to include(:total_formations, :total_channels, :canyons, :weathered)
+    end
+
+    it 'reflects formations created' do
+      described_class.create_formation(material_type: :limestone, domain: 'd', content: 'c', engine: engine)
+      result = described_class.erosion_report(engine: engine)
+      expect(result[:total_formations]).to be >= 1
+    end
+  end
+
+  describe '.get_formation' do
+    it 'returns found: true for existing formation' do
+      id = formation_id
+      result = described_class.get_formation(formation_id: id, engine: engine)
+      expect(result[:found]).to be(true)
+    end
+
+    it 'returns found: false for unknown id' do
+      result = described_class.get_formation(formation_id: 'ghost', engine: engine)
+      expect(result[:found]).to be(false)
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ErrorMonitoring::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes Runners::ErrorMonitoring' do
+    expect(described_class.ancestors).to include(Legion::Extensions::Agentic::Defense::ErrorMonitoring::Runners::ErrorMonitoring)
+  end
+
+  it 'supports full error monitoring lifecycle' do
+    # Normal operation with some successes
+    3.times { client.report_success(action: :process, domain: :data) }
+
+    # Error occurs
+    client.report_error(action: :api_call, domain: :network, intended: :ok, actual: :timeout, severity: 0.6)
+
+    # System should now be vigilant with slowdown
+    state = client.monitoring_state
+    expect(state[:slowdown]).to be > 0
+
+    # Conflict detected
+    client.report_conflict(action_a: :retry, action_b: :abort, domain: :network, intensity: 0.7)
+
+    # Correction applied
+    client.apply_correction(action: :api_call, domain: :network, original_error: :timeout,
+                            correction: :retry_with_backoff)
+
+    # Verify correction
+    uncorrected = client.uncorrected_errors
+    expect(uncorrected[:count]).to eq(0)
+
+    # Tick to decay slowdown
+    client.update_error_monitoring
+
+    # Stats
+    stats = client.error_monitoring_stats
+    expect(stats[:stats][:total_errors]).to eq(1)
+    expect(stats[:stats][:correction_rate]).to eq(1.0)
+  end
+end