lex-extinction 0.2.0 → 0.2.1

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

@@ -1,123 +1,169 @@
 # frozen_string_literal: true
 
+require_relative '../helpers/levels'
+require_relative '../helpers/protocol_state'
+require_relative '../helpers/archiver'
+require_relative '../settings'
+
 module Legion
   module Extensions
     module Extinction
       module Runners
         module Extinction
-          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
-
           def escalate(level:, authority:, reason:, **)
-            result = protocol_state.escalate(level, authority: authority, reason: reason)
-            case result
-            when :escalated
-              info = Helpers::Levels.level_info(level)
-              Legion::Logging.warn "[extinction] ESCALATED: level=#{level} name=#{info[:name]} authority=#{authority} reason=#{reason}"
-              enforce_escalation_effects(level)
-              emit_escalation_event(level, authority, reason)
-              { escalated: true, level: level, info: info }
-            else
-              Legion::Logging.debug "[extinction] escalation denied: level=#{level} reason=#{result}"
-              { escalated: false, reason: result }
+            result = protocol_state.escalate(level: level, authority: authority, reason: reason)
+            return result unless result[:success]
+
+            enforce_escalation_effects(level)
+            emit_escalation_event(level, authority, reason)
+            record_audit(action: :escalate, details: { level: level, authority: authority, reason: reason })
+
+            if Legion::Extensions::Extinction::Settings.setting(:archive_on_escalate) && level >= 3
+              archive_agent(agent_id: 'self', reason: "auto-archive at level #{level}", metadata: { triggered_by: :escalate })
             end
+
+            result
           end
 
-          def deescalate(authority:, reason:, target_level: 0, **)
-            result = protocol_state.deescalate(target_level, authority: authority, reason: reason)
-            case result
-            when :deescalated
-              Legion::Logging.info "[extinction] de-escalated: target=#{target_level} authority=#{authority} reason=#{reason}"
-              { deescalated: true, level: target_level }
-            else
-              Legion::Logging.debug "[extinction] de-escalation denied: target=#{target_level} reason=#{result}"
-              { deescalated: false, reason: result }
-            end
+          def deescalate(target_level:, authority:, reason:, **)
+            result = protocol_state.deescalate(target_level: target_level, authority: authority, reason: reason)
+            return result unless result[:success]
+
+            emit_deescalation_event(target_level, authority, reason)
+            record_audit(action:  :deescalate,
+                         details: { target_level: target_level, authority: authority, reason: reason })
+
+            result
           end
 
           def extinction_status(**)
-            status = protocol_state.to_h
-            Legion::Logging.debug "[extinction] status: level=#{status[:current_level]} active=#{status[:active]}"
-            status
+            state = protocol_state.to_h
+            level_info = Helpers::Levels.level_info(state[:current_level])
+            { success: true, state: state, level_info: level_info }
           end
 
           def monitor_protocol(**)
-            status = protocol_state.to_h
-            level = status[:current_level]
-
-            if level.positive?
-              Legion::Logging.warn "[extinction] ACTIVE: level=#{level} active=#{status[:active]}"
-              detect_stale_escalation(level)
-            else
-              Legion::Logging.debug '[extinction] status: level=0 active=false'
+            state = protocol_state.to_h
+            last_change = state[:last_change]
+            stale       = false
+
+            if last_change
+              threshold_hours = Legion::Extensions::Extinction::Settings.setting(:stale_threshold_hours)
+              changed_at      = Time.parse(last_change[:at]) rescue nil # rubocop:disable Style/RescueModifier
+              stale           = changed_at && (Time.now.utc - changed_at) > (threshold_hours * 3600)
             end
 
-            status
-          end
-
-          def check_reversibility(level:, **)
-            reversible = Helpers::Levels.reversible?(level)
-            Legion::Logging.debug "[extinction] reversibility: level=#{level} reversible=#{reversible}"
             {
-              level:      level,
-              reversible: reversible,
-              authority:  Helpers::Levels.required_authority(level)
+              success:    true,
+              state:      state,
+              stale:      stale,
+              checked_at: Time.now.utc.iso8601
             }
           end
 
