lex-agentic-defense 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 38b6880ab2168a8ec8e0e037c8f031d175eb30312cea1b00981b7d5b67a631b1
+  data.tar.gz: ee8f26503794b5f3168120b1bd9537f9fdcad7eedfb5dd0efab75b016ce55b59
+SHA512:
+  metadata.gz: 8cfe651310f156f79c8c1476e210fd17b90a2344d689d5b636edd94396d59353b42f8ae53e36f4e4e400f0c7584272dbc79ae6d0fa434fded2a8f2f3c4e4fcd7
+  data.tar.gz: 929f72c0515d624586865faed6ed4ecd65cfa8f3c65849f66363539b1d7c66c2b65210c8cca8190f4dccf19eb4fe5fe4f9634e55a61d477e4662e9a841fa0eae

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-03-18
+
+### Added
+- Initial release as domain consolidation gem
+- Consolidated source extensions into unified domain gem under `Legion::Extensions::Agentic::<Domain>`
+- All sub-modules loaded from single entry point
+- Full spec suite with zero failures
+- RuboCop compliance across all files

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew Iverson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,13 @@
+# lex-agentic-defense
+
+LEX agentic defense domain: threat detection, stress response, boundaries
+
+## Sub-modules
+
+*(populated as extensions are consolidated)*
+
+## Installation
+
+```ruby
+gem 'lex-agentic-defense'
+```

