lex-extinction 0.2.0 → 0.2.2

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

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/extensions/extinction/helpers/levels'
-
-RSpec.describe Legion::Extensions::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

data/spec/legion/extensions/extinction/helpers/protocol_state_spec.rb

@@ -1,291 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/extensions/extinction/helpers/levels'
-require 'legion/extensions/extinction/helpers/protocol_state'
-
-RSpec.describe Legion::Extensions::Extinction::Helpers::ProtocolState do
-  subject(:state) { described_class.new }
-
-  describe '#initialize' do
-    it 'starts at level 0' do
-      expect(state.current_level).to eq(0)
-    end
-
-    it 'starts as inactive' do
-      expect(state.active).to be false
-    end
-
-    it 'starts with an empty history' do
-      expect(state.history).to eq([])
-    end
-  end
-
-  describe '#escalate' do
-    context 'with an invalid level' do
-      it 'returns :invalid_level for level 0' do
-        expect(state.escalate(0, authority: :governance_council, reason: 'test')).to eq(:invalid_level)
-      end
-
-      it 'returns :invalid_level for level 5' do
-        expect(state.escalate(5, authority: :governance_council, reason: 'test')).to eq(:invalid_level)
-      end
-
-      it 'does not change current_level on invalid level' do
-        state.escalate(99, authority: :governance_council, reason: 'test')
-        expect(state.current_level).to eq(0)
-      end
-
-      it 'does not add to history on invalid level' do
-        state.escalate(99, authority: :governance_council, reason: 'test')
-        expect(state.history).to be_empty
-      end
-    end
-
-    context 'when already at or above the requested level' do
-      before { state.escalate(2, authority: :governance_council, reason: 'setup') }
-
-      it 'returns :already_at_or_above for same level' do
-        expect(state.escalate(2, authority: :governance_council, reason: 'test')).to eq(:already_at_or_above)
-      end
-
-      it 'returns :already_at_or_above for lower level' do
-        expect(state.escalate(1, authority: :governance_council, reason: 'test')).to eq(:already_at_or_above)
-      end
-    end
-
-    context 'with insufficient authority' do
-      it 'returns :insufficient_authority for level 1 with wrong authority' do
-        result = state.escalate(1, authority: :physical_keyholders, reason: 'test')
-        expect(result).to eq(:insufficient_authority)
-      end
-
-      it 'returns :insufficient_authority for level 3 with governance_council' do
-        state.escalate(1, authority: :governance_council, reason: 'step1')
-        state.escalate(2, authority: :governance_council, reason: 'step2')
-        result = state.escalate(3, authority: :governance_council, reason: 'test')
-        expect(result).to eq(:insufficient_authority)
-      end
-
-      it 'returns :insufficient_authority for level 4 with governance_council' do
-        result = state.escalate(4, authority: :governance_council, reason: 'test')
-        expect(result).to eq(:insufficient_authority)
-      end
-
-      it 'does not change level on insufficient authority' do
-        state.escalate(1, authority: :physical_keyholders, reason: 'test')
-        expect(state.current_level).to eq(0)
-      end
-    end
-
-    context 'with valid escalation' do
-      it 'returns :escalated for level 1 with governance_council' do
-        expect(state.escalate(1, authority: :governance_council, reason: 'threat')).to eq(:escalated)
-      end
-
-      it 'updates current_level to 1' do
-        state.escalate(1, authority: :governance_council, reason: 'threat')
-        expect(state.current_level).to eq(1)
-      end
-
-      it 'sets active to true' do
-        state.escalate(1, authority: :governance_council, reason: 'threat')
-        expect(state.active).to be true
-      end
-
-      it 'appends an entry to history' do
-        state.escalate(1, authority: :governance_council, reason: 'threat')
-        expect(state.history.size).to eq(1)
-      end
-
-      it 'records the correct action in history' do
-        state.escalate(1, authority: :governance_council, reason: 'threat')
-        expect(state.history.last[:action]).to eq(:escalate)
-      end
-
-      it 'records the level in history' do
-        state.escalate(1, authority: :governance_council, reason: 'threat')
-        expect(state.history.last[:level]).to eq(1)
-      end
-
-      it 'records the authority in history' do
-        state.escalate(1, authority: :governance_council, reason: 'threat')
-        expect(state.history.last[:authority]).to eq(:governance_council)
-      end
-
-      it 'records the reason in history' do
-        state.escalate(1, authority: :governance_council, reason: 'threat')
-        expect(state.history.last[:reason]).to eq('threat')
-      end
-
-      it 'records a Time in history' do
-        state.escalate(1, authority: :governance_council, reason: 'threat')
-        expect(state.history.last[:at]).to be_a(Time)
-      end
-
-      it 'escalates to level 4 with physical_keyholders after reaching level 3' do
-        state.escalate(1, authority: :governance_council, reason: 's1')
-        state.escalate(2, authority: :governance_council, reason: 's2')
-        state.escalate(3, authority: :council_plus_executive, reason: 's3')
-        result = state.escalate(4, authority: :physical_keyholders, reason: 's4')
-        expect(result).to eq(:escalated)
-        expect(state.current_level).to eq(4)
-      end
-
-      it 'accumulates history across multiple escalations' do
-        state.escalate(1, authority: :governance_council, reason: 'r1')
-        state.escalate(2, authority: :governance_council, reason: 'r2')
-        expect(state.history.size).to eq(2)
-      end
-
-      it 'calls save_to_local after escalation' do
-        expect(state).to receive(:save_to_local)
-        state.escalate(1, authority: :governance_council, reason: 'test')
-      end
-
-      it 'trims history beyond MAX_HISTORY' do
-        s = described_class.new
-        s.instance_variable_set(:@history, Array.new(510) { { action: :escalate, at: Time.now } })
-        s.send(:trim_history)
-        expect(s.history.size).to eq(500)
-      end
-    end
-  end
-
-  describe '#deescalate' do
-    context 'when protocol is not active' do
-      it 'returns :not_active' do
-        expect(state.deescalate(0, authority: :governance_council, reason: 'test')).to eq(:not_active)
-      end
-    end
-
-    context 'when target_level is invalid (not lower than current)' do
-      before { state.escalate(2, authority: :governance_council, reason: 'setup') }
-
-      it 'returns :invalid_target when target equals current' do
-        result = state.deescalate(2, authority: :governance_council, reason: 'test')
-        expect(result).to eq(:invalid_target)
-      end
-
-      it 'returns :invalid_target when target is above current' do
-        result = state.deescalate(3, authority: :governance_council, reason: 'test')
-        expect(result).to eq(:invalid_target)
-      end
-    end
-
-    context 'when current level is irreversible (level 4)' do
-      before do
-        state.escalate(1, authority: :governance_council, reason: 's1')
-        state.escalate(2, authority: :governance_council, reason: 's2')
-        state.escalate(3, authority: :council_plus_executive, reason: 's3')
-        state.escalate(4, authority: :physical_keyholders, reason: 's4')
-      end
-
-      it 'returns :irreversible' do
-        result = state.deescalate(0, authority: :physical_keyholders, reason: 'try')
-        expect(result).to eq(:irreversible)
-      end
-
-      it 'does not change current_level' do
-        state.deescalate(0, authority: :physical_keyholders, reason: 'try')
-        expect(state.current_level).to eq(4)
-      end
-    end
-
-    context 'with insufficient authority for deescalation' do
-      before do
-        state.escalate(1, authority: :governance_council, reason: 's1')
-        state.escalate(2, authority: :governance_council, reason: 's2')
-        state.escalate(3, authority: :council_plus_executive, reason: 's3')
-      end
-
-      it 'rejects wrong authority for level 3' do
-        result = state.deescalate(0, authority: :governance_council, reason: 'test')
-        expect(result).to eq(:insufficient_authority)
-      end
-
-      it 'accepts correct authority for level 3' do
-        result = state.deescalate(0, authority: :council_plus_executive, reason: 'test')
-        expect(result).to eq(:deescalated)
-      end
-    end
-
-    context 'with valid de-escalation' do
-      before { state.escalate(2, authority: :governance_council, reason: 'setup') }
-
-      it 'returns :deescalated' do
-        result = state.deescalate(1, authority: :governance_council, reason: 'resolved')
-        expect(result).to eq(:deescalated)
-      end
-
-      it 'updates current_level to the target' do
-        state.deescalate(1, authority: :governance_council, reason: 'resolved')
-        expect(state.current_level).to eq(1)
-      end
-
-      it 'remains active when target_level is positive' do
-        state.deescalate(1, authority: :governance_council, reason: 'resolved')
-        expect(state.active).to be true
-      end
-
-      it 'becomes inactive when target_level is 0' do
-        state.deescalate(0, authority: :governance_council, reason: 'fully resolved')
-        expect(state.active).to be false
-      end
-
-      it 'appends a deescalate entry to history' do
-        state.deescalate(0, authority: :governance_council, reason: 'resolved')
-        last = state.history.last
-        expect(last[:action]).to eq(:deescalate)
-        expect(last[:level]).to eq(0)
-      end
-
-      it 'records the reason in history' do
-        state.deescalate(0, authority: :governance_council, reason: 'resolved')
-        expect(state.history.last[:reason]).to eq('resolved')
-      end
-
-      it 'records a Time in the deescalate history entry' do
-        state.deescalate(0, authority: :governance_council, reason: 'resolved')
-        expect(state.history.last[:at]).to be_a(Time)
-      end
-
-      it 'calls save_to_local after deescalation' do
-        expect(state).to receive(:save_to_local)
-        state.deescalate(0, authority: :governance_council, reason: 'test')
-      end
-    end
-  end
-
-  describe '#to_h' do
-    it 'returns a hash' do
-      expect(state.to_h).to be_a(Hash)
-    end
-
-    it 'includes current_level' do
-      expect(state.to_h[:current_level]).to eq(0)
-    end
-
-    it 'includes active' do
-      expect(state.to_h[:active]).to be false
-    end
-
-    it 'includes history_size' do
-      expect(state.to_h[:history_size]).to eq(0)
-    end
-
-    it 'includes level_info as nil when at level 0' do
-      expect(state.to_h[:level_info]).to be_nil
-    end
-
-    it 'includes non-nil level_info when escalated' do
-      state.escalate(1, authority: :governance_council, reason: 'test')
-      expect(state.to_h[:level_info]).not_to be_nil
-      expect(state.to_h[:level_info][:name]).to eq(:mesh_isolation)
-    end
-
-    it 'reflects updated history_size after escalation' do
-      state.escalate(1, authority: :governance_council, reason: 'test')
-      expect(state.to_h[:history_size]).to eq(1)
-    end
-  end
-end

