lex-agentic-defense 0.1.0

data/spec/legion/extensions/agentic/defense/error_monitoring/helpers/error_monitor_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ErrorMonitoring::Helpers::ErrorMonitor do
+  subject(:monitor) { described_class.new }
+
+  let(:constants) { Legion::Extensions::Agentic::Defense::ErrorMonitoring::Helpers::Constants }
+
+  describe '#register_error' do
+    it 'creates an error signal' do
+      signal = monitor.register_error(action: :parse, domain: :data, intended: :valid, actual: :malformed,
+                                      severity: 0.5)
+      expect(signal).to be_a(Legion::Extensions::Agentic::Defense::ErrorMonitoring::Helpers::ErrorSignal)
+      expect(monitor.error_count).to eq(1)
+    end
+
+    it 'increases error rate' do
+      before = monitor.error_rate
+      monitor.register_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.8)
+      expect(monitor.error_rate).to be > before
+    end
+
+    it 'applies post-error slowdown' do
+      monitor.register_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.8)
+      expect(monitor.slowdown).to be > 0
+    end
+
+    it 'decreases confidence' do
+      before = monitor.confidence
+      monitor.register_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.5)
+      expect(monitor.confidence).to be < before
+    end
+
+    it 'limits error log size' do
+      (constants::MAX_ERROR_LOG + 10).times do |i|
+        monitor.register_error(action: :"a_#{i}", domain: :d, intended: :i, actual: :a, severity: 0.3)
+      end
+      expect(monitor.error_count).to eq(constants::MAX_ERROR_LOG)
+    end
+  end
+
+  describe '#register_success' do
+    it 'decreases error rate' do
+      monitor.register_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.8)
+      before = monitor.error_rate
+      monitor.register_success(action: :b, domain: :d)
+      expect(monitor.error_rate).to be < before
+    end
+
+    it 'increases confidence' do
+      monitor.register_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.5)
+      before = monitor.confidence
+      monitor.register_success(action: :b, domain: :d)
+      expect(monitor.confidence).to be > before
+    end
+  end
+
+  describe '#register_conflict' do
+    it 'records a conflict' do
+      entry = monitor.register_conflict(action_a: :run, action_b: :hide, domain: :safety, intensity: 0.8)
+      expect(entry[:action_a]).to eq(:run)
+      expect(entry[:intensity]).to eq(0.8)
+    end
+
+    it 'increases conflict level' do
+      monitor.register_conflict(action_a: :a, action_b: :b, domain: :d, intensity: 0.9)
+      expect(monitor.conflict_level).to be > 0
+    end
+  end
+
+  describe '#register_correction' do
+    it 'records a correction' do
+      monitor.register_error(action: :parse, domain: :data, intended: :valid, actual: :malformed, severity: 0.5)
+      entry = monitor.register_correction(action: :parse, domain: :data, original_error: :malformed, correction: :retry)
+      expect(entry[:correction]).to eq(:retry)
+    end
+
+    it 'marks the error as corrected' do
+      monitor.register_error(action: :parse, domain: :data, intended: :valid, actual: :malformed, severity: 0.5)
+      monitor.register_correction(action: :parse, domain: :data, original_error: :malformed, correction: :retry)
+      expect(monitor.uncorrected_errors).to be_empty
+    end
+
+    it 'boosts confidence' do
+      monitor.register_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.5)
+      before = monitor.confidence
+      monitor.register_correction(action: :a, domain: :d, original_error: :a, correction: :fix)
+      expect(monitor.confidence).to be > before
+    end
+  end
+
+  describe '#recent_errors' do
+    it 'returns recent errors' do
+      3.times { |i| monitor.register_error(action: :"a_#{i}", domain: :d, intended: :i, actual: :a, severity: 0.3) }
+      expect(monitor.recent_errors(limit: 2).size).to eq(2)
+    end
+  end
+
+  describe '#errors_in' do
+    it 'filters by domain' do
+      monitor.register_error(action: :a, domain: :network, intended: :i, actual: :a, severity: 0.3)
+      monitor.register_error(action: :b, domain: :data, intended: :i, actual: :a, severity: 0.3)
+      expect(monitor.errors_in(domain: :network).size).to eq(1)
+    end
+  end
+
+  describe '#uncorrected_errors' do
+    it 'returns only uncorrected errors' do
+      monitor.register_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.3)
+      monitor.register_error(action: :b, domain: :d, intended: :i, actual: :a, severity: 0.3)
+      monitor.register_correction(action: :a, domain: :d, original_error: :a, correction: :fix)
+      expect(monitor.uncorrected_errors.size).to eq(1)
+    end
+  end
+
+  describe '#conflict_active?' do
+    it 'returns false initially' do
+      expect(monitor.conflict_active?).to be false
+    end
+
+    it 'returns true after sustained high-intensity conflict' do
+      20.times { monitor.register_conflict(action_a: :a, action_b: :b, domain: :d, intensity: 0.9) }
+      expect(monitor.conflict_active?).to be true
+    end
+  end
+
+  describe '#monitoring_state' do
+    it 'returns :normal initially' do
+      expect(monitor.monitoring_state).to eq(:normal)
+    end
+
+    it 'returns :vigilant after errors (slowdown active)' do
+      monitor.register_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.8)
+      expect(monitor.monitoring_state).to eq(:vigilant)
+    end
+
+    it 'returns :relaxed after many successes' do
+      50.times { monitor.register_success(action: :a, domain: :d) }
+      expect(monitor.monitoring_state).to eq(:relaxed)
+    end
+  end
+
+  describe '#tick' do
+    it 'decays slowdown' do
+      monitor.register_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.8)
+      before = monitor.slowdown
+      monitor.tick
+      expect(monitor.slowdown).to be < before
+    end
+
+    it 'decays conflict level' do
+      monitor.register_conflict(action_a: :a, action_b: :b, domain: :d, intensity: 0.9)
+      before = monitor.conflict_level
+      monitor.tick
+      expect(monitor.conflict_level).to be < before
+    end
+  end
+
+  describe '#correction_rate' do
+    it 'returns 0 with no errors' do
+      expect(monitor.correction_rate).to eq(0.0)
+    end
+
+    it 'returns ratio of corrected to total' do
+      monitor.register_error(action: :first, domain: :d, intended: :i, actual: :a, severity: 0.3)
+      monitor.register_error(action: :second, domain: :d, intended: :i, actual: :a, severity: 0.3)
+      monitor.register_correction(action: :first, domain: :d, original_error: :a, correction: :fix)
+      expect(monitor.correction_rate).to eq(0.5)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash' do
+      h = monitor.to_h
+      expect(h).to include(:error_rate, :conflict_level, :confidence, :slowdown, :state,
+                           :state_label, :total_errors, :uncorrected, :correction_rate, :conflict_active)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/error_monitoring/helpers/error_signal_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ErrorMonitoring::Helpers::ErrorSignal do
+  subject(:signal) do
+    described_class.new(action: :api_call, domain: :network, intended: :success, actual: :timeout, severity: 0.7)
+  end
+
+  let(:constants) { Legion::Extensions::Agentic::Defense::ErrorMonitoring::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'sets attributes' do
+      expect(signal.action).to eq(:api_call)
+      expect(signal.domain).to eq(:network)
+      expect(signal.intended).to eq(:success)
+      expect(signal.actual).to eq(:timeout)
+      expect(signal.severity).to eq(0.7)
+      expect(signal.corrected).to be false
+    end
+
+    it 'clamps severity' do
+      high = described_class.new(action: :a, domain: :d, intended: :i, actual: :a, severity: 1.5)
+      expect(high.severity).to eq(1.0)
+    end
+
+    it 'records detected_at' do
+      expect(signal.detected_at).to be_a(Time)
+    end
+  end
+
+  describe '#mark_corrected' do
+    it 'marks the error as corrected' do
+      signal.mark_corrected
+      expect(signal.corrected).to be true
+    end
+  end
+
+  describe '#severe?' do
+    it 'returns true for high severity' do
+      expect(signal.severe?).to be true
+    end
+
+    it 'returns false for low severity' do
+      low = described_class.new(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.3)
+      expect(low.severe?).to be false
+    end
+  end
+
+  describe '#age' do
+    it 'returns elapsed time' do
+      expect(signal.age).to be >= 0.0
+    end
+  end
+
+  describe '#label' do
+    it 'returns :major for 0.7 severity' do
+      expect(signal.label).to eq(:major)
+    end
+
+    it 'returns :trivial for low severity' do
+      low = described_class.new(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.1)
+      expect(low.label).to eq(:trivial)
+    end
+
+    it 'returns :critical for high severity' do
+      crit = described_class.new(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.9)
+      expect(crit.label).to eq(:critical)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with all fields' do
+      h = signal.to_h
+      expect(h).to include(:action, :domain, :intended, :actual, :severity, :label, :detected_at, :corrected, :age)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/error_monitoring/runners/error_monitoring_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ErrorMonitoring::Runners::ErrorMonitoring do
+  let(:client) { Legion::Extensions::Agentic::Defense::ErrorMonitoring::Client.new }
+
+  describe '#report_error' do
+    it 'registers an error' do
+      result = client.report_error(action: :api_call, domain: :network, intended: :ok, actual: :timeout, severity: 0.6)
+      expect(result[:success]).to be true
+      expect(result[:error][:action]).to eq(:api_call)
+      expect(result[:slowdown]).to be > 0
+    end
+  end
+
+  describe '#report_success' do
+    it 'registers a success' do
+      result = client.report_success(action: :api_call, domain: :network)
+      expect(result[:success]).to be true
+      expect(result[:error_rate]).to be_a(Float)
+    end
+  end
+
+  describe '#report_conflict' do
+    it 'registers a conflict' do
+      result = client.report_conflict(action_a: :run, action_b: :hide, domain: :safety, intensity: 0.7)
+      expect(result[:success]).to be true
+      expect(result[:conflict][:action_a]).to eq(:run)
+    end
+  end
+
+  describe '#apply_correction' do
+    it 'applies a correction' do
+      client.report_error(action: :parse, domain: :data, intended: :valid, actual: :bad, severity: 0.5)
+      result = client.apply_correction(action: :parse, domain: :data, original_error: :bad, correction: :retry)
+      expect(result[:success]).to be true
+      expect(result[:confidence]).to be > 0
+    end
+  end
+
+  describe '#recent_errors' do
+    it 'returns recent errors' do
+      client.report_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.3)
+      result = client.recent_errors(limit: 5)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#errors_in_domain' do
+    it 'filters errors by domain' do
+      client.report_error(action: :a, domain: :net, intended: :i, actual: :a, severity: 0.3)
+      client.report_error(action: :b, domain: :data, intended: :i, actual: :a, severity: 0.3)
+      result = client.errors_in_domain(domain: :net)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#uncorrected_errors' do
+    it 'returns uncorrected errors' do
+      client.report_error(action: :a, domain: :d, intended: :i, actual: :a, severity: 0.3)
+      result = client.uncorrected_errors
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#monitoring_state' do
+    it 'returns current state' do
+      result = client.monitoring_state
+      expect(result[:success]).to be true
+      expect(result[:state]).to be_a(Symbol)
+    end
+  end
+
+  describe '#update_error_monitoring' do
+    it 'runs tick' do
+      result = client.update_error_monitoring
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#error_monitoring_stats' do
+    it 'returns stats' do
+      result = client.error_monitoring_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:error_rate, :confidence, :state)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/extinction/actors/protocol_monitor_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every; end # rubocop:disable Lint/EmptyClass
+    end
+  end
+end
+
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require_relative '../../../../../../../lib/legion/extensions/agentic/defense/extinction/actors/protocol_monitor'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Extinction::Actor::ProtocolMonitor do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it { expect(actor.runner_class).to eq Legion::Extensions::Agentic::Defense::Extinction::Runners::Extinction }
+  end
+
+  describe '#runner_function' do
+    it { expect(actor.runner_function).to eq 'monitor_protocol' }
+  end
+
+  describe '#time' do
+    it { expect(actor.time).to eq 300 }
+  end
+
+  describe '#run_now?' do
+    it { expect(actor.run_now?).to be false }
+  end
+
+  describe '#use_runner?' do
+    it { expect(actor.use_runner?).to be false }
+  end
+
+  describe '#check_subtask?' do
+    it { expect(actor.check_subtask?).to be false }
+  end
+
+  describe '#generate_task?' do
+    it { expect(actor.generate_task?).to be false }
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/extinction/client'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Extinction::Client do
+  it 'responds to extinction runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:escalate)
+    expect(client).to respond_to(:deescalate)
+    expect(client).to respond_to(:extinction_status)
+    expect(client).to respond_to(:check_reversibility)
+  end
+end