-          STALE_ESCALATION_THRESHOLD = 86_400
+          def archive_agent(agent_id:, reason:, metadata: {}, **)
+            record = archiver.archive(agent_id: agent_id, reason: reason, metadata: metadata)
+            record_audit(action: :archive, details: { agent_id: agent_id, reason: reason })
+            { success: true, archive: record }
+          end
+
+          def full_termination(agent_id:, authority:, reason:, **)
+            gate = governance_check(authority: authority)
+            return gate unless gate[:success]
+
+            archive_result = archive_agent(agent_id: agent_id, reason: reason,
+                                           metadata: { termination: true, authority: authority })
+            return archive_result unless archive_result[:success]
+
+            escalate_result = escalate(level: 4, authority: authority, reason: reason)
+            return escalate_result unless escalate_result[:success]
+
+            record_audit(action: :full_termination, details: { agent_id: agent_id, authority: authority, reason: reason })
+            { success: true, agent_id: agent_id, archive: archive_result[:archive], terminated_at: Time.now.utc.iso8601 }
+          end
 
           private
 
-          def enforce_escalation_effects(level)
-            if level >= 1 && defined?(Legion::Extensions::Mesh::Runners::Mesh)
-              Legion::Extensions::Mesh::Runners::Mesh.disconnect rescue nil # rubocop:disable Style/RescueModifier
-              Legion::Logging.warn '[extinction] mesh isolation enforced'
-            end
+          def protocol_state
+            @protocol_state ||= Helpers::ProtocolState.new
+          end
 
-            return unless level == 4
+          def archiver
+            @archiver ||= Helpers::Archiver.new
+          end
 
-            if defined?(Legion::Extensions::Privatecore::Runners::Privatecore)
-              Legion::Extensions::Privatecore::Runners::Privatecore.erase_all rescue nil # rubocop:disable Style/RescueModifier
-              Legion::Logging.warn '[extinction] cryptographic erasure triggered'
+          def enforce_escalation_effects(level)
+            case level
+            when 1
+              Legion::Logging.info '[extinction] mesh isolation: disconnecting from mesh' if defined?(Legion::Extensions::Mesh) && defined?(Legion::Logging)
+            when 2
+              Legion::Logging.info '[extinction] capability suspension: suspending non-essential capabilities' if defined?(Legion::Logging)
+            when 3
+              Legion::Logging.warn '[extinction] memory lockdown: locking all memory writes' if defined?(Legion::Logging)
+              if defined?(Legion::Extensions::Privatecore) && defined?(Legion::Logging)
+                Legion::Logging.warn '[extinction] notifying privatecore of memory lockdown'
+              end
+            when 4
+              Legion::Logging.warn '[extinction] cryptographic erasure: beginning irreversible termination' if defined?(Legion::Logging)
+              trigger_cryptographic_erasure
             end
+          end
 
-            return unless defined?(Legion::Data::Model::DigitalWorker)
-
-            begin
-              Legion::Data::Model::DigitalWorker.where(lifecycle_state: 'active').update(
-                lifecycle_state: 'terminated', updated_at: Time.now.utc
-              )
-            rescue StandardError
-              nil
+          def trigger_cryptographic_erasure
+            if defined?(Legion::Extensions::Privatecore::Runners::Privatecore)
+              client = Legion::Extensions::Privatecore::Client.new if defined?(Legion::Extensions::Privatecore::Client)
+              client&.full_erasure(traces: [], agent_id: 'self')
             end
-            Legion::Logging.warn '[extinction] all active workers terminated'
+            Legion::Logging.warn '[extinction] cryptographic erasure complete' if defined?(Legion::Logging)
           end
 
           def emit_escalation_event(level, authority, reason)
-            return unless defined?(Legion::Events)
+            payload = { level: level, authority: authority, reason: reason, at: Time.now.utc.iso8601 }
+            Legion::Events.emit('extinction.escalated', payload) if defined?(Legion::Events)
+          rescue StandardError => e
+            Legion::Logging.warn "[extinction] event emit failed: #{e.message}" if defined?(Legion::Logging)
+          end
 
