lex-cognitive-plasticity 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '016298c044c5cdd55e761d9af284fb994ee3cb4adbdb2e0a8f5050fd8e7d4c14'
+  data.tar.gz: 6c1010c7408ceb038e29963d73e158d13d2b6f2bd2b1f8805d67dfa76c7be193
+SHA512:
+  metadata.gz: b68984844be5a42fea305de489fe52251f74daf4c1df035e220ecd3ed7d1c660f4d57fd8958e5e7b99b89e8a0712a5f0e1ad61c2b1c5e3bff17f0c964b642923
+  data.tar.gz: b488f7ae088c2d60db6cabab31e0886394fddc5c7803fceea2b5d2b2bf7808ee8a4e509e08653b0721b8080fc3bf5e53356894044399f5fee445c1c5c3129dfe

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,4 @@
+--format documentation
+--color
+--require spec_helper
+--order random

data/.rubocop.yml

@@ -0,0 +1,40 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.4
+
+Style/Documentation:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/ParameterLists:
+  Max: 8
+  MaxOptionalParameters: 8
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/CLAUDE.md

@@ -0,0 +1,107 @@
+# lex-cognitive-plasticity
+
+**Level 3 Leaf Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+
+## Purpose
+
+Neural plasticity model for adaptive learning. Neural pathways have strength (how established the connection is) and plasticity (how receptive to change). Strengthening increases strength scaled by both amount and current plasticity; plasticity itself decreases (matures) as a pathway is activated — established pathways become harder to change. Critical period mode applies a 2.5× multiplier to all strengthening, modeling sensitive developmental windows. Weak pathways (below `PRUNING_THRESHOLD = 0.15`) are pruning candidates.
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-plasticity`
+- **Module**: `Legion::Extensions::CognitivePlasticity`
+- **Version**: `0.1.0`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_plasticity/
+  version.rb
+  client.rb
+  helpers/
+    constants.rb
+    neural_pathway.rb
+    plasticity_engine.rb
+  runners/
+    cognitive_plasticity.rb
+```
+
+## Key Constants
+
+| Constant | Value | Purpose |
+|---|---|---|
+| `MAX_PATHWAYS` | `300` | Per-engine pathway capacity (auto-prunes weakest on overflow) |
+| `MAX_EVENTS` | `500` | Activation event ring buffer |
+| `DEFAULT_LEARNING_RATE` | `0.5` | Initial plasticity for new pathways |
+| `STRENGTHENING_RATE` | `0.08` | Default amount per strengthen call |
+| `PRUNING_THRESHOLD` | `0.15` | Strength below which pathway is a prune candidate |
+| `CRITICAL_PERIOD_MULTIPLIER` | `2.5` | Strengthening boost during critical period |
+| `MATURATION_RATE` | `0.01` | Plasticity reduction per activation |
+| `PLASTICITY_LABELS` | range hash | From `:crystallized` to `:highly_plastic` |
+| `STRENGTH_LABELS` | range hash | From `:nascent` to `:robust` |
+| `PATHWAY_TYPES` | `%i[synaptic structural functional homeostatic metaplastic]` | Valid pathway types |
+
+## Helpers
+
+### `Helpers::NeuralPathway`
+Individual pathway. Has `id`, `label`, `pathway_type`, `strength` (0.0–1.0), `plasticity` (0.1–1.0), and `activation_count`.
+
+- `strengthen!(amount:, critical_period:)` — effective amount = `amount * multiplier * plasticity`; increments `activation_count`; calls `mature!`
+- `weaken!(amount:)` — effective amount = `amount * plasticity`
+- `prune_candidate?` — `strength < PRUNING_THRESHOLD`
+- `mature!` — reduces plasticity by `MATURATION_RATE` (floor 0.1); called automatically on strengthen
+- `rejuvenate!(amount:)` — increases plasticity (re-opens the pathway to change)
+- `strength_label` / `plasticity_label`
+- `to_h`
+
+### `Helpers::PlasticityEngine`
+Multi-pathway manager with critical period state.
+
+- `create_pathway(label:, pathway_type:, initial_strength:)` → pathway (auto-prunes weakest if at `MAX_PATHWAYS`)
+- `strengthen_pathway(pathway_id:, amount:)` → updated pathway (applies critical_period from engine state)
+- `weaken_pathway(pathway_id:, amount:)` → updated pathway
+- `rejuvenate_pathway(pathway_id:, amount:)` → updated pathway
+- `enter_critical_period!` / `exit_critical_period!` / `critical_period?` — engine-wide mode flag
+- `prune_weak_pathways!` → count of pruned pathways
+- `pathways_by_type(pathway_type:)` → filtered list
+- `strongest_pathways(limit:)` → top N by strength
+- `weakest_pathways(limit:)` → bottom N by strength
+- `average_strength` / `average_plasticity`
+- `prune_candidates_count`
+- `plasticity_report` → aggregate stats hash
+
+## Runners
+
+Module: `Runners::CognitivePlasticity`
+
+| Runner Method | Description |
+|---|---|
+| `create_pathway(label:, pathway_type:, initial_strength:)` | Register a new pathway |
+| `strengthen_pathway(pathway_id:, amount:)` | Strengthen (respects critical period) |
+| `weaken_pathway(pathway_id:, amount:)` | Weaken a pathway |
+| `rejuvenate_pathway(pathway_id:, amount:)` | Re-open pathway to change |
+| `enter_critical_period` | Enable 2.5× strengthening multiplier |
+| `exit_critical_period` | Disable critical period |
+| `prune_weak_pathways` | Remove prune-candidate pathways |
+| `strongest_pathways(limit:)` | Top N pathways by strength |
+| `plasticity_report` | Aggregate stats |
+
+All runners return `{success: true/false, ...}` hashes.
+
+## Integration Points
+
+- `lex-coldstart` imprint window = critical period: `enter_critical_period` at imprint_window start, `exit_critical_period` at continuous_learning transition
+- `lex-memory`: neural pathways are the underlying substrate for memory trace Hebbian links
+- `lex-tick` dormant phases: `prune_weak_pathways` is a natural dormant maintenance operation
+- `lex-emotion`: high-arousal emotional events can trigger strengthening of associated pathways
+
+## Development Notes
+
+- `Client` instantiates `@default_engine = Helpers::PlasticityEngine.new` via runner memoization
+- Effective strengthening = `amount * multiplier * plasticity`: a pathway with plasticity = 0.1 only strengthens at 10% efficiency
+- Critical period multiplier (2.5×) is applied by the engine, not the pathway — the engine knows its own state
+- `MAX_PATHWAYS = 300` enforces auto-pruning at creation time: weakest pathway is removed to make room
+- Plasticity floor is 0.1 (not 0.0): pathways never become completely unmodifiable — they just become very resistant to change

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: .
+  specs:
+    lex-cognitive-plasticity (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.9)
+      public_suffix (>= 2.0.2, < 8.0)
+    ast (2.4.3)
+    bigdecimal (4.0.1)
+    diff-lcs (1.6.2)
+    json (2.19.1)
+    json-schema (6.2.0)
+      addressable (~> 2.8)
+      bigdecimal (>= 3.1, < 5)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    mcp (0.8.0)
+      json-schema (>= 4.1)
+    parallel (1.27.0)
+    parser (3.3.10.2)
+      ast (~> 2.4.1)
+      racc
+    prism (1.9.0)
+    public_suffix (7.0.5)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    regexp_parser (2.11.3)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    rubocop (1.85.1)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      mcp (~> 0.6)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-rspec (3.9.0)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.81)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+
+PLATFORMS
+  arm64-darwin-25
+  ruby
+
+DEPENDENCIES
+  lex-cognitive-plasticity!
+  rspec (~> 3.13)
+  rubocop (~> 1.75)
+  rubocop-rspec
+
+BUNDLED WITH
+   2.6.9

