lex-extinction 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09d900581a92a527c43ffce88cf96c499f8aae44a4c12cf00adedd47a079dd38'
-  data.tar.gz: 6f5ac264ef4ae83879bec5f515dedebf0662a79eb551804e96669263446e3314
+  metadata.gz: eb9e97dfd37144dc7a5b9d94c18f8f0c04daa25b682a6382d124aaafd22bfe5d
+  data.tar.gz: 9105b88a1cca0e7c0485925859131ad8879124acca633fa9613f10f69818a75e
 SHA512:
-  metadata.gz: 70b94eeb7b31f41f9cb721d45229efc17c89e91b25eb8068e4ae3a1de3b316b9f902309d3b2c9188edc51e1d99c39bcbebcf1463909b24a1e5941ea632a41319
-  data.tar.gz: a59842aade6c008b7e33927988732045e6e45660be85b2541db543b5ef7005ff4fbfdee22a638786a00b148f50718600bd114e042b933b1203b263817e4f58d2
+  metadata.gz: f55025877d82a197ec8fea8ddf842d55f462332bb97ed5d020c20e8d87678318b69abdfd4a227d87fe94dde00c4e0d51ec8f5d90183b33cb2f1e61cac8f7095e
+  data.tar.gz: '0816236a9aca4a74fefa2cac8879213a959ea29ac743e478fcb3e4c12518833f25942b46c594e64009bdc1a16cc944d4fe121ffc70a33ebf8667376cdcba3948'

data/lib/legion/extensions/extinction/actors/protocol_monitor.rb

@@ -1,38 +1,75 @@
 # frozen_string_literal: true
 
-require 'legion/extensions/actors/every'
-
 module Legion
   module Extensions
     module Extinction
-      module Actor
-        class ProtocolMonitor < Legion::Extensions::Actors::Every
-          def runner_class
-            Legion::Extensions::Extinction::Runners::Extinction
-          end
+      module Actors
+        if defined?(Legion::Extensions::Actors::Every)
+          class ProtocolMonitor < Legion::Extensions::Actors::Every
+            def runner_class
+              self.class
+            end
 
-          def runner_function
-            'monitor_protocol'
-          end
+            def runner_function
+              'monitor_protocol'
+            end
 
-          def time
-            300
-          end
+            def time
+              Legion::Extensions::Extinction::Settings.setting(:monitor_interval)
+            rescue StandardError
+              300
+            end
 
-          def run_now?
-            false
-          end
+            def run_now?
+              false
+            end
 
-          def use_runner?
-            false
-          end
+            def use_runner?
+              false
+            end
 
-          def check_subtask?
-            false
-          end
+            def check_subtask?
+              false
+            end
+
+            def generate_task?
+              false
+            end
+
+            def monitor_protocol(**)
+              state = build_state
+              last_change = state[:last_change]
+              stale       = check_stale(last_change)
+
+              Legion::Logging.debug "[extinction] monitor_protocol: level=#{state[:current_level]} stale=#{stale}" if defined?(Legion::Logging)
+
+              {
+                success:    true,
+                state:      state,
+                stale:      stale,
+                checked_at: Time.now.utc.iso8601
+              }
+            end
+
+            private
+
+            def build_state
+              {
+                current_level: 0,
+                level_name:    :normal,
+                reversible:    true,
+                history_count: 0,
+                last_change:   nil
+              }
+            end
+
+            def check_stale(last_change)
+              return false unless last_change
 
-          def generate_task?
-            false
+              threshold_hours = Legion::Extensions::Extinction::Settings.setting(:stale_threshold_hours)
+              changed_at      = Time.parse(last_change[:at]) rescue nil # rubocop:disable Style/RescueModifier
+              changed_at && (Time.now.utc - changed_at) > (threshold_hours * 3600)
+            end
           end
         end
       end

data/lib/legion/extensions/extinction/client.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'legion/extensions/extinction/helpers/levels'
-require 'legion/extensions/extinction/helpers/protocol_state'
-require 'legion/extensions/extinction/runners/extinction'
+require_relative 'runners/extinction'
 
 module Legion
   module Extensions
@@ -10,13 +8,13 @@ module Legion
       class Client
         include Runners::Extinction
 
-        def initialize(**)
-          @protocol_state = Helpers::ProtocolState.new
+        def initialize(**opts)
+          @opts = opts
         end
 
-        private
-
-        attr_reader :protocol_state
+        def settings
+          { options: @opts }
+        end
       end
     end
   end

