lex-cognitive-avalanche 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6567ff48d15aa79fa8c5ff8766debc2450945d512170b24d35ffe7a066b60734
+  data.tar.gz: fbf7bbb237b72fd3d50611b4711a1332d2915d5ce301b4dc51592f3956aad276
+SHA512:
+  metadata.gz: 8202662f77b3ea2642aaee609a8a2b5312ee38e79d64391d1277375e48ba9d8e3046ad1878c40d6a720880992c817a7bf31fcd7b77b7c5d4017162981befa2c5
+  data.tar.gz: a349476ee03ae01fcffb805b455ff26f630a9b1b12c6445fa4f3dab38a839d5c125be6832441c53d295156f03a5ed39799c6a92d4adc14aa67709efa47810545

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  release:
+    needs: ci
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,2 @@
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format documentation

data/.rubocop.yml

@@ -0,0 +1,64 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 160
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/ModuleLength:
+  Max: 150
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/ParameterLists:
+  Max: 8
+  MaxOptionalParameters: 8
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 17
+
+Style/Documentation:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'
+
+Naming/FileName:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Naming/PredicatePrefix:
+  Enabled: false

data/CLAUDE.md

@@ -0,0 +1,74 @@
+# lex-cognitive-avalanche
+
+**Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Cascading thought-chain model for LegionIO. Models how small perturbations become massive cognitive avalanches: snowpack stability, trigger events, cascade propagation, and debris fields. Used to detect and model runaway thought cascades — both creative (productive cascades) and chaotic (destructive spirals).
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-avalanche`
+- **Version**: `0.1.0`
+- **Module**: `Legion::Extensions::CognitiveAvalanche`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_avalanche/
+  cognitive_avalanche.rb
+  version.rb
+  client.rb
+  helpers/
+    constants.rb
+    avalanche_engine.rb
+    snowpack.rb
+    cascade.rb
+  runners/
+    cognitive_avalanche.rb
+```
+
+## Key Constants
+
+From `helpers/constants.rb`:
+
+- `SNOWPACK_TYPES` — `%i[ideas emotions memories associations impulses]`
+- `CASCADE_TYPES` — `%i[creative emotional analytical chaotic convergent]`
+- `MAX_SNOWPACKS` = `100`, `MAX_CASCADE_HISTORY` = `500`
+- `TRIGGER_THRESHOLD` = `0.75` (depth >= this makes snowpack trigger-ready)
+- `ACCUMULATION_RATE` = `0.06`, `MELT_RATE` = `0.02`
+- `STABILITY_LABELS` — `0.8+` = `:bedrock`, `0.6` = `:moderate`, `0.4` = `:unstable`, `0.2` = `:critical`, below = `:catastrophic`
+- `MAGNITUDE_LABELS` — `0.8+` = `:devastating`, `0.6` = `:major`, `0.4` = `:significant`, `0.2` = `:moderate`, below = `:minor`
+
+## Runners
+
+All methods in `Runners::CognitiveAvalanche` (`extend self`):
+
+- `create_snowpack(snowpack_type:, domain:, content:, depth: 0.0, stability: 1.0)` — creates a new accumulating snowpack; `snowpack_type`, `domain`, and `content` are required
+- `trigger(snowpack_id:, force: 0.5, cascade_type: :chaotic)` — triggers an avalanche from a snowpack if depth is sufficient; produces a cascade record
+- `accumulate(rate: ACCUMULATION_RATE)` — applies accumulation to all snowpacks (depth increases)
+- `list_snowpacks` — returns all snowpacks with their current state
+- `terrain_status` — returns terrain report: total snowpacks, stability averages, recent cascade history
+
+## Helpers
+
+- `AvalancheEngine` — manages snowpacks and cascade history. `trigger` produces `Cascade` objects when depth >= threshold.
+- `Snowpack` — accumulating thought store with `depth`, `stability`, `snowpack_type`, `domain`. Stability degrades under accumulation and recovers during melt. `trigger_ready?` checks depth vs `TRIGGER_THRESHOLD`.
+- `Cascade` — records a triggered avalanche: `cascade_type`, `magnitude`, `source_snowpack_id`, `debris` (residual fragments from the cascade).
+
+## Integration Points
+
+- `lex-cognitive-dwell` and `lex-cognitive-echo` both model persistence of cognitive content; avalanche models the threshold crossing where that persistence becomes runaway.
+- `lex-tick` can call `accumulate` on each tick to model slow pressure buildup, with `trigger` called when external force is applied (e.g., a high-intensity signal).
+- `cascade_type: :creative` and `:analytical` are positive cascades; `:chaotic` and `:emotional` represent instability.
+
+## Development Notes
+
+- `create_snowpack` requires all three arguments (`snowpack_type`, `domain`, `content`) — missing any raises `ArgumentError`.
+- `AvalancheEngine` state is in-memory only; history cap enforced via `MAX_CASCADE_HISTORY`.
+- `accumulate_all!` is the periodic maintenance runner — intended to be called every tick or at set intervals.
+- Cascade debris represents unprocessed fragments after the avalanche — callers can read these as input for downstream extensions (e.g., feed debris into memory traces).

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rspec', '~> 3.13'
+  gem 'rubocop', '~> 1.75', require: false
+  gem 'rubocop-rspec', require: false
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/README.md

