lex-agentic-defense 0.1.0

data/lib/legion/extensions/agentic/defense/error_monitoring/actors/tick.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ErrorMonitoring
+          module Actor
+            class Tick < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Defense::ErrorMonitoring::Runners::ErrorMonitoring
+              end
+
+              def runner_function
+                'update_error_monitoring'
+              end
+
+              def time
+                15
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/error_monitoring/helpers/constants'
+require 'legion/extensions/agentic/defense/error_monitoring/helpers/error_signal'
+require 'legion/extensions/agentic/defense/error_monitoring/helpers/error_monitor'
+require 'legion/extensions/agentic/defense/error_monitoring/runners/error_monitoring'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ErrorMonitoring
+          class Client
+            include Runners::ErrorMonitoring
+
+            def initialize(monitor: nil, **)
+              @monitor = monitor || Helpers::ErrorMonitor.new
+            end
+
+            private
+
+            attr_reader :monitor
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ErrorMonitoring
+          module Helpers
+            module Constants
+              MAX_ERROR_LOG = 500
+              MAX_CONFLICT_LOG = 200
+              MAX_CORRECTIONS = 200
+
+              ERROR_RATE_ALPHA = 0.12
+              CONFLICT_ALPHA = 0.1
+              CONFIDENCE_ALPHA = 0.1
+
+              DEFAULT_ERROR_RATE = 0.1
+              DEFAULT_CONFLICT_LEVEL = 0.0
+              DEFAULT_CONFIDENCE = 0.7
+
+              POST_ERROR_SLOWDOWN = 0.3
+              SLOWDOWN_DECAY = 0.05
+              MAX_SLOWDOWN = 1.0
+
+              CONFLICT_THRESHOLD = 0.5
+              SEVERE_ERROR_THRESHOLD = 0.7
+              CORRECTION_BOOST = 0.05
+
+              ERROR_SEVERITY_LABELS = {
+                (0.8..)     => :critical,
+                (0.6...0.8) => :major,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :minor,
+                (..0.2)     => :trivial
+              }.freeze
+
+              MONITORING_STATE_LABELS = {
+                vigilant:    'heightened error sensitivity after recent errors',
+                normal:      'standard monitoring',
+                relaxed:     'low error rate, reduced monitoring',
+                overwhelmed: 'error rate too high, system stressed'
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/error_monitoring/helpers/error_monitor.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ErrorMonitoring
+          module Helpers
+            class ErrorMonitor
+              include Constants
+
+              attr_reader :error_log, :conflict_log, :corrections,
+                          :error_rate, :conflict_level, :confidence, :slowdown
+
+              def initialize
+                @error_log      = []
+                @conflict_log   = []
+                @corrections    = []
+                @error_rate     = DEFAULT_ERROR_RATE
+                @conflict_level = DEFAULT_CONFLICT_LEVEL
+                @confidence     = DEFAULT_CONFIDENCE
+                @slowdown       = 0.0
+              end
+
+              def register_error(action:, domain:, intended:, actual:, severity:)
+                signal = ErrorSignal.new(
+                  action: action, domain: domain,
+                  intended: intended, actual: actual, severity: severity
+                )
+                @error_log << signal
+                @error_log.shift while @error_log.size > MAX_ERROR_LOG
+
+                update_error_rate(severity.to_f)
+                apply_post_error_slowdown(severity.to_f)
+                update_confidence(correct: false)
+                signal
+              end
+
+              def register_success(action:, domain:)
+                update_error_rate(0.0)
+                update_confidence(correct: true)
+                decay_slowdown
+                { action: action, domain: domain, error_rate: @error_rate.round(4) }
+              end
+
+              def register_conflict(action_a:, action_b:, domain:, intensity:)
+                entry = {
+                  action_a: action_a, action_b: action_b,
+                  domain: domain, intensity: intensity.to_f.clamp(0.0, 1.0),
+                  detected_at: Time.now.utc
+                }
+                @conflict_log << entry
+                @conflict_log.shift while @conflict_log.size > MAX_CONFLICT_LOG
+
+                update_conflict_level(intensity.to_f)
+                entry
+              end
+
+              def register_correction(action:, domain:, original_error:, correction:)
+                entry = {
+                  action: action, domain: domain,
+                  original_error: original_error, correction: correction,
+                  applied_at: Time.now.utc
+                }
+                @corrections << entry
+                @corrections.shift while @corrections.size > MAX_CORRECTIONS
+
+                mark_error_corrected(action, domain)
+                update_confidence_boost
+                entry
+              end
+
+              def recent_errors(limit: 10)
+                @error_log.last(limit)
+              end
+
+              def errors_in(domain:)
+                @error_log.select { |e| e.domain == domain }
+              end
+
+              def uncorrected_errors
+                @error_log.reject(&:corrected)
+              end
+
+              def conflict_active?
+                @conflict_level >= CONFLICT_THRESHOLD
+              end
+
+              def monitoring_state
+                if @error_rate > 0.5
+                  :overwhelmed
+                elsif @slowdown > 0.1
+                  :vigilant
+                elsif @error_rate < 0.05
+                  :relaxed
+                else
+                  :normal
+                end
+              end
+
+              def tick
+                decay_slowdown
+                decay_conflict
+              end
+
+              def error_count
+                @error_log.size
+              end
+
+              def correction_rate
+                return 0.0 if @error_log.empty?
+
+                corrected = @error_log.count(&:corrected)
+                corrected.to_f / @error_log.size
+              end
+
+              def to_h
+                {
+                  error_rate:      @error_rate.round(4),
+                  conflict_level:  @conflict_level.round(4),
+                  confidence:      @confidence.round(4),
+                  slowdown:        @slowdown.round(4),
+                  state:           monitoring_state,
+                  state_label:     MONITORING_STATE_LABELS[monitoring_state],
+                  total_errors:    @error_log.size,
+                  uncorrected:     uncorrected_errors.size,
+                  correction_rate: correction_rate.round(4),
+                  conflict_active: conflict_active?
+                }
+              end
+
+              private
+
+              def update_error_rate(severity)
+                @error_rate += ERROR_RATE_ALPHA * (severity - @error_rate)
+              end
+
+              def update_conflict_level(intensity)
+                @conflict_level += CONFLICT_ALPHA * (intensity - @conflict_level)
+              end
+
+              def update_confidence(correct:)
+                target = correct ? 1.0 : 0.0
+                @confidence += CONFIDENCE_ALPHA * (target - @confidence)
+              end
+
+              def update_confidence_boost
+                @confidence = [@confidence + CORRECTION_BOOST, 1.0].min
+              end
+
+              def apply_post_error_slowdown(severity)
+                increase = POST_ERROR_SLOWDOWN * severity
+                @slowdown = [@slowdown + increase, MAX_SLOWDOWN].min
+              end
+
+              def decay_slowdown
+                @slowdown = [@slowdown - SLOWDOWN_DECAY, 0.0].max
+              end
+
+              def decay_conflict
+                @conflict_level = [@conflict_level * 0.95, 0.0].max
+              end
+
+              def mark_error_corrected(action, domain)
+                match = @error_log.reverse.find { |e| e.action == action && e.domain == domain && !e.corrected }
+                match&.mark_corrected
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/error_monitoring/helpers/error_signal.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ErrorMonitoring
+          module Helpers
+            class ErrorSignal
+              include Constants
+
+              attr_reader :action, :domain, :intended, :actual, :severity, :detected_at, :corrected
+
+              def initialize(action:, domain:, intended:, actual:, severity:)
+                @action      = action
+                @domain      = domain
+                @intended    = intended
+                @actual      = actual
+                @severity    = severity.to_f.clamp(0.0, 1.0)
+                @detected_at = Time.now.utc
+                @corrected   = false
+              end
+
+              def mark_corrected
+                @corrected = true
+              end
+
+              def severe?
+                @severity >= SEVERE_ERROR_THRESHOLD
+              end
+
+              def age
+                Time.now.utc - @detected_at
+              end
+
+              def label
+                ERROR_SEVERITY_LABELS.each { |range, lbl| return lbl if range.cover?(@severity) }
+                :trivial
+              end
+
+              def to_h
+                {
+                  action:      @action,
+                  domain:      @domain,
+                  intended:    @intended,
+                  actual:      @actual,
+                  severity:    @severity.round(4),
+                  label:       label,
+                  detected_at: @detected_at,
+                  corrected:   @corrected,
+                  age:         age.round(2)
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/error_monitoring/runners/error_monitoring.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ErrorMonitoring
+          module Runners
+            module ErrorMonitoring
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def report_error(action:, domain:, intended:, actual:, severity:, **)
+                Legion::Logging.debug "[error_monitor] error: action=#{action} domain=#{domain} severity=#{severity}"
+                signal = monitor.register_error(
+                  action: action, domain: domain,
+                  intended: intended, actual: actual, severity: severity
+                )
+                {
+                  success: true, error: signal.to_h,
+                  error_rate: monitor.error_rate.round(4),
+                  slowdown: monitor.slowdown.round(4),
+                  state: monitor.monitoring_state
+                }
+              end
+
+              def report_success(action:, domain:, **)
+                Legion::Logging.debug "[error_monitor] success: action=#{action} domain=#{domain}"
+                result = monitor.register_success(action: action, domain: domain)
+                { success: true, action: action, domain: domain, error_rate: result[:error_rate] }
+              end
+
+              def report_conflict(action_a:, action_b:, domain:, intensity:, **)
+                Legion::Logging.debug "[error_monitor] conflict: #{action_a} vs #{action_b} domain=#{domain}"
+                entry = monitor.register_conflict(
+                  action_a: action_a, action_b: action_b,
+                  domain: domain, intensity: intensity
+                )
+                { success: true, conflict: entry, conflict_active: monitor.conflict_active? }
+              end
+
+              def apply_correction(action:, domain:, original_error:, correction:, **)
+                Legion::Logging.debug "[error_monitor] correction: action=#{action} domain=#{domain}"
+                entry = monitor.register_correction(
+                  action: action, domain: domain,
+                  original_error: original_error, correction: correction
+                )
+                { success: true, correction: entry, confidence: monitor.confidence.round(4) }
+              end
+
+              def recent_errors(limit: 10, **)
+                errors = monitor.recent_errors(limit: limit.to_i).map(&:to_h)
+                Legion::Logging.debug "[error_monitor] recent_errors: #{errors.size}"
+                { success: true, errors: errors, count: errors.size }
+              end
+
+              def errors_in_domain(domain:, **)
+                errors = monitor.errors_in(domain: domain).map(&:to_h)
+                Legion::Logging.debug "[error_monitor] errors_in: domain=#{domain} count=#{errors.size}"
+                { success: true, domain: domain, errors: errors, count: errors.size }
+              end
+
+              def uncorrected_errors(**)
+                errors = monitor.uncorrected_errors.map(&:to_h)
+                Legion::Logging.debug "[error_monitor] uncorrected: #{errors.size}"
+                { success: true, errors: errors, count: errors.size }
+              end
+
+              def monitoring_state(**)
+                state = monitor.monitoring_state
+                Legion::Logging.debug "[error_monitor] state: #{state}"
+                {
+                  success: true, state: state,
+                  label: Helpers::Constants::MONITORING_STATE_LABELS[state],
+                  slowdown: monitor.slowdown.round(4),
+                  confidence: monitor.confidence.round(4)
+                }
+              end
+
+              def update_error_monitoring(**)
+                Legion::Logging.debug '[error_monitor] tick'
+                monitor.tick
+                { success: true, state: monitor.monitoring_state, slowdown: monitor.slowdown.round(4) }
+              end
+
+              def error_monitoring_stats(**)
+                Legion::Logging.debug '[error_monitor] stats'
+                { success: true, stats: monitor.to_h }
+              end
+
+              private
+
+              def monitor
+                @monitor ||= Helpers::ErrorMonitor.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/error_monitoring/version'
+require 'legion/extensions/agentic/defense/error_monitoring/helpers/constants'
+require 'legion/extensions/agentic/defense/error_monitoring/helpers/error_signal'
+require 'legion/extensions/agentic/defense/error_monitoring/helpers/error_monitor'
+require 'legion/extensions/agentic/defense/error_monitoring/runners/error_monitoring'
+require 'legion/extensions/agentic/defense/error_monitoring/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module ErrorMonitoring
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Extinction
+          module Actor
+            class ProtocolMonitor < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Defense::Extinction::Runners::Extinction
+              end
+
+              def runner_function
+                'monitor_protocol'
+              end
+
+              def time
+                300
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Extinction
+          class Client
+            include Runners::Extinction
+
+            def initialize(**)
+              @protocol_state = Helpers::ProtocolState.new
+            end
+
+            private
+
+            attr_reader :protocol_state
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        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 }
+              }.freeze
+
+              VALID_LEVELS = [1, 2, 3, 4].freeze
+
+              module_function
+
+              def valid_level?(level)
+                VALID_LEVELS.include?(level)
+              end
+
+              def level_info(level)
+                ESCALATION_LEVELS[level]
+              end
+
+              def reversible?(level)
+                ESCALATION_LEVELS.dig(level, :reversible) || false
+              end
+
+              def required_authority(level)
+                ESCALATION_LEVELS.dig(level, :authority)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end