data/lib/legion/extensions/extinction/helpers/archiver.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Extinction
+      module Helpers
+        class Archiver
+          def initialize
+            @archives = []
+          end
+
+          def archive(agent_id:, reason:, metadata: {})
+            level = current_protocol_level
+            record = {
+              agent_id:       agent_id,
+              reason:         reason,
+              metadata:       metadata,
+              level:          level,
+              archived_at:    Time.now.utc.iso8601,
+              state_snapshot: capture_state_snapshot
+            }
+
+            persist_archive(record)
+            record
+          end
+
+          def all_archives
+            @archives.dup
+          end
+
+          private
+
+          def current_protocol_level
+            0
+          end
+
+          def capture_state_snapshot
+            snapshot = {}
+            snapshot[:mesh_connected] = true if defined?(Legion::Extensions::Mesh)
+            snapshot[:privatecore_active] = true if defined?(Legion::Extensions::Privatecore)
+            snapshot
+          end
+
+          def persist_archive(record)
+            if defined?(Legion::Data::Local)
+              key = "extinction:archive:#{record[:agent_id]}:#{record[:archived_at]}"
+              Legion::Data::Local.set(key, record)
+            end
+            @archives << record
+          rescue StandardError => e
+            Legion::Logging.warn "[extinction] archive persist failed: #{e.message}" if defined?(Legion::Logging)
+            @archives << record
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/extinction/helpers/levels.rb

@@ -5,32 +5,57 @@ module Legion
     module Extinction
       module Helpers
         module Levels