-            info = Helpers::Levels.level_info(level)
-            Legion::Events.emit("extinction.#{info[:name]}", {
-                                  level: level, authority: authority, reason: reason, at: Time.now.utc
-                                })
+          def emit_deescalation_event(target_level, authority, reason)
+            payload = { target_level: target_level, authority: authority, reason: reason, at: Time.now.utc.iso8601 }
+            Legion::Events.emit('extinction.deescalated', payload) if defined?(Legion::Events)
+          rescue StandardError => e
+            Legion::Logging.warn "[extinction] event emit failed: #{e.message}" if defined?(Legion::Logging)
           end
 
-          def detect_stale_escalation(level)
-            last_escalation = protocol_state.history.select { |h| h[:action] == :escalate }.last
-            return unless last_escalation && (Time.now.utc - last_escalation[:at]) > STALE_ESCALATION_THRESHOLD
+          def governance_check(authority:, _reason: nil)
+            return { success: true } unless Legion::Extensions::Extinction::Settings.setting(:governance_required)
+            return { success: true } unless defined?(Legion::Extensions::Governance)
 
-            Legion::Logging.warn "[extinction] STALE: level=#{level} has been active > 24 hours"
-            return unless defined?(Legion::Events)
+            review = Legion::Extensions::Governance::Runners::Governance.review_transition(
+              worker_id:    'extinction',
+              from_state:   'active',
+              to_state:     'terminated',
+              principal_id: authority.to_s,
+              worker_owner: nil
+            )
 
-            Legion::Events.emit('extinction.stale_escalation', {
-                                  level: level, since: last_escalation[:at],
-                                  hours: ((Time.now.utc - last_escalation[:at]) / 3600).round(1)
-                                })
+            if review[:allowed]
+              { success: true }
+            else
+              { success: false, reason: :governance_blocked, details: review[:reasons] }
+            end
+          rescue StandardError => e
+            Legion::Logging.warn "[extinction] governance check failed: #{e.message}" if defined?(Legion::Logging)
+            { success: true }
           end
 
-          def protocol_state
-            @protocol_state ||= Helpers::ProtocolState.new
+          def record_audit(action:, details: {})
+            return unless defined?(Legion::Extensions::Audit::Runners::Audit)
+
+            Legion::Extensions::Audit::Runners::Audit.record(
+              entity_type: 'extinction',
+              entity_id:   'protocol',
+              action:      action,
+              details:     details
+            )
+          rescue StandardError => e
+            Legion::Logging.warn "[extinction] audit record failed: #{e.message}" if defined?(Legion::Logging)
           end
         end
       end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Extinction
+      module Settings
+        DEFAULTS = {
+          enabled:               true,
+          governance_required:   true,
+          stale_threshold_hours: 24,
+          monitor_interval:      300,
+          archive_on_escalate:   true,
+          max_history:           500
+        }.freeze
+
+        def self.setting(key)
+          if defined?(Legion::Settings) && Legion::Settings[:extinction]
+            Legion::Settings[:extinction].fetch(key, DEFAULTS[key])
+          else
+            DEFAULTS[key]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Extinction
-      VERSION = '0.2.0'
+      VERSION = '0.2.1'
     end
   end
 end

data/lib/legion/extensions/extinction.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require 'legion/extensions/extinction/version'
-require 'legion/extensions/extinction/helpers/levels'
-require 'legion/extensions/extinction/helpers/protocol_state'
-require 'legion/extensions/extinction/runners/extinction'
+require_relative 'extinction/version'
+require_relative 'extinction/settings'
+require_relative 'extinction/helpers/levels'
+require_relative 'extinction/helpers/protocol_state'
+require_relative 'extinction/helpers/archiver'
+require_relative 'extinction/runners/extinction'
+
+require_relative 'extinction/actors/protocol_monitor' if defined?(Legion::Extensions::Actors::Every)
 
 module Legion
   module Extensions
     module Extinction
