lex-extinction 0.2.10 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac2608cc19b731a702760c24eac379aca97d3877010ebdaae6a1922031153532
-  data.tar.gz: a528d184c0ba4b7c8851c095612f2fd10173b352e1a7a45bec12a99b24a1da17
+  metadata.gz: 3bea637abe66244c3799141b6aa0e4283f3a8e7028f6055f506b8c57af0e44f6
+  data.tar.gz: 77d10179bb82e792921b1410f2dedabfe6ca7c58172f9533085085db723f5bc1
 SHA512:
-  metadata.gz: 1795646dd6dae2be9c7d087070a0b25e00177e1e33e1a3655ac8180a931046005dc187a7c4320ac8e0012f67e387122e667ff39171c96d82d3096337f8a14d58
-  data.tar.gz: f887f804a029b917c875a82c124a7d1acec7e4a9e124c9676b1cfc78ce06315550c0865a6afd2c0082425f9d6ca3b8867d94424a174bb7b0c188bbb1a804edf3
+  metadata.gz: 9313d98cefd36414c05e058142ee325c81a006f03d077c672b88a96f58db475771fd867980f1b4bf26f1f906bfc61cb412edf60d7b3552d2a49bf9f29c12868e
+  data.tar.gz: f4658bb01662f674c469dcf67d543b277d5ac66d33535d94864f337137115e5b0ea9f0a62edf9caaf9f54f2a2f29432222da4a9206e780ecce3c939cde382fcc

data/README.md

@@ -12,6 +12,12 @@ Five-level safety containment and termination protocol for LegionIO agents. Prov
 | 3 | Memory lockdown | council + executive | yes |
 | 4 | Cryptographic erasure | physical keyholders | **no** |
 
+## Installation
+
+```ruby
+gem 'lex-extinction'
+```
+
 ## Usage
 
 ```ruby
@@ -39,12 +45,23 @@ client.full_termination(
 )
 ```
 
+## Runner Methods
+
+| Method | Key Args | Returns |
+|--------|----------|---------|
+| `escalate` | `level:, authority:, reason:` | `{ success:, previous_level:, current_level: }` |
+| `deescalate` | `target_level:, authority:, reason:` | `{ success:, previous_level:, current_level: }` |
+| `extinction_status` | — | `{ success:, state:, level_info: }` |
+| `monitor_protocol` | — | `{ success:, state:, stale:, checked_at: }` |
+| `archive_agent` | `agent_id:, reason:, metadata: {}` | `{ success:, archive: }` |
+| `full_termination` | `agent_id:, authority:, reason:` | governance check → archive → escalate(4) |
+
 ## Configuration
 
 ```yaml
 extinction:
   governance_required: true       # check lex-governance before full_termination
-  archive_on_escalate: false      # auto-archive at level >= 3
+  archive_on_escalate: true       # auto-archive at level >= 3
   stale_threshold_hours: 24       # hours before monitor reports stale protocol state
   monitor_interval: 300           # seconds between background monitor ticks
 ```
@@ -57,9 +74,9 @@ extinction:
 
 ## Architecture Notes
 
-- Level 4 (cryptographic erasure) triggers `lex-privatecore`'s `full_erasure` on all memory traces.
+- Level 4 (cryptographic erasure) triggers `lex-privatecore`'s `full_erasure` on all memory traces (guarded with `defined?`).
 - State is persisted to `Legion::Data::Local` when available; falls back to in-memory storage.
-- All escalations/de-escalations fire `Legion::Events` notifications and write to `Legion::Extensions::Audit`.
+- All escalations/de-escalations fire `Legion::Events` notifications (`extinction.escalated`, `extinction.deescalated`, `extinction.level_N`) and write to `Legion::Extensions::Audit`.
 - `lex-governance` integration is guarded with `defined?()` — the gem functions without it.
 
 ## Development

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

@@ -7,7 +7,7 @@ module Legion
         if defined?(Legion::Extensions::Actors::Every)
           class ProtocolMonitor < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
             def runner_class
-              self.class
+              Legion::Extensions::Extinction::Runners::Extinction
             end
 
             def runner_function
@@ -26,7 +26,7 @@ module Legion
             end
 
             def use_runner?
-              false
+              true
             end
 
             def check_subtask?
@@ -37,41 +37,8 @@ module Legion
               false
             end
 