@@ -0,0 +1,44 @@
+# lex-cognitive-avalanche
+
+Cascading thought-chain model for LegionIO. Models how small perturbations become massive cognitive avalanches through snowpack accumulation, trigger events, and cascade propagation.
+
+## What It Does
+
+Thoughts accumulate like snow: slow buildup increases depth, reducing stability over time. When depth crosses a threshold and external force is applied, an avalanche triggers. The cascade type determines the character of the runaway — creative cascades are productive bursts of association, chaotic cascades are destabilizing spirals.
+
+The extension tracks snowpacks by type (ideas, emotions, memories, associations, impulses) and domain, records cascade history with magnitude scores, and provides terrain stability reports.
+
+## Usage
+
+```ruby
+client = Legion::Extensions::CognitiveAvalanche::Client.new
+
+pack = client.create_snowpack(
+  snowpack_type: :ideas,
+  domain: :problem_solving,
+  content: 'unprocessed ideas about the architecture',
+  stability: 0.8
+)
+
+client.accumulate(rate: 0.06)   # call periodically to build depth
+
+cascade = client.trigger(
+  snowpack_id: pack[:snowpack][:id],
+  force: 0.6,
+  cascade_type: :creative
+)
+
+client.terrain_status
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-avalanche.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_avalanche/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-avalanche'
+  spec.version       = Legion::Extensions::CognitiveAvalanche::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Cognitive Avalanche'
+  spec.description   = 'Cascading thought-chain model for LegionIO — snowpack stability, trigger events, ' \
+                       'cascade propagation, and debris fields model how small perturbations become massive cognitive avalanches'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-avalanche'
+  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-cognitive-avalanche'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-cognitive-avalanche'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-cognitive-avalanche'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-cognitive-avalanche/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAvalanche
+      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

data/lib/legion/extensions/cognitive_avalanche/helpers/avalanche_engine.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAvalanche
+      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

data/lib/legion/extensions/cognitive_avalanche/helpers/cascade.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveAvalanche
+      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

data/lib/legion/extensions/cognitive_avalanche/helpers/constants.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAvalanche
+      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

data/lib/legion/extensions/cognitive_avalanche/helpers/snowpack.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveAvalanche
+      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

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAvalanche
+      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

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAvalanche
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/cognitive_avalanche.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require 'legion/extensions/cognitive_avalanche/version'
+require 'legion/extensions/cognitive_avalanche/helpers/constants'
+require 'legion/extensions/cognitive_avalanche/helpers/snowpack'
+require 'legion/extensions/cognitive_avalanche/helpers/cascade'
+require 'legion/extensions/cognitive_avalanche/helpers/avalanche_engine'
+require 'legion/extensions/cognitive_avalanche/runners/cognitive_avalanche'
+require 'legion/extensions/cognitive_avalanche/client'
+
+module Legion
+  module Extensions
+    module CognitiveAvalanche
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-avalanche
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Cascading thought-chain model for LegionIO — snowpack stability, trigger
+  events, cascade propagation, and debris fields model how small perturbations become
+  massive cognitive avalanches
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- README.md
+- lex-cognitive-avalanche.gemspec
+- lib/legion/extensions/cognitive_avalanche.rb
+- lib/legion/extensions/cognitive_avalanche/client.rb
+- lib/legion/extensions/cognitive_avalanche/helpers/avalanche_engine.rb
+- lib/legion/extensions/cognitive_avalanche/helpers/cascade.rb
+- lib/legion/extensions/cognitive_avalanche/helpers/constants.rb
+- lib/legion/extensions/cognitive_avalanche/helpers/snowpack.rb
+- lib/legion/extensions/cognitive_avalanche/runners/cognitive_avalanche.rb
+- lib/legion/extensions/cognitive_avalanche/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-avalanche
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-avalanche
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-avalanche
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-avalanche
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-avalanche
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-avalanche/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Cognitive Avalanche
+test_files: []