data/lex-agentic-defense.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/agentic/defense/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-agentic-defense'
+  spec.version       = Legion::Extensions::Agentic::Defense::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Agentic Defense'
+  spec.description   = 'LEX agentic defense domain: threat detection, stress response, boundaries'
+  spec.homepage      = 'https://github.com/LegionIO/lex-agentic-defense'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']      = spec.homepage
+  spec.metadata['source_code_uri']   = spec.homepage
+  spec.metadata['changelog_uri']     = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir.glob('{lib,spec}/**/*.rb') + %w[lex-agentic-defense.gemspec Gemfile LICENSE README.md CHANGELOG.md]
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rspec', '~> 3.13'
+  spec.add_development_dependency 'rubocop', '~> 1.60'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.26'
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Avalanche
+          class Client
+            include Runners::CognitiveAvalanche
+
+            attr_reader :engine
+
+            def initialize(engine: nil, **)
+              @engine           = engine || Helpers::AvalancheEngine.new
+              @avalanche_engine = @engine
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/avalanche/helpers/avalanche_engine.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Avalanche
+          module Helpers
+            class AvalancheEngine
+              include Constants
+
+              attr_reader :snowpacks, :cascade_history
+
+              def initialize
+                @snowpacks       = {}
+                @cascade_history = []
+              end
+
+              def create_snowpack(snowpack_type:, domain:, content:, depth: 0.0, stability: 1.0, **)
+                raise ArgumentError, 'snowpack limit reached' if @snowpacks.size >= Constants::MAX_SNOWPACKS
+
+                pack = Snowpack.new(
+                  snowpack_type: snowpack_type,
+                  domain:        domain,
+                  content:       content,
+                  depth:         depth,
+                  stability:     stability
+                )
+                @snowpacks[pack.id] = pack
+                { success: true, snowpack_id: pack.id, snowpack: pack.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def trigger(snowpack_id:, force:, cascade_type: :chaotic, **)
+                pack = @snowpacks[snowpack_id]
+                raise ArgumentError, "snowpack not found: #{snowpack_id}" unless pack
+
+                pack.destabilize!(force)
+                instability = pack.instability
+
+                return { success: true, triggered: false, instability: instability, reason: :below_threshold } \
+                  if (force + instability) < Constants::TRIGGER_THRESHOLD
+
+                cascade = Cascade.new(
+                  cascade_type:      cascade_type,
+                  trigger_source:    snowpack_id,
+                  magnitude:         ((force + instability) / 2.0).clamp(0.0, 1.0).round(10),
+                  propagation_speed: instability.round(10),
+                  debris:            [pack.content]
+                )
+                record_cascade(cascade)
+                { success: true, triggered: true, cascade_id: cascade.id, cascade: cascade.to_h, instability: instability }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def accumulate_all!(rate: Constants::ACCUMULATION_RATE, **)
+                count = 0
+                @snowpacks.each_value do |pack|
+                  pack.accumulate!(rate)
+                  count += 1
+                end
+                { success: true, packs_accumulated: count, rate: rate }
+              end
+
+              def melt_all!(rate: Constants::MELT_RATE, **)
+                count = 0
+                @snowpacks.each_value do |pack|
+                  pack.melt!(rate)
+                  count += 1
+                end
+                { success: true, packs_melted: count, rate: rate }
+              end
+
+              def active_cascades
+                @cascade_history.select(&:active?)
+              end
+
+              def most_unstable
+                @snowpacks.values.min_by(&:stability)
+              end
+
+              def terrain_report
+                packs           = @snowpacks.values
+                active_cascades = self.active_cascades
+                critical_packs  = packs.select(&:critical?)
+                unstable_packs  = packs.select(&:unstable?)
+
+                {
+                  total_snowpacks:  packs.size,
+                  critical_count:   critical_packs.size,
+                  unstable_count:   unstable_packs.size,
+                  stable_count:     packs.count(&:stable?),
+                  active_cascades:  active_cascades.size,
+                  cascade_history:  @cascade_history.size,
+                  avg_stability:    avg_stability(packs),
+                  avg_depth:        avg_depth(packs),
+                  most_unstable_id: most_unstable&.id,
+                  recent_cascades:  recent_cascades(5)
+                }
+              end
+
+              private
+
+              def record_cascade(cascade)
+                @cascade_history << cascade
+                @cascade_history.shift if @cascade_history.size > Constants::MAX_CASCADE_HISTORY
+              end
+
+              def avg_stability(packs)
+                return 0.0 if packs.empty?
+
+                (packs.sum(&:stability) / packs.size.to_f).round(10)
+              end
+
+              def avg_depth(packs)
+                return 0.0 if packs.empty?
+
+                (packs.sum(&:depth) / packs.size.to_f).round(10)
+              end
+
+              def recent_cascades(count)
+                @cascade_history.last(count).map(&:to_h)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/avalanche/helpers/cascade.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Avalanche
+          module Helpers
+            class Cascade
+              include Constants
+
+              attr_reader :id, :cascade_type, :trigger_source, :started_at
+              attr_accessor :magnitude, :propagation_speed, :debris
+
+              def initialize(cascade_type:, trigger_source:, magnitude:, propagation_speed: 0.5, debris: [], **)
+                raise ArgumentError, "unknown cascade_type: #{cascade_type}" unless Constants::CASCADE_TYPES.include?(cascade_type)
+
+                @id                = SecureRandom.uuid
+                @cascade_type      = cascade_type
+                @trigger_source    = trigger_source
+                @magnitude         = magnitude.clamp(0.0, 1.0)
+                @propagation_speed = propagation_speed.clamp(0.0, 1.0)
+                @debris            = Array(debris).dup
+                @active            = true
+                @started_at        = Time.now.utc
+              end
+
+              def propagate!(rate = 0.1)
+                return unless @active
+
+                @magnitude = (@magnitude + rate.abs).clamp(0.0, 1.0).round(10)
+              end
+
+              def dissipate!(rate = 0.08)
+                @magnitude = (@magnitude - rate.abs).clamp(0.0, 1.0).round(10)
+                @active    = false if @magnitude <= 0.0
+              end
+
+              def active?
+                @active && @magnitude > 0.0
+              end
+
+              def spent?
+                !@active || @magnitude <= 0.0
+              end
+
+              def magnitude_label
+                Constants.label_for(:MAGNITUDE_LABELS, @magnitude)
+              end
+
+              def add_debris(item)
+                @debris << item
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  cascade_type:      @cascade_type,
+                  trigger_source:    @trigger_source,
+                  magnitude:         @magnitude,
+                  magnitude_label:   magnitude_label,
+                  propagation_speed: @propagation_speed,
+                  debris:            @debris.dup,
+                  active:            @active,
+                  started_at:        @started_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Avalanche
+          module Helpers
+            module Constants
+              MAX_SNOWPACKS = 100
+              MAX_CASCADE_HISTORY = 500
+              TRIGGER_THRESHOLD  = 0.75
+              ACCUMULATION_RATE  = 0.06
+              MELT_RATE          = 0.02
+
+              SNOWPACK_TYPES = %i[ideas emotions memories associations impulses].freeze
+              CASCADE_TYPES  = %i[creative emotional analytical chaotic convergent].freeze
+
+              STABILITY_LABELS = {
+                (0.0...0.2) => :catastrophic,
+                (0.2...0.4) => :critical,
+                (0.4...0.6) => :unstable,
+                (0.6...0.8) => :moderate,
+                (0.8..1.0)  => :bedrock
+              }.freeze
+
+              MAGNITUDE_LABELS = {
+                (0.0...0.2) => :minor,
+                (0.2...0.4) => :moderate,
+                (0.4...0.6) => :significant,
+                (0.6...0.8) => :major,
+                (0.8..1.0)  => :devastating
+              }.freeze
+
+              def self.label_for(table, value)
+                const_get(table).find { |range, _| range.cover?(value.clamp(0.0, 1.0)) }&.last || :unknown
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/avalanche/helpers/snowpack.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Avalanche
+          module Helpers
+            class Snowpack
+              include Constants
+
+              attr_reader :id, :snowpack_type, :domain, :content, :created_at
+              attr_accessor :depth, :stability
+
+              def initialize(snowpack_type:, domain:, content:, depth: 0.0, stability: 1.0, **)
+                raise ArgumentError, "unknown snowpack_type: #{snowpack_type}" unless Constants::SNOWPACK_TYPES.include?(snowpack_type)
+
+                @id            = SecureRandom.uuid
+                @snowpack_type = snowpack_type
+                @domain        = domain
+                @content       = content
+                @depth         = depth.clamp(0.0, 1.0)
+                @stability     = stability.clamp(0.0, 1.0)
+                @created_at    = Time.now.utc
+              end
+
+              def accumulate!(rate = Constants::ACCUMULATION_RATE)
+                @depth = (@depth + rate.abs).clamp(0.0, 1.0).round(10)
+              end
+
+              def compact!
+                @stability = (@stability + 0.05).clamp(0.0, 1.0).round(10)
+              end
+
+              def melt!(rate = Constants::MELT_RATE)
+                @depth = (@depth - rate.abs).clamp(0.0, 1.0).round(10)
+              end
+
+              def destabilize!(force)
+                @stability = (@stability - force.abs).clamp(0.0, 1.0).round(10)
+              end
+
+              def stable?
+                @stability >= 0.6
+              end
+
+              def unstable?
+                @stability < 0.4
+              end
+
+              def critical?
+                @stability < 0.2
+              end
+
+              def stability_label
+                Constants.label_for(:STABILITY_LABELS, @stability)
+              end
+
+              def instability
+                (1.0 - @stability).round(10)
+              end
+
+              def to_h
+                {
+                  id:              @id,
+                  snowpack_type:   @snowpack_type,
+                  domain:          @domain,
+                  content:         @content,
+                  depth:           @depth,
+                  stability:       @stability,
+                  stable:          stable?,
+                  unstable:        unstable?,
+                  critical:        critical?,
+                  stability_label: stability_label,
+                  created_at:      @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/avalanche/runners/cognitive_avalanche.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Avalanche
+          module Runners
+            module CognitiveAvalanche
+              extend self
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def create_snowpack(snowpack_type: nil, domain: nil, content: nil,
+                                  depth: 0.0, stability: 1.0, engine: nil, **)
+                raise ArgumentError, 'snowpack_type is required' if snowpack_type.nil?
+                raise ArgumentError, 'domain is required'        if domain.nil?
+                raise ArgumentError, 'content is required'       if content.nil?
+
+                avalanche_engine(engine).create_snowpack(
+                  snowpack_type: snowpack_type,
+                  domain:        domain,
+                  content:       content,
+                  depth:         depth,
+                  stability:     stability
+                )
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def trigger(snowpack_id: nil, force: 0.5, cascade_type: :chaotic, engine: nil, **)
+                raise ArgumentError, 'snowpack_id is required' if snowpack_id.nil?
+
+                avalanche_engine(engine).trigger(
+                  snowpack_id:  snowpack_id,
+                  force:        force,
+                  cascade_type: cascade_type
+                )
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def accumulate(rate: Helpers::Constants::ACCUMULATION_RATE, engine: nil, **)
+                avalanche_engine(engine).accumulate_all!(rate: rate)
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def list_snowpacks(engine: nil, **)
+                eng   = avalanche_engine(engine)
+                packs = eng.snowpacks.values.map(&:to_h)
+                { success: true, snowpacks: packs, count: packs.size }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def terrain_status(engine: nil, **)
+                report = avalanche_engine(engine).terrain_report
+                { success: true }.merge(report)
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              private
+
+              def avalanche_engine(engine)
+                engine || @avalanche_engine ||= Helpers::AvalancheEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require 'legion/extensions/agentic/defense/avalanche/version'
+require 'legion/extensions/agentic/defense/avalanche/helpers/constants'
+require 'legion/extensions/agentic/defense/avalanche/helpers/snowpack'
+require 'legion/extensions/agentic/defense/avalanche/helpers/cascade'
+require 'legion/extensions/agentic/defense/avalanche/helpers/avalanche_engine'
+require 'legion/extensions/agentic/defense/avalanche/runners/cognitive_avalanche'
+require 'legion/extensions/agentic/defense/avalanche/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Avalanche
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/bias/actors/update.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Bias
+          module Actor
+            class Update < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Defense::Bias::Runners::Bias
+              end
+
+              def runner_function
+                'update_bias'
+              end
+
+              def time
+                60
+              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/bias/client.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/bias/helpers/constants'
+require 'legion/extensions/agentic/defense/bias/helpers/bias_event'
+require 'legion/extensions/agentic/defense/bias/helpers/bias_detector'
+require 'legion/extensions/agentic/defense/bias/helpers/bias_store'
+require 'legion/extensions/agentic/defense/bias/runners/bias'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Bias
+          class Client
+            include Runners::Bias
+
+            def initialize(**)
+              @bias_detector = Helpers::BiasDetector.new
+              @bias_store    = Helpers::BiasStore.new
+            end
+
+            private
+
+            attr_reader :bias_detector, :bias_store
+          end
+        end
+      end
+    end
+  end
+end