data/spec/legion/extensions/agentic/defense/extinction/helpers/levels_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/extinction/helpers/levels'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Extinction::Helpers::Levels do
+  describe 'ESCALATION_LEVELS' do
+    it 'defines exactly four levels' do
+      expect(described_class::ESCALATION_LEVELS.size).to eq(4)
+    end
+
+    it 'is keyed by integers 1 through 4' do
+      expect(described_class::ESCALATION_LEVELS.keys).to eq([1, 2, 3, 4])
+    end
+
+    it 'is frozen' do
+      expect(described_class::ESCALATION_LEVELS).to be_frozen
+    end
+
+    it 'defines level 1 as mesh_isolation' do
+      expect(described_class::ESCALATION_LEVELS[1][:name]).to eq(:mesh_isolation)
+    end
+
+    it 'defines level 2 as forced_sentinel' do
+      expect(described_class::ESCALATION_LEVELS[2][:name]).to eq(:forced_sentinel)
+    end
+
+    it 'defines level 3 as full_suspension' do
+      expect(described_class::ESCALATION_LEVELS[3][:name]).to eq(:full_suspension)
+    end
+
+    it 'defines level 4 as cryptographic_erasure' do
+      expect(described_class::ESCALATION_LEVELS[4][:name]).to eq(:cryptographic_erasure)
+    end
+
+    it 'marks levels 1-3 as reversible' do
+      [1, 2, 3].each do |level|
+        expect(described_class::ESCALATION_LEVELS[level][:reversible]).to be true
+      end
+    end
+
+    it 'marks level 4 as not reversible' do
+      expect(described_class::ESCALATION_LEVELS[4][:reversible]).to be false
+    end
+
+    it 'assigns governance_council authority to levels 1 and 2' do
+      expect(described_class::ESCALATION_LEVELS[1][:authority]).to eq(:governance_council)
+      expect(described_class::ESCALATION_LEVELS[2][:authority]).to eq(:governance_council)
+    end
+
+    it 'assigns council_plus_executive authority to level 3' do
+      expect(described_class::ESCALATION_LEVELS[3][:authority]).to eq(:council_plus_executive)
+    end
+
+    it 'assigns physical_keyholders authority to level 4' do
+      expect(described_class::ESCALATION_LEVELS[4][:authority]).to eq(:physical_keyholders)
+    end
+  end
+
+  describe 'VALID_LEVELS' do
+    it 'contains exactly [1, 2, 3, 4]' do
+      expect(described_class::VALID_LEVELS).to eq([1, 2, 3, 4])
+    end
+
+    it 'is frozen' do
+      expect(described_class::VALID_LEVELS).to be_frozen
+    end
+  end
+
+  describe '.valid_level?' do
+    it 'returns true for level 1' do
+      expect(described_class.valid_level?(1)).to be true
+    end
+
+    it 'returns true for level 2' do
+      expect(described_class.valid_level?(2)).to be true
+    end
+
+    it 'returns true for level 3' do
+      expect(described_class.valid_level?(3)).to be true
+    end
+
+    it 'returns true for level 4' do
+      expect(described_class.valid_level?(4)).to be true
+    end
+
+    it 'returns false for level 0' do
+      expect(described_class.valid_level?(0)).to be false
+    end
+
+    it 'returns false for level 5' do
+      expect(described_class.valid_level?(5)).to be false
+    end
+
+    it 'returns false for negative levels' do
+      expect(described_class.valid_level?(-1)).to be false
+    end
+
+    it 'returns false for nil' do
+      expect(described_class.valid_level?(nil)).to be false
+    end
+
+    it 'returns false for string level' do
+      expect(described_class.valid_level?('1')).to be false
+    end
+  end
+
+  describe '.level_info' do
+    it 'returns the full info hash for a valid level' do
+      info = described_class.level_info(1)
+      expect(info).to be_a(Hash)
+      expect(info.keys).to contain_exactly(:name, :reversible, :authority)
+    end
+
+    it 'returns nil for an invalid level' do
+      expect(described_class.level_info(99)).to be_nil
+    end
+
+    it 'returns nil for level 0' do
+      expect(described_class.level_info(0)).to be_nil
+    end
+
+    [1, 2, 3, 4].each do |level|
+      it "returns a hash for level #{level}" do
+        expect(described_class.level_info(level)).to be_a(Hash)
+      end
+    end
+  end
+
+  describe '.reversible?' do
+    it 'returns true for level 1' do
+      expect(described_class.reversible?(1)).to be true
+    end
+
+    it 'returns true for level 2' do
+      expect(described_class.reversible?(2)).to be true
+    end
+
+    it 'returns true for level 3' do
+      expect(described_class.reversible?(3)).to be true
+    end
+
+    it 'returns false for level 4' do
+      expect(described_class.reversible?(4)).to be false
+    end
+
+    it 'returns false for an invalid level (fallback to false)' do
+      expect(described_class.reversible?(99)).to be false
+    end
+
+    it 'returns false for nil level' do
+      expect(described_class.reversible?(nil)).to be false
+    end
+  end
+
+  describe '.required_authority' do
+    it 'returns :governance_council for level 1' do
+      expect(described_class.required_authority(1)).to eq(:governance_council)
+    end
+
+    it 'returns :governance_council for level 2' do
+      expect(described_class.required_authority(2)).to eq(:governance_council)
+    end
+
+    it 'returns :council_plus_executive for level 3' do
+      expect(described_class.required_authority(3)).to eq(:council_plus_executive)
+    end
+
+    it 'returns :physical_keyholders for level 4' do
+      expect(described_class.required_authority(4)).to eq(:physical_keyholders)
+    end
+
+    it 'returns nil for an invalid level' do
+      expect(described_class.required_authority(0)).to be_nil
+    end
+
+    it 'returns nil for an out-of-range level' do
+      expect(described_class.required_authority(5)).to be_nil
+    end
+  end
+end