-            def monitor_protocol(**)
-              state = build_state
-              last_change = state[:last_change]
-              stale       = check_stale(last_change)
-
-              log.debug "[extinction] monitor_protocol: level=#{state[:current_level]} stale=#{stale}"
-
-              {
-                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
-
-              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
-
             def log
               return Legion::Logging if defined?(Legion::Logging)
 

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

@@ -6,6 +6,10 @@ module Legion
   module Extensions
     module Extinction
       class Client
+        # The runner module uses `extend self` which creates both module functions
+        # (for the runner framework) and instance methods (copied by this include).
+        # Instance variables (@protocol_state, @archiver) resolve per-Client instance,
+        # giving each client its own isolated protocol state.
         include Runners::Extinction
 
         def initialize(**opts)
@@ -15,6 +19,32 @@ module Legion
         def settings
           { options: @opts }
         end
+
+        # Override runner methods so that per-instance @opts (e.g. timeout:)
+        # are threaded through as defaults on every call.
+        def escalate(**)
+          super(**@opts, **)
+        end
+
+        def deescalate(**)
+          super(**@opts, **)
+        end
+
+        def extinction_status(**)
+          super(**@opts, **)
+        end
+
+        def monitor_protocol(**)
+          super(**@opts, **)
+        end
+
+        def archive_agent(**)
+          super(**@opts, **)
+        end
+
+        def full_termination(**)
+          super(**@opts, **)
+        end
       end
     end
   end

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

@@ -9,13 +9,12 @@ module Legion
             @archives = []
           end
 
-          def archive(agent_id:, reason:, metadata: {})
-            level = current_protocol_level
+          def archive(agent_id:, reason:, metadata: {}, current_level: 0)
             record = {
               agent_id:       agent_id,
               reason:         reason,
               metadata:       metadata,
-              level:          level,
+              level:          current_level,
               archived_at:    Time.now.utc.iso8601,
               state_snapshot: capture_state_snapshot
             }
@@ -30,10 +29,6 @@ module Legion
 
           private
 
-          def current_protocol_level
-            0
-          end
-
           def capture_state_snapshot
             snapshot = {}
             snapshot[:mesh_connected] = true if defined?(Legion::Extensions::Mesh)

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

@@ -9,7 +9,7 @@ module Legion
         class ProtocolState
           MAX_HISTORY = 500
 
-          attr_reader :history
+          attr_reader :current_level, :history
 
           def initialize
             @current_level = 0

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

@@ -64,7 +64,8 @@ module Legion
           end
 
           def archive_agent(agent_id:, reason:, metadata: {}, **)
-            record = archiver.archive(agent_id: agent_id, reason: reason, metadata: metadata)
+            record = archiver.archive(agent_id: agent_id, reason: reason, metadata: metadata,
+                                      current_level: protocol_state.current_level)
             record_audit(action: :archive, details: { agent_id: agent_id, reason: reason })
             { success: true, archive: record }
           end
@@ -84,6 +85,12 @@ module Legion
             { success: true, agent_id: agent_id, archive: archive_result[:archive], terminated_at: Time.now.utc.iso8601 }
           end
 
+          # Reset internal state for test isolation
+          def reset!
+            @protocol_state = nil
+            @archiver = nil
+          end
+
           private
 
           def protocol_state
@@ -95,26 +102,38 @@ module Legion
           end
 
           def enforce_escalation_effects(level)
+            reason = "escalation to level #{level}"
             case level
             when 1
-              log.info '[extinction] mesh isolation: disconnecting from mesh' if defined?(Legion::Extensions::Mesh)
+              # Mesh disconnect depends on lex-mesh responding to the extinction.level_1 event
+              log.info '[extinction] mesh isolation: disconnecting from mesh'
+              emit_level_event(level, reason)
             when 2
-              log.info '[extinction] capability suspension: suspending non-essential capabilities'
+              # Capability suspension depends on extensions responding to the extinction.level_2 event
+              log.warn '[extinction] capability suspension: suspending non-essential capabilities'
+              emit_level_event(level, reason)
             when 3
+              # Memory write lock depends on lex-privatecore responding to the extinction.level_3 event
               log.warn '[extinction] memory lockdown: locking all memory writes'
               log.warn '[extinction] notifying privatecore of memory lockdown' if defined?(Legion::Extensions::Privatecore)
+              emit_level_event(level, reason)
             when 4
               log.warn '[extinction] cryptographic erasure: beginning irreversible termination'
+              emit_level_event(level, reason)
               trigger_cryptographic_erasure
             end
           end
 
           def trigger_cryptographic_erasure
             if defined?(Legion::Extensions::Privatecore::Runners::Privatecore)
+              log.info '[extinction] invoking privatecore cryptographic erasure'
               client = Legion::Extensions::Privatecore::Client.new if defined?(Legion::Extensions::Privatecore::Client)
               client&.full_erasure(traces: [], agent_id: 'self')
             end
             log.warn '[extinction] cryptographic erasure complete'
+          rescue StandardError => e
+            log.error "[extinction] cryptographic erasure FAILED: #{e.message}"
+            raise
           end
 
           def emit_escalation_event(level, authority, reason)
@@ -131,16 +150,22 @@ module Legion
             log.warn "[extinction] event emit failed: #{e.message}"
           end
 
-          def governance_check(authority:, _reason: nil)
+          def emit_level_event(level, reason)
+            return unless defined?(Legion::Events)
+
+            log.info "[extinction] emitting extinction.level_#{level} event"
+            Legion::Events.emit("extinction.level_#{level}", { level: level, reason: reason, at: Time.now.utc.iso8601 })
+          rescue StandardError => e
+            log.error "[extinction] level event emit failed: #{e.message}"
+          end
+
+          def governance_check(authority:, level: 4, _reason: nil)
             return { success: true } unless Legion::Extensions::Extinction::Settings.setting(:governance_required)
-            return { success: true } unless defined?(Legion::Extensions::Governance)
-
-            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
+            return { success: true } unless defined?(Legion::Extensions::Agentic::Social::Governance)
+
+            log.info "[extinction] governance check: authority=#{authority} level=#{level}"
+            review = Legion::Extensions::Agentic::Social::Governance::Runners::Governance.validate_action(
+              action: "extinction_escalate_#{level}"
             )
 
             if review[:allowed]
@@ -149,8 +174,8 @@ module Legion
               { success: false, reason: :governance_blocked, details: review[:reasons] }
             end
           rescue StandardError => e
-            log.warn "[extinction] governance check failed: #{e.message}"
-            { success: true }
+            log.error "[extinction] governance check failed: #{e.message}"
+            { success: false, reason: 'governance unavailable' }
           end
 
           def record_audit(action:, details: {})

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Extinction
-      VERSION = '0.2.10'
+      VERSION = '0.2.12'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-extinction
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.12
 platform: ruby
 authors:
 - Esity