lex-agentic-defense 0.1.0

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Extinction
+          module Helpers
+            class ProtocolState
+              MAX_HISTORY = 500
+
+              attr_reader :current_level, :history, :active
+
+              def initialize
+                @current_level = 0 # 0 = normal operation
+                @active = false
+                @history = []
+                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)
+
+                @current_level = level
+                @active = true
+                @history << {
+                  action: :escalate, level: level, authority: authority,
+                  reason: reason, at: Time.now.utc
+                }
+                trim_history
+                save_to_local
+                :escalated
+              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)
+
+                @current_level = target_level
+                @active = target_level.positive?
+                @history << {
+                  action: :deescalate, level: target_level, authority: authority,
+                  reason: reason, at: Time.now.utc
+                }
+                trim_history
+                save_to_local
+                :deescalated
+              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
+                }
+              end
+
+              def save_to_local
+                return unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
+
+                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
+                }
+                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
+
+                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
+              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)
+                  )
+                end
+              rescue StandardError
+                []
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# 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/lib/legion/extensions/agentic/defense/extinction/runners/extinction.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        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 }
+                end
+              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
+              end
+
+              def extinction_status(**)
+                status = protocol_state.to_h
+                Legion::Logging.debug "[extinction] status: level=#{status[:current_level]} active=#{status[:active]}"
+                status
+              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'
+                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)
+                }
+              end
+
+              STALE_ESCALATION_THRESHOLD = 86_400
+
+              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
+
+                return unless level == 4
+
+                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'
+                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
+                end
+                Legion::Logging.warn '[extinction] all active workers terminated'
+              end
+
+              def emit_escalation_event(level, authority, reason)
+                return unless defined?(Legion::Events)
+
+                info = Helpers::Levels.level_info(level)
+                Legion::Events.emit("extinction.#{info[:name]}", {
+                                      level: level, authority: authority, reason: reason, at: Time.now.utc
+                                    })
+              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
+
+                Legion::Logging.warn "[extinction] STALE: level=#{level} has been active > 24 hours"
+                return unless defined?(Legion::Events)
+
+                Legion::Events.emit('extinction.stale_escalation', {
+                                      level: level, since: last_escalation[:at],
+                                      hours: ((Time.now.utc - last_escalation[:at]) / 3600).round(1)
+                                    })
+              end
+
+              def protocol_state
+                @protocol_state ||= Helpers::ProtocolState.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Extinction
+          VERSION = '0.2.0'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/extinction.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/extinction/version'
+require 'legion/extensions/agentic/defense/extinction/helpers/levels'
+require 'legion/extensions/agentic/defense/extinction/helpers/protocol_state'
+require 'legion/extensions/agentic/defense/extinction/runners/extinction'
+require 'legion/extensions/agentic/defense/extinction/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Extinction
+        end
+      end
+    end
+
+    if defined?(Legion::Data::Local)
+      Legion::Data::Local.register_migrations(
+        name: :extinction,
+        path: File.join(__dir__, 'extinction', 'local_migrations')
+      )
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/friction/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Friction
+          class Client
+            include Runners::CognitiveFriction
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/friction/helpers/constants.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Friction
+          module Helpers
+            module Constants
+              MAX_TRANSITIONS = 300
+
+              DEFAULT_FRICTION = 0.3
+              FRICTION_BOOST = 0.1
+              FRICTION_DECAY = 0.03
+              MOMENTUM_THRESHOLD = 0.7
+              INERTIA_THRESHOLD = 0.6
+
+              FRICTION_LABELS = {
+                (0.8..)     => :locked,
+                (0.6...0.8) => :resistant,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :smooth,
+                (..0.2)     => :frictionless
+              }.freeze
+
+              TRANSITION_OUTCOMES = %i[completed resisted deferred forced].freeze
+
+              STATE_TYPES = %i[
+                focus_mode rest_mode social_mode analytical_mode
+                creative_mode vigilant_mode reflective_mode
+              ].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/friction/helpers/friction_engine.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Friction
+          module Helpers
+            class FrictionEngine
+              include Constants
+
+              def initialize
+                @transitions    = {}
+                @friction_map   = {}
+                @current_state  = :rest_mode
+              end
+
+              def set_current_state(state:)
+                @current_state = state.to_sym
+              end
+
+              attr_reader :current_state
+
+              def set_friction(from_state:, to_state:, friction:)
+                key = :"#{from_state}_to_#{to_state}"
+                @friction_map[key] = friction.to_f.clamp(0.0, 1.0)
+              end
+
+              def get_friction(from_state:, to_state:)
+                key = :"#{from_state}_to_#{to_state}"
+                @friction_map.fetch(key, DEFAULT_FRICTION)
+              end
+
+              def attempt_transition(to_state:, force: 0.5)
+                prune_if_needed
+                friction = get_friction(from_state: @current_state, to_state: to_state)
+                transition = StateTransition.new(
+                  from_state: @current_state,
+                  to_state:   to_state,
+                  friction:   friction
+                )
+                transition.attempt!(force: force)
+                @current_state = to_state.to_sym if transition.completed?
+                @transitions[transition.id] = transition
+                transition
+              end
+
+              def force_transition(to_state:)
+                prune_if_needed
+                friction = get_friction(from_state: @current_state, to_state: to_state)
+                transition = StateTransition.new(
+                  from_state: @current_state,
+                  to_state:   to_state,
+                  friction:   friction
+                )
+                transition.force!
+                @current_state = to_state.to_sym
+                @transitions[transition.id] = transition
+                transition
+              end
+
+              def transition_history(limit: 10)
+                @transitions.values.sort_by(&:created_at).last(limit)
+              end
+
+              def successful_transitions
+                @transitions.values.select(&:completed?)
+              end
+
+              def resisted_transitions
+                @transitions.values.select { |t| t.outcome == :resisted }
+              end
+
+              def success_rate
+                return 0.0 if @transitions.empty?
+
+                (successful_transitions.size.to_f / @transitions.size).round(4)
+              end
+
+              def average_friction
+                return 0.0 if @transitions.empty?
+
+                frictions = @transitions.values.map(&:friction)
+                (frictions.sum / frictions.size).round(10)
+              end
+
+              def highest_friction_paths(limit: 5)
+                @friction_map.sort_by { |_, v| -v }.first(limit).map do |key, friction|
+                  parts = key.to_s.split('_to_')
+                  { from: parts[0]&.to_sym, to: parts[1]&.to_sym, friction: friction }
+                end
+              end
+
+              def friction_report
+                {
+                  current_state:     @current_state,
+                  total_transitions: @transitions.size,
+                  successful:        successful_transitions.size,
+                  resisted:          resisted_transitions.size,
+                  success_rate:      success_rate,
+                  average_friction:  average_friction,
+                  friction_paths:    @friction_map.size,
+                  highest_friction:  highest_friction_paths(limit: 3)
+                }
+              end
+
+              def to_h
+                {
+                  current_state:     @current_state,
+                  total_transitions: @transitions.size,
+                  success_rate:      success_rate,
+                  average_friction:  average_friction,
+                  friction_paths:    @friction_map.size
+                }
+              end
+
+              private
+
+              def prune_if_needed
+                return if @transitions.size < MAX_TRANSITIONS
+
+                oldest = @transitions.values.min_by(&:created_at)
+                @transitions.delete(oldest.id) if oldest
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/friction/helpers/state_transition.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Friction
+          module Helpers
+            class StateTransition
+              include Constants
+
+              attr_reader :id, :from_state, :to_state, :friction, :outcome, :force_applied,
+                          :created_at
+
+              def initialize(from_state:, to_state:, friction: DEFAULT_FRICTION)
+                @id            = SecureRandom.uuid
+                @from_state    = from_state.to_sym
+                @to_state      = to_state.to_sym
+                @friction      = friction.to_f.clamp(0.0, 1.0)
+                @outcome       = nil
+                @force_applied = 0.0
+                @created_at    = Time.now.utc
+              end
+
+              def attempt!(force: 0.5)
+                @force_applied = force.to_f.clamp(0.0, 1.0)
+                @outcome = if @force_applied > @friction
+                             :completed
+                           elsif @force_applied > (@friction * 0.7)
+                             :deferred
+                           else
+                             :resisted
+                           end
+                self
+              end
+
+              def force!(force: 1.0)
+                @force_applied = force.to_f.clamp(0.0, 1.0)
+                @outcome = :forced
+                self
+              end
+
+              def completed?
+                %i[completed forced].include?(@outcome)
+              end
+
+              def friction_label
+                match = FRICTION_LABELS.find { |range, _| range.cover?(@friction) }
+                match ? match.last : :locked
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  from_state:     @from_state,
+                  to_state:       @to_state,
+                  friction:       @friction,
+                  friction_label: friction_label,
+                  outcome:        @outcome,
+                  force_applied:  @force_applied,
+                  completed:      completed?,
+                  created_at:     @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/friction/runners/cognitive_friction.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Friction
+          module Runners
+            module CognitiveFriction
+              include Helpers::Constants
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def set_current_state(state:, engine: nil, **)
+                eng = engine || default_engine
+                eng.set_current_state(state: state)
+                { success: true, state: eng.current_state }
+              end
+
+              def set_friction(from_state:, to_state:, friction:, engine: nil, **)
+                eng = engine || default_engine
+                eng.set_friction(from_state: from_state, to_state: to_state, friction: friction)
+                { success: true, from_state: from_state, to_state: to_state, friction: friction }
+              end
+
+              def get_friction(from_state:, to_state:, engine: nil, **)
+                eng = engine || default_engine
+                friction = eng.get_friction(from_state: from_state, to_state: to_state)
+                { success: true, from_state: from_state, to_state: to_state, friction: friction }
+              end
+
+              def attempt_transition(to_state:, engine: nil, force: 0.5, **)
+                eng = engine || default_engine
+                transition = eng.attempt_transition(to_state: to_state, force: force)
+                { success: true, transition: transition.to_h, current_state: eng.current_state }
+              end
+
+              def force_transition(to_state:, engine: nil, **)
+                eng = engine || default_engine
+                transition = eng.force_transition(to_state: to_state)
+                { success: true, transition: transition.to_h, current_state: eng.current_state }
+              end
+
+              def transition_history(engine: nil, limit: 10, **)
+                eng = engine || default_engine
+                history = eng.transition_history(limit: limit).map(&:to_h)
+                { success: true, history: history, count: history.size }
+              end
+
+              def success_rate(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, success_rate: eng.success_rate }
+              end
+
+              def average_friction(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, average_friction: eng.average_friction }
+              end
+
+              def highest_friction_paths(engine: nil, limit: 5, **)
+                eng = engine || default_engine
+                paths = eng.highest_friction_paths(limit: limit)
+                { success: true, paths: paths, count: paths.size }
+              end
+
+              def friction_report(engine: nil, **)
+                eng = engine || default_engine
+                { success: true, report: eng.friction_report }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::FrictionEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/friction/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Friction
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/friction.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'friction/version'
+require_relative 'friction/helpers/constants'
+require_relative 'friction/helpers/state_transition'
+require_relative 'friction/helpers/friction_engine'
+require_relative 'friction/runners/cognitive_friction'
+require_relative 'friction/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Friction
+        end
+      end
+    end
+  end
+end