lex-cognitive-integration 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 11519fb839b607ed2c297ae8aa0594f90fd43cdd6e743a23f8cbb5b118e11a20
+  data.tar.gz: 179f7b4e326e3e2ef62589d73e692ed7bcdc0c51c0afcc0d0148f624bde0f496
+SHA512:
+  metadata.gz: 61d43bb8a7c10d7b3774168fbafda1df071b7a18cbd439b8d8a6322d478d07e2a9da7e5b7a6aad1ce625d13a2e2b85e110fe28694fcf7ae6b20e762dc8d8654c
+  data.tar.gz: ffc069e410f67fa2cfc135883e02a6a2951c8bf523e93f6c10b8a7498dadcb508b737dc22f56be9c297cd6ddcf04a00f477ec7bed226a3c6c6242ae0e77c5244

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,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+Gemfile.lock
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,34 @@
+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/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/CLAUDE.md

@@ -0,0 +1,128 @@
+# lex-cognitive-integration
+
+**Level 3 Leaf Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Gem**: `lex-cognitive-integration`
+
+## Purpose
+
+Models multi-modal cognitive binding — the process of unifying signals from different modalities (visual, auditory, semantic, proprioceptive, etc.) into coherent integrated representations. Signals are registered with a modality type. Integration binds a set of signals into an IntegratedRepresentation with a binding strength. Representations above the coherent threshold are considered stable; below the fragmented threshold they are degraded. Passive decay reduces binding strength over time. Disruption forcibly degrades a representation.
+
+## Gem Info
+
+| Field | Value |
+|---|---|
+| Gem name | `lex-cognitive-integration` |
+| Version | `0.1.0` |
+| Namespace | `Legion::Extensions::CognitiveIntegration` |
+| Ruby | `>= 3.4` |
+| License | MIT |
+| GitHub | https://github.com/LegionIO/lex-cognitive-integration |
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_integration/
+  cognitive_integration.rb          # Top-level require
+  version.rb                        # VERSION = '0.1.0'
+  client.rb                         # Client class
+  helpers/
+    constants.rb                    # Modalities, binding thresholds, decay rate, binding/confidence/quality labels
+    modal_signal.rb                 # ModalSignal value object
+    integrated_representation.rb    # IntegratedRepresentation value object
+    integration_engine.rb           # Engine: signals, representations, bind, decay, coherence
+  runners/
+    cognitive_integration.rb        # Runner module
+```
+
+## Key Constants
+
+| Constant | Value | Meaning |
+|---|---|---|
+| `MAX_SIGNALS` | 500 | Signal store cap |
+| `MAX_REPRESENTATIONS` | 200 | Representation cap |
+| `MIN_SIGNALS_FOR_BINDING` | 2 | Minimum signals required to create a representation |
+| `MODALITIES` | array | `[:visual, :auditory, :semantic, :proprioceptive, :interoceptive, :temporal, :spatial, :emotional, :linguistic]` |
+| `DEFAULT_BINDING_STRENGTH` | 0.5 | Starting binding strength for new representations |
+| `BINDING_DECAY_RATE` | 0.03 | Binding strength decrease per decay call |
+| `COHERENT_THRESHOLD` | 0.6 | Binding strength above this = coherent |
+| `FRAGMENTED_THRESHOLD` | 0.3 | Binding strength below this = fragmented |
+| `BINDING_LABELS` | hash | `bound` (0.8+) through `unbound` |
+| `CONFIDENCE_LABELS` | hash | Labels for representation confidence |
+| `QUALITY_LABELS` | hash | Labels for signal quality |
+
+## Helpers
+
+### `ModalSignal`
+
+A single-modality cognitive input.
+
+- `initialize(modality:, content:, domain:, quality: 0.5, signal_id: nil)`
+- `quality`, `modality`, `domain`
+- `to_h`
+
+### `IntegratedRepresentation`
+
+A multi-modal binding of several signals.
+
+- `initialize(signal_ids:, binding_strength: DEFAULT_BINDING_STRENGTH, representation_id: nil)`
+- `reinforce!(amount)` — increases binding_strength, cap 1.0
+- `disrupt!(amount)` — decreases binding_strength, floor 0.0
+- `decay!(rate)` — decreases binding_strength by `BINDING_DECAY_RATE`
+- `coherent?` — binding_strength >= `COHERENT_THRESHOLD`
+- `fragmented?` — binding_strength < `FRAGMENTED_THRESHOLD`
+- `binding_label`
+- `to_h`
+
+### `IntegrationEngine`
+
+- `add_signal(modality:, content:, domain:, quality: 0.5)` — returns `{ added:, signal_id:, signal: }` or capacity error
+- `remove_signal(signal_id:)` — removes from signal store
+- `integrate(signal_ids:, binding_strength: DEFAULT_BINDING_STRENGTH)` — requires >= MIN_SIGNALS_FOR_BINDING; creates IntegratedRepresentation; returns `{ integrated:, representation_id:, representation: }`
+- `integrate_by_modalities(modalities:)` — integrates all signals matching given modality list
+- `integrate_all_salient(quality_threshold: 0.6)` — auto-integrates all signals above quality threshold
+- `reinforce(representation_id:, amount: 0.1)` — strengthens binding
+- `disrupt(representation_id:, amount: 0.1)` — weakens binding
+- `decay_all!(rate: BINDING_DECAY_RATE)` — decays all representations
+- `coherent_representations(limit: 20)` — filtered and sorted
+- `fragmented_representations(limit: 20)` — filtered and sorted
+- `signals_by_modality` — hash of modality -> signal array
+- `integration_report` — full stats
+
+## Runners
+
+**Module**: `Legion::Extensions::CognitiveIntegration::Runners::CognitiveIntegration`
+
+| Method | Key Args | Returns |
+|---|---|---|
+| `add_signal` | `modality:`, `content:`, `domain:`, `quality: 0.5` | `{ success:, signal_id:, signal: }` |
+| `remove_signal` | `signal_id:` | `{ success:, removed: }` |
+| `integrate` | `signal_ids:`, `binding_strength: DEFAULT_BINDING_STRENGTH` | `{ success:, representation_id:, representation: }` |
+| `integrate_by_modalities` | `modalities:` | `{ success:, representation_id:, representation: }` |
+| `integrate_all_salient` | `quality_threshold: 0.6` | `{ success:, representations: [...] }` |
+| `reinforce` | `representation_id:`, `amount: 0.1` | `{ success:, binding_strength: }` |
+| `disrupt` | `representation_id:`, `amount: 0.1` | `{ success:, binding_strength: }` |
+| `decay` | — | `{ success:, decayed: N }` |
+| `signals_by_modality` | — | `{ success:, modalities: }` |
+| `coherent_representations` | `limit: 20` | `{ success:, representations: }` |
+| `integration_report` | — | Full report hash |
+| `status` | — | `{ success:, report: }` |
+
+Private: `integration_engine` — memoized `IntegrationEngine`. Logs via `log_debug` helper.
+
+## Integration Points
+
+- **`lex-memory`**: Coherent integrated representations are prime candidates for memory trace storage. Fragmented representations could be stored at lower strength. `lex-memory`'s Hebbian linking can strengthen associations between signals that appear together in the same representation.
+- **`lex-cognitive-hologram`**: Hologram reconstruction assembles fragments into a whole; integration binds multi-modal signals into a unified representation. Both model the process of assembling coherent wholes from parts.
+- **`lex-emotion`**: Emotional signals (`:emotional` modality) can be integrated alongside semantic and linguistic signals to produce affectively grounded representations. `lex-emotion`'s valence can influence binding quality.
+
+## Development Notes
+
+- `integrate` requires at least `MIN_SIGNALS_FOR_BINDING` (2) signal IDs. Passing a single signal returns an error.
+- `integrate_all_salient` groups signals by domain and integrates each domain's high-quality signals independently. This can produce many representations in one call.
+- `decay_all!` operates on all representations regardless of coherence state. Coherent representations can decay into the fragmented range over time without periodic `reinforce` calls.
+- In-memory only.
+
+---
+
+**Maintained By**: Matthew Iverson (@Esity)

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/README.md

@@ -0,0 +1,52 @@
+# lex-cognitive-integration
+
+Multi-modal cognitive binding engine for brain-modeled agentic AI in the LegionIO ecosystem.
+
+## What It Does
+
+Models the binding of signals from different cognitive modalities (visual, auditory, semantic, proprioceptive, interoceptive, temporal, spatial, emotional, linguistic) into coherent integrated representations. Signals are registered individually; integration binds a set of them into a unified representation with a binding strength. Representations above 0.6 binding strength are considered coherent; below 0.3 they are fragmented. Passive decay reduces binding strength. Active reinforcement or disruption adjusts representations after formation.
+
+## Usage
+
+```ruby
+require 'legion/extensions/cognitive_integration'
+
+client = Legion::Extensions::CognitiveIntegration::Client.new
+
+# Register signals from different modalities
+visual = client.add_signal(modality: :visual, content: 'diagram of system architecture', domain: :engineering, quality: 0.8)
+semantic = client.add_signal(modality: :semantic, content: 'microservice decomposition pattern', domain: :engineering, quality: 0.9)
+
+# Bind them into an integrated representation
+result = client.integrate(
+  signal_ids: [visual[:signal_id], semantic[:signal_id]],
+  binding_strength: 0.65
+)
+rep_id = result[:representation_id]
+
+# Reinforce the binding
+client.reinforce(representation_id: rep_id, amount: 0.1)
+# => { success: true, binding_strength: 0.75 }
+
+# Auto-integrate all high-quality signals
+client.integrate_all_salient(quality_threshold: 0.7)
+
+# Find coherent representations
+client.coherent_representations(limit: 10)
+
+# Status
+client.status
+# => { success: true, report: { signal_count: 2, representation_count: 2, ... } }
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-integration.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_integration/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-integration'
+  spec.version       = Legion::Extensions::CognitiveIntegration::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Cross-modal cognitive integration for LegionIO'
+  spec.description   = 'Models convergence zones that bind information from different cognitive modalities ' \
+                       'into unified multi-modal representations with binding strength and coherence tracking.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-integration'
+  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-integration'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-cognitive-integration/blob/master/README.md'
+  spec.metadata['changelog_uri']     = 'https://github.com/LegionIO/lex-cognitive-integration/blob/master/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri']   = 'https://github.com/LegionIO/lex-cognitive-integration/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveIntegration
+      class Client
+        include Runners::CognitiveIntegration
+
+        def initialize(engine: nil)
+          @default_engine = engine || Helpers::IntegrationEngine.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveIntegration
+      module Helpers
+        module Constants
+          MAX_SIGNALS = 500
+          MAX_REPRESENTATIONS = 200
+          MIN_SIGNALS_FOR_BINDING = 2
+
+          # Modality types
+          MODALITIES = %i[
+            visual auditory semantic emotional motor
+            proprioceptive temporal spatial contextual
+          ].freeze
+
+          # Binding dynamics
+          DEFAULT_BINDING_STRENGTH = 0.5
+          BINDING_DECAY_RATE = 0.03
+          REINFORCEMENT_RATE = 0.08
+          CONFLICT_PENALTY = 0.15
+
+          # Thresholds
+          COHERENT_THRESHOLD = 0.6
+          FRAGMENTED_THRESHOLD = 0.3
+
+          # Binding strength labels
+          BINDING_LABELS = {
+            (0.8..)     => :tightly_bound,
+            (0.6...0.8) => :bound,
+            (0.4...0.6) => :loosely_bound,
+            (0.2...0.4) => :fragmentary,
+            (..0.2)     => :unbound
+          }.freeze
+
+          # Signal confidence labels
+          CONFIDENCE_LABELS = {
+            (0.8..)     => :certain,
+            (0.6...0.8) => :confident,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :low,
+            (..0.2)     => :uncertain
+          }.freeze
+
+          # Integration quality labels
+          QUALITY_LABELS = {
+            (0.8..)     => :excellent,
+            (0.6...0.8) => :good,
+            (0.4...0.6) => :adequate,
+            (0.2...0.4) => :poor,
+            (..0.2)     => :failed
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_integration/helpers/integrated_representation.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveIntegration
+      module Helpers
+        class IntegratedRepresentation
+          include Constants
+
+          attr_reader :id, :signal_ids, :modalities, :binding_strength,
+                      :coherence, :created_at
+
+          def initialize(signals:)
+            @id               = SecureRandom.uuid
+            @signal_ids       = signals.map(&:id)
+            @modalities       = signals.map(&:modality).uniq
+            @binding_strength = compute_binding(signals)
+            @coherence        = compute_coherence(signals)
+            @reinforcement_count = 0
+            @created_at       = Time.now.utc
+          end
+
+          def reinforce!
+            @binding_strength = (@binding_strength + REINFORCEMENT_RATE).clamp(0.0, 1.0).round(10)
+            @reinforcement_count += 1
+            self
+          end
+
+          def decay!
+            @binding_strength = (@binding_strength - BINDING_DECAY_RATE).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def disrupt!(amount: CONFLICT_PENALTY)
+            @binding_strength = (@binding_strength - amount).clamp(0.0, 1.0).round(10)
+            @coherence = (@coherence - (amount * 0.5)).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def modal_count = @modalities.size
+          def multi_modal? = @modalities.size > 1
+          def coherent? = @coherence >= COHERENT_THRESHOLD
+          def fragmented? = @coherence < FRAGMENTED_THRESHOLD
+
+          def binding_label
+            match = BINDING_LABELS.find { |range, _| range.cover?(@binding_strength) }
+            match ? match.last : :unbound
+          end
+
+          def quality_label
+            score = ((@binding_strength * 0.6) + (@coherence * 0.4)).round(10)
+            match = QUALITY_LABELS.find { |range, _| range.cover?(score) }
+            match ? match.last : :failed
+          end
+
+          def quality_score
+            ((@binding_strength * 0.6) + (@coherence * 0.4)).round(10)
+          end
+
+          def to_h
+            {
+              id:                  @id,
+              signal_ids:          @signal_ids,
+              modalities:          @modalities,
+              modal_count:         modal_count,
+              multi_modal:         multi_modal?,
+              binding_strength:    @binding_strength,
+              binding_label:       binding_label,
+              coherence:           @coherence,
+              coherent:            coherent?,
+              fragmented:          fragmented?,
+              quality_score:       quality_score,
+              quality_label:       quality_label,
+              reinforcement_count: @reinforcement_count,
+              created_at:          @created_at
+            }
+          end
+
+          private
+
+          def compute_binding(signals)
+            return DEFAULT_BINDING_STRENGTH if signals.empty?
+
+            weights = signals.map(&:effective_weight)
+            (weights.sum / weights.size).round(10)
+          end
+
+          def compute_coherence(signals)
+            return 0.0 if signals.size < 2
+
+            confidences = signals.map(&:confidence)
+            mean = confidences.sum / confidences.size
+            variance = confidences.sum { |c| (c - mean)**2 } / confidences.size
+            (1.0 - Math.sqrt(variance)).clamp(0.0, 1.0).round(10)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_integration/helpers/integration_engine.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveIntegration
+      module Helpers
+        class IntegrationEngine
+          include Constants
+
+          def initialize
+            @signals         = {}
+            @representations = {}
+          end
+
+          def add_signal(modality:, content:, confidence: 0.5, salience: 0.5)
+            prune_signals_if_needed
+            signal = ModalSignal.new(modality: modality, content: content,
+                                     confidence: confidence, salience: salience)
+            @signals[signal.id] = signal
+            signal
+          end
+
+          def remove_signal(signal_id:)
+            @signals.delete(signal_id)
+          end
+
+          def integrate(signal_ids:)
+            signals = signal_ids.filter_map { |sid| @signals[sid] }
+            return nil if signals.size < MIN_SIGNALS_FOR_BINDING
+
+            prune_representations_if_needed
+            rep = IntegratedRepresentation.new(signals: signals)
+            @representations[rep.id] = rep
+            rep
+          end
+
+          def integrate_by_modalities(modalities:)
+            mods = modalities.map(&:to_sym)
+            matching = @signals.values.select { |s| mods.include?(s.modality) }
+            return nil if matching.size < MIN_SIGNALS_FOR_BINDING
+
+            integrate(signal_ids: matching.map(&:id))
+          end
+
+          def integrate_all_salient
+            salient = @signals.values.select(&:salient?)
+            return nil if salient.size < MIN_SIGNALS_FOR_BINDING
+
+            integrate(signal_ids: salient.map(&:id))
+          end
+
+          def reinforce(representation_id:)
+            rep = @representations[representation_id]
+            return nil unless rep
+
+            rep.reinforce!
+          end
+
+          def disrupt(representation_id:, amount: CONFLICT_PENALTY)
+            rep = @representations[representation_id]
+            return nil unless rep
+
+            rep.disrupt!(amount: amount)
+          end
+
+          def decay_all!
+            @representations.each_value(&:decay!)
+            prune_weak_representations
+            { representations_remaining: @representations.size }
+          end
+
+          def signals_by_modality(modality:)
+            m = modality.to_sym
+            @signals.values.select { |s| s.modality == m }
+          end
+
+          def multi_modal_representations
+            @representations.values.select(&:multi_modal?)
+          end
+
+          def coherent_representations
+            @representations.values.select(&:coherent?)
+          end
+
+          def fragmented_representations
+            @representations.values.select(&:fragmented?)
+          end
+
+          def strongest_representations(limit: 5)
+            @representations.values.sort_by { |r| -r.binding_strength }.first(limit)
+          end
+
+          def average_binding_strength
+            return DEFAULT_BINDING_STRENGTH if @representations.empty?
+
+            vals = @representations.values.map(&:binding_strength)
+            (vals.sum / vals.size).round(10)
+          end
+
+          def average_coherence
+            return 0.5 if @representations.empty?
+
+            vals = @representations.values.map(&:coherence)
+            (vals.sum / vals.size).round(10)
+          end
+
+          def modality_coverage
+            @signals.values.map(&:modality).uniq
+          end
+
+          def integration_report
+            {
+              total_signals:            @signals.size,
+              total_representations:    @representations.size,
+              multi_modal_count:        multi_modal_representations.size,
+              coherent_count:           coherent_representations.size,
+              fragmented_count:         fragmented_representations.size,
+              average_binding_strength: average_binding_strength,
+              average_coherence:        average_coherence,
+              modality_coverage:        modality_coverage,
+              strongest:                strongest_representations(limit: 3).map(&:to_h)
+            }
+          end
+
+          def to_h
+            {
+              total_signals:            @signals.size,
+              total_representations:    @representations.size,
+              multi_modal_count:        multi_modal_representations.size,
+              coherent_count:           coherent_representations.size,
+              average_binding_strength: average_binding_strength,
+              average_coherence:        average_coherence
+            }
+          end
+
+          private
+
+          def prune_signals_if_needed
+            return if @signals.size < MAX_SIGNALS
+
+            oldest = @signals.values.min_by(&:created_at)
+            @signals.delete(oldest.id) if oldest
+          end
+
+          def prune_representations_if_needed
+            return if @representations.size < MAX_REPRESENTATIONS
+
+            weakest = @representations.values.min_by(&:binding_strength)
+            @representations.delete(weakest.id) if weakest
+          end
+
+          def prune_weak_representations
+            @representations.reject! { |_, r| r.binding_strength <= 0.0 }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_integration/helpers/modal_signal.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveIntegration
+      module Helpers
+        class ModalSignal
+          include Constants
+
+          attr_reader :id, :modality, :content, :confidence, :salience,
+                      :created_at
+
+          def initialize(modality:, content:, confidence: 0.5, salience: 0.5)
+            @id         = SecureRandom.uuid
+            @modality   = modality.to_sym
+            @content    = content
+            @confidence = confidence.to_f.clamp(0.0, 1.0).round(10)
+            @salience   = salience.to_f.clamp(0.0, 1.0).round(10)
+            @created_at = Time.now.utc
+          end
+
+          def effective_weight
+            (@confidence * @salience).round(10)
+          end
+
+          def salient?
+            @salience >= 0.6
+          end
+
+          def confident?
+            @confidence >= 0.6
+          end
+
+          def confidence_label
+            match = CONFIDENCE_LABELS.find { |range, _| range.cover?(@confidence) }
+            match ? match.last : :uncertain
+          end
+
+          def to_h
+            {
+              id:               @id,
+              modality:         @modality,
+              content:          @content,
+              confidence:       @confidence,
+              confidence_label: confidence_label,
+              salience:         @salience,
+              effective_weight: effective_weight,
+              salient:          salient?,
+              created_at:       @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveIntegration
+      module Runners
+        module CognitiveIntegration
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def add_signal(modality:, content:, confidence: 0.5, salience: 0.5, engine: nil, **)
+            eng = engine || default_engine
+            signal = eng.add_signal(modality: modality, content: content,
+                                    confidence: confidence, salience: salience)
+            { success: true, signal: signal.to_h }
+          end
+
+          def remove_signal(signal_id:, engine: nil, **)
+            eng = engine || default_engine
+            signal = eng.remove_signal(signal_id: signal_id)
+            return { success: false, error: 'signal not found' } unless signal
+
+            { success: true, removed: signal.to_h }
+          end
+
+          def integrate(signal_ids:, engine: nil, **)
+            eng = engine || default_engine
+            rep = eng.integrate(signal_ids: signal_ids)
+            return { success: false, error: 'insufficient signals for binding' } unless rep
+
+            { success: true, representation: rep.to_h }
+          end
+
+          def integrate_by_modalities(modalities:, engine: nil, **)
+            eng = engine || default_engine
+            rep = eng.integrate_by_modalities(modalities: modalities)
+            return { success: false, error: 'insufficient matching signals' } unless rep
+
+            { success: true, representation: rep.to_h }
+          end
+
+          def integrate_all_salient(engine: nil, **)
+            eng = engine || default_engine
+            rep = eng.integrate_all_salient
+            return { success: false, error: 'insufficient salient signals' } unless rep
+
+            { success: true, representation: rep.to_h }
+          end
+
+          def reinforce(representation_id:, engine: nil, **)
+            eng = engine || default_engine
+            rep = eng.reinforce(representation_id: representation_id)
+            return { success: false, error: 'representation not found' } unless rep
+
+            { success: true, representation: rep.to_h }
+          end
+
+          def disrupt(representation_id:, amount: nil, engine: nil, **)
+            eng = engine || default_engine
+            amt = amount || Helpers::Constants::CONFLICT_PENALTY
+            rep = eng.disrupt(representation_id: representation_id, amount: amt)
+            return { success: false, error: 'representation not found' } unless rep
+
+            { success: true, representation: rep.to_h }
+          end
+
+          def decay(engine: nil, **)
+            eng = engine || default_engine
+            result = eng.decay_all!
+            { success: true, **result }
+          end
+
+          def signals_by_modality(modality:, engine: nil, **)
+            eng = engine || default_engine
+            { success: true, signals: eng.signals_by_modality(modality: modality).map(&:to_h) }
+          end
+
+          def coherent_representations(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, representations: eng.coherent_representations.map(&:to_h) }
+          end
+
+          def integration_report(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, report: eng.integration_report }
+          end
+
+          def status(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, **eng.to_h }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::IntegrationEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_integration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'cognitive_integration/version'
+require_relative 'cognitive_integration/helpers/constants'
+require_relative 'cognitive_integration/helpers/modal_signal'
+require_relative 'cognitive_integration/helpers/integrated_representation'
+require_relative 'cognitive_integration/helpers/integration_engine'
+require_relative 'cognitive_integration/runners/cognitive_integration'
+require_relative 'cognitive_integration/client'
+
+module Legion
+  module Extensions
+    module CognitiveIntegration
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-integration
+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 convergence zones that bind information from different cognitive
+  modalities into unified multi-modal representations with binding strength and coherence
+  tracking.
+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-integration.gemspec
+- lib/legion/extensions/cognitive_integration.rb
+- lib/legion/extensions/cognitive_integration/client.rb
+- lib/legion/extensions/cognitive_integration/helpers/constants.rb
+- lib/legion/extensions/cognitive_integration/helpers/integrated_representation.rb
+- lib/legion/extensions/cognitive_integration/helpers/integration_engine.rb
+- lib/legion/extensions/cognitive_integration/helpers/modal_signal.rb
+- lib/legion/extensions/cognitive_integration/runners/cognitive_integration.rb
+- lib/legion/extensions/cognitive_integration/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-integration
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-integration
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-integration
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-integration/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-integration/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-integration/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: Cross-modal cognitive integration for LegionIO
+test_files: []