data/README.md

@@ -0,0 +1,58 @@
+# lex-cognitive-plasticity
+
+Neural plasticity model for LegionIO cognitive agents. Pathways have strength and plasticity; strengthening is scaled by current plasticity, which itself decreases as pathways mature. Critical period mode applies a 2.5× multiplier for accelerated learning.
+
+## What It Does
+
+- Five pathway types: `synaptic`, `structural`, `functional`, `homeostatic`, `metaplastic`
+- Strength: how established the pathway is (0.0–1.0)
+- Plasticity: how receptive to change (0.1–1.0, decays with each activation)
+- `strengthen_pathway`: effective gain = amount × plasticity (× 2.5 in critical period)
+- `weaken_pathway`: effective reduction = amount × plasticity
+- `rejuvenate_pathway`: re-open a mature pathway to change
+- Critical period: engine-wide 2.5× boost on all strengthening
+- Auto-prune: weakest pathway removed when capacity (300) is reached
+- `prune_weak_pathways`: explicit pruning of pathways below strength threshold (0.15)
+
+## Usage
+
+```ruby
+# Create a pathway
+result = runner.create_pathway(label: 'pattern_recognition_loop',
+                                pathway_type: :synaptic, initial_strength: 0.3)
+pid = result[:pathway][:id]
+
+# Enter critical period (imprint window)
+runner.enter_critical_period
+# => { success: true, critical_period: true }
+
+# Strengthen with 2.5× boost
+runner.strengthen_pathway(pathway_id: pid, amount: 0.08)
+# => { success: true, pathway: { strength: 0.40, plasticity: 0.49, activation_count: 1, ... } }
+
+# Exit critical period
+runner.exit_critical_period
+
+# Rejuvenate a mature pathway to re-open it to change
+runner.rejuvenate_pathway(pathway_id: pid, amount: 0.1)
+
+# Prune weak pathways
+runner.prune_weak_pathways
+# => { success: true, pruned_count: 0 }
+
+# Report
+runner.plasticity_report
+# => { success: true, report: { total_pathways: 1, critical_period: false, average_strength: 0.4, ... } }
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-plasticity.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_plasticity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-plasticity'
+  spec.version       = Legion::Extensions::CognitivePlasticity::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Neural plasticity modeling for LegionIO'
+  spec.description   = 'Models synaptic plasticity with critical periods, pathway strengthening, and pruning'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-plasticity'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']        = spec.homepage
+  spec.metadata['source_code_uri']     = spec.homepage
+  spec.metadata['documentation_uri']   = "#{spec.homepage}/blob/main/README.md"
+  spec.metadata['changelog_uri']       = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata['bug_tracker_uri']     = "#{spec.homepage}/issues"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{\A(?:test|spec|features)/})
+    end
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePlasticity
+      class Client
+        include Runners::CognitivePlasticity
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePlasticity
+      module Helpers
+        module Constants
+          MAX_PATHWAYS = 300
+          MAX_EVENTS = 500
+
+          DEFAULT_LEARNING_RATE = 0.5
+          STRENGTHENING_RATE = 0.08
+          PRUNING_THRESHOLD = 0.15
+          CRITICAL_PERIOD_MULTIPLIER = 2.5
+          MATURATION_RATE = 0.01
+
+          PLASTICITY_LABELS = {
+            (0.8..)     => :highly_plastic,
+            (0.6...0.8) => :plastic,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :rigid,
+            (..0.2)     => :crystallized
+          }.freeze
+
+          STRENGTH_LABELS = {
+            (0.8..)     => :robust,
+            (0.6...0.8) => :strong,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :weak,
+            (..0.2)     => :nascent
+          }.freeze
+
+          PATHWAY_TYPES = %i[
+            synaptic structural functional
+            homeostatic metaplastic
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_plasticity/helpers/neural_pathway.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitivePlasticity
+      module Helpers
+        class NeuralPathway
+          include Constants
+
+          attr_reader :id, :label, :pathway_type, :strength, :plasticity,
+                      :activation_count, :created_at
+
+          def initialize(label:, pathway_type: :synaptic, initial_strength: 0.3)
+            @id               = SecureRandom.uuid
+            @label            = label
+            @pathway_type     = pathway_type.to_sym
+            @strength         = initial_strength.to_f.clamp(0.0, 1.0)
+            @plasticity       = DEFAULT_LEARNING_RATE
+            @activation_count = 0
+            @created_at       = Time.now.utc
+          end
+
+          def strengthen!(amount: STRENGTHENING_RATE, critical_period: false)
+            multiplier = critical_period ? CRITICAL_PERIOD_MULTIPLIER : 1.0
+            effective = (amount * multiplier * @plasticity).round(10)
+            @strength = (@strength + effective).clamp(0.0, 1.0).round(10)
+            @activation_count += 1
+            mature!
+            self
+          end
+
+          def weaken!(amount: STRENGTHENING_RATE)
+            effective = (amount * @plasticity).round(10)
+            @strength = (@strength - effective).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def prune_candidate?
+            @strength < PRUNING_THRESHOLD
+          end
+
+          def mature!
+            @plasticity = (@plasticity - MATURATION_RATE).clamp(0.1, 1.0).round(10)
+          end
+
+          def rejuvenate!(amount: 0.1)
+            @plasticity = (@plasticity + amount).clamp(0.1, 1.0).round(10)
+            self
+          end
+
+          def strength_label
+            match = STRENGTH_LABELS.find { |range, _| range.cover?(@strength) }
+            match ? match.last : :nascent
+          end
+
+          def plasticity_label
+            match = PLASTICITY_LABELS.find { |range, _| range.cover?(@plasticity) }
+            match ? match.last : :crystallized
+          end
+
+          def to_h
+            {
+              id:               @id,
+              label:            @label,
+              pathway_type:     @pathway_type,
+              strength:         @strength,
+              strength_label:   strength_label,
+              plasticity:       @plasticity,
+              plasticity_label: plasticity_label,
+              activation_count: @activation_count,
+              prune_candidate:  prune_candidate?,
+              created_at:       @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_plasticity/helpers/plasticity_engine.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePlasticity
+      module Helpers
+        class PlasticityEngine
+          include Constants
+
+          def initialize
+            @pathways        = {}
+            @critical_period = false
+          end
+
+          def create_pathway(label:, pathway_type: :synaptic, initial_strength: 0.3)
+            prune_if_needed
+            pathway = NeuralPathway.new(label: label, pathway_type: pathway_type,
+                                        initial_strength: initial_strength)
+            @pathways[pathway.id] = pathway
+            pathway
+          end
+
+          def strengthen_pathway(pathway_id:, amount: STRENGTHENING_RATE)
+            pathway = @pathways[pathway_id]
+            return nil unless pathway
+
+            pathway.strengthen!(amount: amount, critical_period: @critical_period)
+          end
+
+          def weaken_pathway(pathway_id:, amount: STRENGTHENING_RATE)
+            pathway = @pathways[pathway_id]
+            return nil unless pathway
+
+            pathway.weaken!(amount: amount)
+          end
+
+          def rejuvenate_pathway(pathway_id:, amount: 0.1)
+            pathway = @pathways[pathway_id]
+            return nil unless pathway
+
+            pathway.rejuvenate!(amount: amount)
+          end
+
+          def enter_critical_period!
+            @critical_period = true
+          end
+
+          def exit_critical_period!
+            @critical_period = false
+          end
+
+          def critical_period?
+            @critical_period
+          end
+
+          def prune_weak_pathways!
+            candidates = @pathways.values.select(&:prune_candidate?)
+            candidates.each { |p| @pathways.delete(p.id) }
+            candidates.size
+          end
+
+          def pathways_by_type(pathway_type:)
+            pt = pathway_type.to_sym
+            @pathways.values.select { |p| p.pathway_type == pt }
+          end
+
+          def strongest_pathways(limit: 5)
+            @pathways.values.sort_by { |p| -p.strength }.first(limit)
+          end
+
+          def weakest_pathways(limit: 5)
+            @pathways.values.sort_by(&:strength).first(limit)
+          end
+
+          def average_strength
+            return 0.0 if @pathways.empty?
+
+            strengths = @pathways.values.map(&:strength)
+            (strengths.sum / strengths.size).round(10)
+          end
+
+          def average_plasticity
+            return DEFAULT_LEARNING_RATE if @pathways.empty?
+
+            plasticities = @pathways.values.map(&:plasticity)
+            (plasticities.sum / plasticities.size).round(10)
+          end
+
+          def prune_candidates_count
+            @pathways.values.count(&:prune_candidate?)
+          end
+
+          def plasticity_report
+            {
+              total_pathways:     @pathways.size,
+              critical_period:    @critical_period,
+              average_strength:   average_strength,
+              average_plasticity: average_plasticity,
+              prune_candidates:   prune_candidates_count,
+              strongest:          strongest_pathways(limit: 3).map(&:to_h)
+            }
+          end
+
+          def to_h
+            {
+              total_pathways:     @pathways.size,
+              critical_period:    @critical_period,
+              average_strength:   average_strength,
+              average_plasticity: average_plasticity,
+              prune_candidates:   prune_candidates_count
+            }
+          end
+
+          private
+
+          def prune_if_needed
+            return if @pathways.size < MAX_PATHWAYS
+
+            weakest = @pathways.values.min_by(&:strength)
+            @pathways.delete(weakest.id) if weakest
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePlasticity
+      module Runners
+        module CognitivePlasticity
+          include Helpers::Constants
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def create_pathway(label:, engine: nil, pathway_type: :synaptic, initial_strength: 0.3, **)
+            eng = engine || default_engine
+            pathway = eng.create_pathway(label: label, pathway_type: pathway_type,
+                                         initial_strength: initial_strength)
+            { success: true, pathway: pathway.to_h }
+          end
+
+          def strengthen_pathway(pathway_id:, engine: nil, amount: STRENGTHENING_RATE, **)
+            eng = engine || default_engine
+            result = eng.strengthen_pathway(pathway_id: pathway_id, amount: amount)
+            return { success: false, error: 'pathway not found' } unless result
+
+            { success: true, pathway: result.to_h }
+          end
+
+          def weaken_pathway(pathway_id:, engine: nil, amount: STRENGTHENING_RATE, **)
+            eng = engine || default_engine
+            result = eng.weaken_pathway(pathway_id: pathway_id, amount: amount)
+            return { success: false, error: 'pathway not found' } unless result
+
+            { success: true, pathway: result.to_h }
+          end
+
+          def rejuvenate_pathway(pathway_id:, engine: nil, amount: 0.1, **)
+            eng = engine || default_engine
+            result = eng.rejuvenate_pathway(pathway_id: pathway_id, amount: amount)
+            return { success: false, error: 'pathway not found' } unless result
+
+            { success: true, pathway: result.to_h }
+          end
+
+          def enter_critical_period(engine: nil, **)
+            eng = engine || default_engine
+            eng.enter_critical_period!
+            { success: true, critical_period: true }
+          end
+
+          def exit_critical_period(engine: nil, **)
+            eng = engine || default_engine
+            eng.exit_critical_period!
+            { success: true, critical_period: false }
+          end
+
+          def prune_weak_pathways(engine: nil, **)
+            eng = engine || default_engine
+            pruned = eng.prune_weak_pathways!
+            { success: true, pruned_count: pruned }
+          end
+
+          def strongest_pathways(engine: nil, limit: 5, **)
+            eng = engine || default_engine
+            pathways = eng.strongest_pathways(limit: limit).map(&:to_h)
+            { success: true, pathways: pathways, count: pathways.size }
+          end
+
+          def plasticity_report(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, report: eng.plasticity_report }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::PlasticityEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_plasticity.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'cognitive_plasticity/version'
+require_relative 'cognitive_plasticity/helpers/constants'
+require_relative 'cognitive_plasticity/helpers/neural_pathway'
+require_relative 'cognitive_plasticity/helpers/plasticity_engine'
+require_relative 'cognitive_plasticity/runners/cognitive_plasticity'
+require_relative 'cognitive_plasticity/client'
+
+module Legion
+  module Extensions
+    module CognitivePlasticity
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-plasticity
+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: Models synaptic plasticity with critical periods, pathway strengthening,
+  and pruning
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- lex-cognitive-plasticity.gemspec
+- lib/legion/extensions/cognitive_plasticity.rb
+- lib/legion/extensions/cognitive_plasticity/client.rb
+- lib/legion/extensions/cognitive_plasticity/helpers/constants.rb
+- lib/legion/extensions/cognitive_plasticity/helpers/neural_pathway.rb
+- lib/legion/extensions/cognitive_plasticity/helpers/plasticity_engine.rb
+- lib/legion/extensions/cognitive_plasticity/runners/cognitive_plasticity.rb
+- lib/legion/extensions/cognitive_plasticity/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-plasticity
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-plasticity
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-plasticity
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-plasticity/blob/main/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-plasticity/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-plasticity/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: Neural plasticity modeling for LegionIO
+test_files: []