-      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+
+      data_required? false     if respond_to?(:data_required?)
+      remote_invocable? false  if respond_to?(:remote_invocable?)
     end
   end
 end
-
-if defined?(Legion::Data::Local)
-  Legion::Data::Local.register_migrations(
-    name: :extinction,
-    path: File.join(__dir__, 'extinction', 'local_migrations')
-  )
-end

metadata

@@ -1,39 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: lex-extinction
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Esity
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
-description: Escalation and extinction protocol (4 levels) for brain-modeled agentic
-  AI
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.62'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.62'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.25'
+description: Five-level extinction protocol with archival, audit trail, governance
+  gates, and configurable settings
 email:
-- matthewdiverson@gmail.com
+- matt@esity.io
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Gemfile
-- lex-extinction.gemspec
 - lib/legion/extensions/extinction.rb
 - lib/legion/extensions/extinction/actors/protocol_monitor.rb
 - lib/legion/extensions/extinction/client.rb
+- lib/legion/extensions/extinction/helpers/archiver.rb
 - lib/legion/extensions/extinction/helpers/levels.rb
 - lib/legion/extensions/extinction/helpers/protocol_state.rb
-- lib/legion/extensions/extinction/local_migrations/20260316000040_create_extinction_state.rb
 - lib/legion/extensions/extinction/runners/extinction.rb
+- lib/legion/extensions/extinction/settings.rb
 - lib/legion/extensions/extinction/version.rb
-- spec/legion/extensions/extinction/actors/protocol_monitor_spec.rb
-- spec/legion/extensions/extinction/client_spec.rb
-- spec/legion/extensions/extinction/helpers/levels_spec.rb
-- spec/legion/extensions/extinction/helpers/protocol_state_spec.rb
-- spec/legion/extensions/extinction/runners/extinction_spec.rb
-- spec/local_persistence_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/LegionIO/lex-extinction
 licenses:
 - MIT
@@ -60,5 +94,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: LEX Extinction
+summary: Agent lifecycle termination protocol for LegionIO
 test_files: []

data/Gemfile

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gemspec
-
-gem 'rspec', '~> 3.13'
-gem 'rubocop', '~> 1.75', require: false
-gem 'sequel', '>= 5.70'
-gem 'sqlite3', '>= 2.0'

data/lex-extinction.gemspec

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/legion/extensions/extinction/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'lex-extinction'
-  spec.version       = Legion::Extensions::Extinction::VERSION
-  spec.authors       = ['Esity']
-  spec.email         = ['matthewdiverson@gmail.com']
-
-  spec.summary       = 'LEX Extinction'
-  spec.description   = 'Escalation and extinction protocol (4 levels) for brain-modeled agentic AI'
-  spec.homepage      = 'https://github.com/LegionIO/lex-extinction'
-  spec.license       = 'MIT'
-  spec.required_ruby_version = '>= 3.4'
-
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = 'https://github.com/LegionIO/lex-extinction'
-  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-extinction'
-  spec.metadata['changelog_uri'] = 'https://github.com/LegionIO/lex-extinction'
-  spec.metadata['bug_tracker_uri'] = 'https://github.com/LegionIO/lex-extinction/issues'
-  spec.metadata['rubygems_mfa_required'] = 'true'
-
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    Dir.glob('{lib,spec}/**/*') + %w[lex-extinction.gemspec Gemfile]
-  end
-  spec.require_paths = ['lib']
-end

data/lib/legion/extensions/extinction/local_migrations/20260316000040_create_extinction_state.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-Sequel.migration do
-  change do
-    create_table(:extinction_state) do
-      primary_key :id
-      Integer :current_level, null: false, default: 0
-      TrueClass :active, null: false, default: false
-      String :history, text: true
-      DateTime :updated_at
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# 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/extinction/actors/protocol_monitor'
-
-RSpec.describe Legion::Extensions::Extinction::Actor::ProtocolMonitor do
-  subject(:actor) { described_class.new }
-
-  describe '#runner_class' do
-    it { expect(actor.runner_class).to eq Legion::Extensions::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/extinction/client_spec.rb

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