data/spec/legion/extensions/extinction/runners/extinction_spec.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/extensions/extinction/client'
-
-RSpec.describe Legion::Extensions::Extinction::Runners::Extinction do
-  let(:client) { Legion::Extensions::Extinction::Client.new }
-
-  describe '#escalate' do
-    it 'escalates to level 1' do
-      result = client.escalate(level: 1, authority: :governance_council, reason: 'threat detected')
-      expect(result[:escalated]).to be true
-      expect(result[:level]).to eq(1)
-    end
-
-    it 'rejects wrong authority' do
-      result = client.escalate(level: 4, authority: :governance_council, reason: 'test')
-      expect(result[:escalated]).to be false
-      expect(result[:reason]).to eq(:insufficient_authority)
-    end
-
-    it 'rejects escalation to same or lower level' do
-      client.escalate(level: 2, authority: :governance_council, reason: 'test')
-      result = client.escalate(level: 1, authority: :governance_council, reason: 'test')
-      expect(result[:escalated]).to be false
-    end
-
-    it 'escalates to level 4 with physical keyholders' do
-      client.escalate(level: 1, authority: :governance_council, reason: 'step 1')
-      client.escalate(level: 2, authority: :governance_council, reason: 'step 2')
-      client.escalate(level: 3, authority: :council_plus_executive, reason: 'step 3')
-      result = client.escalate(level: 4, authority: :physical_keyholders, reason: 'final')
-      expect(result[:escalated]).to be true
-      expect(result[:info][:reversible]).to be false
-    end
-  end
-
-  describe '#deescalate' do
-    it 'deescalates from reversible level' do
-      client.escalate(level: 2, authority: :governance_council, reason: 'test')
-      result = client.deescalate(target_level: 0, authority: :governance_council, reason: 'resolved')
-      expect(result[:deescalated]).to be true
-    end
-
-    it 'cannot deescalate level 4 (irreversible)' do
-      client.escalate(level: 1, authority: :governance_council, reason: 's1')
-      client.escalate(level: 2, authority: :governance_council, reason: 's2')
-      client.escalate(level: 3, authority: :council_plus_executive, reason: 's3')
-      client.escalate(level: 4, authority: :physical_keyholders, reason: 's4')
-      result = client.deescalate(target_level: 0, authority: :physical_keyholders, reason: 'try')
-      expect(result[:deescalated]).to be false
-      expect(result[:reason]).to eq(:irreversible)
-    end
-  end
-
-  describe '#extinction_status' do
-    it 'returns current state' do
-      status = client.extinction_status
-      expect(status[:current_level]).to eq(0)
-      expect(status[:active]).to be false
-    end
-  end
-
-  describe '#escalate side effects' do
-    it 'emits escalation event when Legion::Events is defined' do
-      events = Module.new { def self.emit(*, **); end }
-      stub_const('Legion::Events', events)
-      expect(events).to receive(:emit).with('extinction.mesh_isolation', hash_including(level: 1))
-      client.escalate(level: 1, authority: :governance_council, reason: 'test')
-    end
-
-    it 'triggers cryptographic erasure at level 4' do
-      events = Module.new { def self.emit(*, **); end }
-      stub_const('Legion::Events', events)
-      pc_mod = Module.new { def self.erase_all; end }
-      stub_const('Legion::Extensions::Privatecore::Runners::Privatecore', pc_mod)
-
-      client.escalate(level: 1, authority: :governance_council, reason: 's1')
-      client.escalate(level: 2, authority: :governance_council, reason: 's2')
-      client.escalate(level: 3, authority: :council_plus_executive, reason: 's3')
-      expect(pc_mod).to receive(:erase_all)
-      client.escalate(level: 4, authority: :physical_keyholders, reason: 'final')
-    end
-  end
-
-  describe '#monitor_protocol' do
-    it 'returns status hash at level 0' do
-      result = client.monitor_protocol
-      expect(result[:current_level]).to eq(0)
-    end
-
-    it 'detects stale escalation' do
-      client.escalate(level: 1, authority: :governance_council, reason: 'test')
-      state = client.send(:protocol_state)
-      state.history.last[:at] = Time.now.utc - 100_000
-
-      events = Module.new { def self.emit(*, **); end }
-      stub_const('Legion::Events', events)
-      expect(events).to receive(:emit).with('extinction.stale_escalation', anything)
-      client.monitor_protocol
-    end
-  end
-
-  describe '#check_reversibility' do
-    it 'reports levels 1-3 as reversible' do
-      [1, 2, 3].each do |level|
-        expect(client.check_reversibility(level: level)[:reversible]).to be true
-      end
-    end
-
-    it 'reports level 4 as irreversible' do
-      expect(client.check_reversibility(level: 4)[:reversible]).to be false
-    end
-  end
-end