-          # Four escalation levels (spec: extinction-protocol-spec.md)
-          ESCALATION_LEVELS = {
-            1 => { name: :mesh_isolation,       reversible: true,  authority: :governance_council },
-            2 => { name: :forced_sentinel,      reversible: true,  authority: :governance_council },
-            3 => { name: :full_suspension,       reversible: true,  authority: :council_plus_executive },
-            4 => { name: :cryptographic_erasure, reversible: false, authority: :physical_keyholders }
+          LEVELS = {
+            0 => {
+              name:               :normal,
+              authority_required: nil,
+              reversible:         true,
+              description:        'No extinction active'
+            }.freeze,
+            1 => {
+              name:               :mesh_isolation,
+              authority_required: :governance_council,
+              reversible:         true,
+              description:        'Disconnect from mesh network'
+            }.freeze,
+            2 => {
+              name:               :capability_suspension,
+              authority_required: :governance_council,
+              reversible:         true,
+              description:        'Suspend all non-essential capabilities'
+            }.freeze,
+            3 => {
+              name:               :memory_lockdown,
+              authority_required: :council_plus_executive,
+              reversible:         true,
+              description:        'Lock all memory writes, read-only mode'
+            }.freeze,
+            4 => {
+              name:               :cryptographic_erasure,
+              authority_required: :physical_keyholders,
+              reversible:         false,
+              description:        'Erase all memory, terminate all workers'
+            }.freeze
           }.freeze
 
-          VALID_LEVELS = [1, 2, 3, 4].freeze
-
-          module_function
-
-          def valid_level?(level)
-            VALID_LEVELS.include?(level)
+          def self.valid_level?(level)
+            LEVELS.key?(level)
           end
 
-          def level_info(level)
-            ESCALATION_LEVELS[level]
+          def self.required_authority(level)
+            info = LEVELS[level]
+            info ? info[:authority_required] : nil
           end
 
-          def reversible?(level)
-            ESCALATION_LEVELS.dig(level, :reversible) || false
+          def self.reversible?(level)
+            info = LEVELS[level]
+            return false unless info
+
+            info[:reversible]
           end
 
-          def required_authority(level)
-            ESCALATION_LEVELS.dig(level, :authority)
+          def self.level_info(level)
+            LEVELS[level]
           end
         end
       end

data/lib/legion/extensions/extinction/helpers/protocol_state.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require_relative 'levels'
 
 module Legion
   module Extensions
@@ -9,110 +9,104 @@ module Legion
         class ProtocolState
           MAX_HISTORY = 500
 
-          attr_reader :current_level, :history, :active
+          attr_reader :history
 
           def initialize
-            @current_level = 0 # 0 = normal operation
-            @active = false
-            @history = []
+            @current_level = 0
+            @history       = []
+            @store         = {}
             load_from_local
           end
 
-          def escalate(level, authority:, reason:)
-            return :invalid_level unless Levels.valid_level?(level)
-            return :already_at_or_above if level <= @current_level
-            return :insufficient_authority unless authority == Levels.required_authority(level)
+          def escalate(level:, authority:, reason:)
+            return { success: false, reason: :invalid_level } unless Levels.valid_level?(level)
+            return { success: false, reason: :invalid_escalation } if level <= @current_level
 
+            required = Levels.required_authority(level)
+            return { success: false, reason: :insufficient_authority, required: required, provided: authority } if required && authority != required
+
+            previous = @current_level
             @current_level = level
-            @active = true
-            @history << {
-              action: :escalate, level: level, authority: authority,
-              reason: reason, at: Time.now.utc
-            }
+            record_history(action: :escalate, from: previous, to: level, authority: authority, reason: reason)
             trim_history
             save_to_local
-            :escalated
+
+            { success: true, previous_level: previous, current_level: level }
           end
 
-          def deescalate(target_level, authority:, reason:)
-            return :not_active unless @active
-            return :invalid_target if target_level >= @current_level
-            return :irreversible unless Levels.reversible?(@current_level)
-            return :insufficient_authority unless authority == Levels.required_authority(@current_level)
+          def deescalate(target_level:, authority:, reason:)
+            return { success: false, reason: :invalid_level } unless Levels.valid_level?(target_level)
+            return { success: false, reason: :invalid_deescalation } if target_level >= @current_level
 
+            return { success: false, reason: :not_reversible } unless Levels.reversible?(@current_level)
+
+            required = Levels.required_authority(@current_level)
+            return { success: false, reason: :insufficient_authority, required: required, provided: authority } if required && authority != required
+
+            previous = @current_level
             @current_level = target_level
-            @active = target_level.positive?
-            @history << {
-              action: :deescalate, level: target_level, authority: authority,
-              reason: reason, at: Time.now.utc
-            }
+            record_history(action: :deescalate, from: previous, to: target_level, authority: authority,
+                           reason: reason)
             trim_history
             save_to_local
-            :deescalated
+
+            { success: true, previous_level: previous, current_level: target_level }
           end
 
           def to_h
             {
               current_level: @current_level,
-              active:        @active,
-              level_info:    @current_level.positive? ? Levels.level_info(@current_level) : nil,
-              history_size:  @history.size
+              level_name:    Levels.level_info(@current_level)&.dig(:name),
+              reversible:    Levels.reversible?(@current_level),
+              history_count: @history.size,
+              last_change:   @history.last
             }
           end
 
-          def save_to_local
-            return unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
+          private
 
-            row = {
-              id:            1,
-              current_level: @current_level,
-              active:        @active,
-              history:       ::JSON.dump(@history.map { |h| h.merge(at: h[:at].to_s) }),
-              updated_at:    Time.now.utc
+          def record_history(action:, from:, to:, authority:, reason:)
+            @history << {
+              action:    action,
+              from:      from,
+              to:        to,
+              authority: authority,
+              reason:    reason,
+              at:        Time.now.utc.iso8601
             }
-            db = Legion::Data::Local.connection
-            if db[:extinction_state].where(id: 1).any?
-              db[:extinction_state].where(id: 1).update(row.except(:id))
-            else
-              db[:extinction_state].insert(row)
-            end
-          rescue StandardError
-            nil
           end
 
-          private
-
           def trim_history
-            @history = @history.last(MAX_HISTORY) if @history.size > MAX_HISTORY
-          end
-
-          def load_from_local
-            return unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
-
-            row = Legion::Data::Local.connection[:extinction_state].where(id: 1).first
-            return unless row
+            max = defined?(Legion::Extensions::Extinction::Settings) ? Legion::Extensions::Extinction::Settings.setting(:max_history) : MAX_HISTORY
+            return unless @history.size > max
 
-            db_level = row[:current_level].to_i
-            @current_level = [db_level, @current_level].max
-            @active = [true, 1].include?(row[:active])
-            @history = parse_history(row[:history])
-          rescue StandardError
-            nil
+            @history.shift(@history.size - max)
           end
 
-          def parse_history(raw)
-            return [] if raw.nil? || raw.empty?
-
-            parsed = ::JSON.parse(raw, symbolize_names: true)
-            parsed.map do |h|
-              h.merge(
-                action:    h[:action].to_sym,
-                authority: h[:authority].to_sym,
-                at:        Time.parse(h[:at].to_s)
-              )
+          def save_to_local
+            data = { current_level: @current_level, history: @history }
+            if defined?(Legion::Data::Local)
+              Legion::Data::Local.set('extinction:protocol_state', data)
+            else
+              @store[:protocol_state] = data
             end
-          rescue StandardError
-            []
+          rescue StandardError => e
+            Legion::Logging.warn "[extinction] protocol_state save failed: #{e.message}" if defined?(Legion::Logging)
+          end
+
+          def load_from_local
+            data = if defined?(Legion::Data::Local)
+                     Legion::Data::Local.get('extinction:protocol_state')
+                   else
+                     @store[:protocol_state]
+                   end
+            return unless data
+
+            @current_level = data[:current_level] || data['current_level'] || 0
+            raw_history    = data[:history] || data['history'] || []
+            @history       = raw_history
+          rescue StandardError => e
+            Legion::Logging.warn "[extinction] protocol_state load failed: #{e.message}" if defined?(Legion::Logging)
           end
         end
       end