lex-cognitive-echo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 999f772ad29137ea8193c34453a986f9e9e5bf6c47aa280b574efb78b38c5e31
+  data.tar.gz: ebb34f4efe8a8c9ff2f2c80f616b1f8ac0937aa4a02efe868aeedfe4230c760f
+SHA512:
+  metadata.gz: 9cc3212295c5644b89b9a457aef6ea938f4606531b37dd26209490c68b8ada6367b8cb2b083450afa9a3783d34c7fafac950beb0e82f82281a1100867423a4a5
+  data.tar.gz: 8a28e5a978aeda3b8ec2661340c194d11f7d73b625a4f80c50126b031ace7c229a2538c0015a746bc04f989f8f4a612220e202b8fb7189472c7fd6e31c2aa119

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,41 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.4
+  SuggestExtensions: false
+
+Style/Documentation:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Naming/PredicatePrefix:
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/ParameterLists:
+  Max: 8
+  MaxOptionalParameters: 8
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/CLAUDE.md

@@ -0,0 +1,77 @@
+# lex-cognitive-echo
+
+**Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Models residual cognitive activation from previous processing. Recent thoughts leave echoes that decay over time but influence current processing through priming and interference effects. Provides a background activation layer — the cognitive afterimage of prior thinking that shapes new processing without conscious attention.
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-echo`
+- **Version**: `0.1.0`
+- **Module**: `Legion::Extensions::CognitiveEcho`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_echo/
+  cognitive_echo.rb
+  version.rb
+  client.rb
+  helpers/
+    constants.rb
+    echo_engine.rb
+    echo.rb
+  runners/
+    cognitive_echo.rb
+```
+
+## Key Constants
+
+From `helpers/constants.rb`:
+
+- `ECHO_TYPES` — `%i[thought emotion decision observation prediction error success failure]`
+- `MAX_ECHOES` = `300`, `MAX_INTERACTIONS` = `500`
+- `DEFAULT_INTENSITY` = `0.8`, `ECHO_DECAY` = `0.1`, `REINFORCEMENT` = `0.15`
+- `INTERFERENCE_THRESHOLD` = `0.4`, `PRIMING_THRESHOLD` = `0.3`, `SILENT_THRESHOLD` = `0.05`
+- `INTENSITY_LABELS` — `0.8+` = `:reverberating`, `0.6` = `:strong`, `0.4` = `:moderate`, `0.2` = `:fading`, below = `:whisper`
+- `EFFECT_LABELS` — `0.6+` = `:dominant`, `0.3` = `:influential`, `0.1` = `:subtle`, below = `:negligible`
+- `CHAMBER_LABELS` — `0.8+` = `:echo_chamber`, `0.6` = `:resonant`, `0.4` = `:balanced`, `0.2` = `:diverse`, below = `:scattered`
+
+## Runners
+
+All methods in `Runners::CognitiveEcho`:
+
+- `create_echo(content:, echo_type: :thought, domain: :general, intensity: 0.8)` — registers a new echo from a just-processed cognitive event
+- `reinforce_echo(echo_id:, amount: 0.15)` — increases echo intensity; models repeated exposure reinforcing residual activation
+- `decay_all` — applies `ECHO_DECAY` to all echoes; removes echoes below `SILENT_THRESHOLD`
+- `active_echoes` — echoes above `SILENT_THRESHOLD`
+- `priming_echoes` — echoes above `PRIMING_THRESHOLD` (influencing current processing)
+- `interfering_echoes` — echoes above `INTERFERENCE_THRESHOLD` (strong enough to distort)
+- `echoes_by_domain(domain:)` — filter by domain
+- `strongest_echoes(limit: 5)` — top echoes by intensity
+- `priming_effect(domain:)` — aggregate priming effect for a domain (sum of priming echo intensities)
+- `echo_status` — full report: totals, decay stats, chamber resonance, domain distribution
+
+## Helpers
+
+- `EchoEngine` — manages echoes. `decay_all!` removes silent echoes. `priming_effect_for(domain:)` sums intensities of priming echoes in the domain.
+- `Echo` — has `content`, `echo_type`, `domain`, `intensity`. `decay!` reduces by `ECHO_DECAY`. `reinforce!(amount)` increases intensity. `priming?`, `interfering?`, `silent?` predicates.
+
+## Integration Points
+
+- `lex-cognitive-echo-chamber` is the multi-echo, self-amplifying version — echo models single residual activations; echo chamber models self-reinforcing belief loops.
+- `lex-cognitive-dwell` models active foreground attention; echo models passive background residual. They complement each other.
+- `priming_effect(domain:)` can be called from `lex-tick` before prediction or memory retrieval phases — high priming in a domain biases retrieval toward domain-consistent content.
+
+## Development Notes
+
+- Echo decay is rapid (`ECHO_DECAY = 0.1` per cycle) — echoes are transient by design. Only reinforced echoes persist.
+- `SILENT_THRESHOLD = 0.05` is the removal floor — echoes below this are pruned on `decay_all`.
+- `CHAMBER_LABELS` keyed on the ratio of echoes above `INTERFERENCE_THRESHOLD` to total echoes — a high ratio indicates an echo chamber is forming.
+- `priming_effect_for` returns a sum, not a ratio — high echo counts amplify domain priming linearly.

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,54 @@
+# lex-cognitive-echo
+
+Residual cognitive activation modeling for the LegionIO cognitive architecture. Recent thoughts leave echoes that decay over time but continue to influence current processing through priming and interference effects.
+
+## What It Does
+
+Cognitive echo models the afterimage of prior thinking — the background activation that persists after an active thought has passed. An echo is created when a cognitive event (thought, emotion, decision, observation, prediction, error, success, or failure) finishes processing. It starts at a configurable intensity, decays each cycle, and gets pruned once it falls below the silent threshold (0.05).
+
+Echoes serve two roles: **priming** (echoes above 0.3 bias new retrieval and processing toward their domain) and **interference** (echoes above 0.4 are strong enough to distort new processing). The extension also tracks chamber resonance — the ratio of interfering echoes to total echoes — as an early signal that an echo chamber is forming.
+
+## Usage
+
+```ruby
+client = Legion::Extensions::CognitiveEcho::Client.new
+
+# Register a new echo from a just-processed event
+result = client.create_echo(
+  content: 'recursive planning loop detected',
+  echo_type: :thought,
+  domain: :planning,
+  intensity: 0.8
+)
+echo_id = result[:echo][:id]
+
+# Reinforce an echo (e.g., it was encountered again)
+client.reinforce_echo(echo_id: echo_id, amount: 0.15)
+
+# Periodic maintenance — decay all echoes, prune silent ones
+client.decay_all
+
+# Query by role
+client.active_echoes
+client.priming_echoes       # intensity > 0.3 — influencing current processing
+client.interfering_echoes   # intensity > 0.4 — strong enough to distort
+
+# Domain-focused queries
+client.echoes_by_domain(domain: :planning)
+client.priming_effect(domain: :planning)  # aggregate priming for a domain
+
+# Status
+client.echo_status
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-echo.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_echo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-echo'
+  spec.version       = Legion::Extensions::CognitiveEcho::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Thought echo and residual activation tracking for LegionIO'
+  spec.description   = 'Models residual cognitive activation from previous processing. Recent thoughts ' \
+                       'leave echoes that decay over time but influence current processing through ' \
+                       'priming and interference effects.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-echo'
+  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-echo'
+  spec.metadata['documentation_uri']     = 'https://github.com/LegionIO/lex-cognitive-echo/blob/master/README.md'
+  spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/lex-cognitive-echo/blob/master/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri']       = 'https://github.com/LegionIO/lex-cognitive-echo/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_echo/client.rb

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

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveEcho
+      module Helpers
+        module Constants
+          MAX_ECHOES        = 300
+          MAX_INTERACTIONS  = 500
+          DEFAULT_INTENSITY = 0.8
+          ECHO_DECAY        = 0.1
+          REINFORCEMENT     = 0.15
+          INTERFERENCE_THRESHOLD = 0.4
+          PRIMING_THRESHOLD = 0.3
+          SILENT_THRESHOLD  = 0.05
+
+          ECHO_TYPES = %i[
+            thought emotion decision observation
+            prediction error success failure
+          ].freeze
+
+          INTENSITY_LABELS = {
+            (0.8..)     => :reverberating,
+            (0.6...0.8) => :strong,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :fading,
+            (..0.2)     => :whisper
+          }.freeze
+
+          EFFECT_LABELS = {
+            (0.6..)     => :dominant,
+            (0.3...0.6) => :influential,
+            (0.1...0.3) => :subtle,
+            (..0.1)     => :negligible
+          }.freeze
+
+          CHAMBER_LABELS = {
+            (0.8..)     => :echo_chamber,
+            (0.6...0.8) => :resonant,
+            (0.4...0.6) => :balanced,
+            (0.2...0.4) => :diverse,
+            (..0.2)     => :scattered
+          }.freeze
+
+          def self.label_for(labels, value)
+            match = labels.find { |range, _| range.cover?(value) }
+            match&.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_echo/helpers/echo.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveEcho
+      module Helpers
+        class Echo
+          include Constants
+
+          attr_reader :id, :content, :echo_type, :domain, :intensity,
+                      :original_intensity, :decay_count, :created_at
+
+          def initialize(content:, echo_type: :thought, domain: :general, intensity: DEFAULT_INTENSITY)
+            @id                 = SecureRandom.uuid
+            @content            = content
+            @echo_type          = validate_type(echo_type)
+            @domain             = domain.to_sym
+            @intensity          = intensity.to_f.clamp(0.0, 1.0).round(10)
+            @original_intensity = @intensity
+            @decay_count        = 0
+            @created_at         = Time.now.utc
+          end
+
+          def decay!
+            @decay_count += 1
+            @intensity = (@intensity - ECHO_DECAY).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def reinforce!(amount = REINFORCEMENT)
+            @intensity = (@intensity + amount).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def silent?
+            @intensity <= SILENT_THRESHOLD
+          end
+
+          def active?
+            @intensity > SILENT_THRESHOLD
+          end
+
+          def priming?
+            @intensity >= PRIMING_THRESHOLD
+          end
+
+          def interfering?
+            @intensity >= INTERFERENCE_THRESHOLD
+          end
+
+          def persistence
+            return 0.0 if @original_intensity.zero?
+
+            (@intensity / @original_intensity).clamp(0.0, 1.0).round(10)
+          end
+
+          def intensity_label = Constants.label_for(INTENSITY_LABELS, @intensity)
+          def effect_label = Constants.label_for(EFFECT_LABELS, @intensity)
+
+          def to_h
+            {
+              id:                 @id,
+              content:            @content,
+              echo_type:          @echo_type,
+              domain:             @domain,
+              intensity:          @intensity,
+              original_intensity: @original_intensity,
+              intensity_label:    intensity_label,
+              effect_label:       effect_label,
+              priming:            priming?,
+              interfering:        interfering?,
+              silent:             silent?,
+              persistence:        persistence,
+              decay_count:        @decay_count,
+              created_at:         @created_at
+            }
+          end
+
+          private
+
+          def validate_type(type)
+            sym = type.to_sym
+            ECHO_TYPES.include?(sym) ? sym : :thought
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_echo/helpers/echo_engine.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveEcho
+      module Helpers
+        class EchoEngine
+          include Constants
+
+          def initialize
+            @echoes = {}
+          end
+
+          def create_echo(content:, echo_type: :thought, domain: :general, intensity: DEFAULT_INTENSITY)
+            prune_silent
+            echo = Echo.new(content: content, echo_type: echo_type, domain: domain, intensity: intensity)
+            @echoes[echo.id] = echo
+            echo
+          end
+
+          def reinforce_echo(echo_id:, amount: REINFORCEMENT)
+            echo = @echoes[echo_id]
+            return nil unless echo
+
+            echo.reinforce!(amount)
+            echo
+          end
+
+          def decay_all!
+            @echoes.each_value(&:decay!)
+            prune_silent
+            { echoes_decayed: @echoes.size, pruned: count_silent }
+          end
+
+          def active_echoes = @echoes.values.select(&:active?)
+          def priming_echoes = @echoes.values.select(&:priming?)
+          def interfering_echoes = @echoes.values.select(&:interfering?)
+
+          def echoes_by_type(echo_type:)
+            @echoes.values.select { |e| e.echo_type == echo_type.to_sym }
+          end
+
+          def echoes_by_domain(domain:)
+            @echoes.values.select { |e| e.domain == domain.to_sym }
+          end
+
+          def strongest_echoes(limit: 5) = @echoes.values.sort_by { |e| -e.intensity }.first(limit)
+          def faintest_echoes(limit: 5) = @echoes.values.select(&:active?).sort_by(&:intensity).first(limit)
+
+          def echo_chamber_score
+            return 0.0 if @echoes.empty?
+
+            domains = @echoes.values.map(&:domain).uniq
+            return 1.0 if domains.size <= 1
+
+            domain_concentration(domains)
+          end
+
+          def chamber_label = Constants.label_for(CHAMBER_LABELS, echo_chamber_score)
+
+          def priming_effect_for(domain:)
+            matching = echoes_by_domain(domain: domain).select(&:priming?)
+            return 0.0 if matching.empty?
+
+            matching.sum(&:intensity).clamp(0.0, 1.0).round(10)
+          end
+
+          def interference_level
+            interfering = interfering_echoes
+            return 0.0 if interfering.empty?
+
+            (interfering.sum(&:intensity) / @echoes.size).clamp(0.0, 1.0).round(10)
+          end
+
+          def average_intensity
+            return 0.0 if @echoes.empty?
+
+            (@echoes.values.sum(&:intensity) / @echoes.size).round(10)
+          end
+
+          def echo_report
+            {
+              total_echoes:       @echoes.size,
+              active_count:       active_echoes.size,
+              priming_count:      priming_echoes.size,
+              interfering_count:  interfering_echoes.size,
+              average_intensity:  average_intensity,
+              echo_chamber_score: echo_chamber_score,
+              chamber_label:      chamber_label,
+              interference_level: interference_level,
+              strongest:          strongest_echoes(limit: 3).map(&:to_h)
+            }
+          end
+
+          def to_h
+            {
+              total_echoes:      @echoes.size,
+              active:            active_echoes.size,
+              average_intensity: average_intensity,
+              chamber_score:     echo_chamber_score
+            }
+          end
+
+          private
+
+          def domain_concentration(domains)
+            intensities = domains.map { |d| @echoes.values.select { |e| e.domain == d }.sum(&:intensity) }
+            total = intensities.sum
+            return 0.0 if total.zero?
+
+            (intensities.max / total).round(10)
+          end
+
+          def count_silent
+            @echoes.values.count(&:silent?)
+          end
+
+          def prune_silent
+            return if @echoes.size < MAX_ECHOES
+
+            silent = @echoes.values.select(&:silent?)
+            silent.each { |e| @echoes.delete(e.id) }
+            return unless @echoes.size >= MAX_ECHOES
+
+            faintest = @echoes.values.min_by(&:intensity)
+            @echoes.delete(faintest.id) if faintest
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveEcho
+      module Runners
+        module CognitiveEcho
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def create_echo(content:, echo_type: :thought, domain: :general, intensity: 0.8, engine: nil, **)
+            eng = engine || default_engine
+            echo = eng.create_echo(content: content, echo_type: echo_type, domain: domain, intensity: intensity)
+            { success: true, echo: echo.to_h }
+          end
+
+          def reinforce_echo(echo_id:, amount: 0.15, engine: nil, **)
+            eng = engine || default_engine
+            echo = eng.reinforce_echo(echo_id: echo_id, amount: amount)
+            return { success: false, error: 'echo not found' } unless echo
+
+            { success: true, echo: echo.to_h }
+          end
+
+          def decay_all(engine: nil, **)
+            eng = engine || default_engine
+            result = eng.decay_all!
+            { success: true, **result }
+          end
+
+          def active_echoes(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, echoes: eng.active_echoes.map(&:to_h), count: eng.active_echoes.size }
+          end
+
+          def priming_echoes(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, echoes: eng.priming_echoes.map(&:to_h), count: eng.priming_echoes.size }
+          end
+
+          def interfering_echoes(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, echoes: eng.interfering_echoes.map(&:to_h), count: eng.interfering_echoes.size }
+          end
+
+          def echoes_by_domain(domain:, engine: nil, **)
+            eng = engine || default_engine
+            echoes = eng.echoes_by_domain(domain: domain)
+            { success: true, echoes: echoes.map(&:to_h), count: echoes.size }
+          end
+
+          def strongest_echoes(limit: 5, engine: nil, **)
+            eng = engine || default_engine
+            { success: true, echoes: eng.strongest_echoes(limit: limit).map(&:to_h) }
+          end
+
+          def priming_effect(domain:, engine: nil, **)
+            eng = engine || default_engine
+            effect = eng.priming_effect_for(domain: domain)
+            label = Helpers::Constants.label_for(Helpers::Constants::EFFECT_LABELS, effect)
+            { success: true, domain: domain.to_sym, priming_effect: effect, effect_label: label }
+          end
+
+          def echo_status(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, **eng.echo_report }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::EchoEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_echo.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'cognitive_echo/version'
+require_relative 'cognitive_echo/helpers/constants'
+require_relative 'cognitive_echo/helpers/echo'
+require_relative 'cognitive_echo/helpers/echo_engine'
+require_relative 'cognitive_echo/runners/cognitive_echo'
+require_relative 'cognitive_echo/client'
+
+module Legion
+  module Extensions
+    module CognitiveEcho
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-echo
+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 residual cognitive activation from previous processing. Recent
+  thoughts leave echoes that decay over time but influence current processing through
+  priming and interference effects.
+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-echo.gemspec
+- lib/legion/extensions/cognitive_echo.rb
+- lib/legion/extensions/cognitive_echo/client.rb
+- lib/legion/extensions/cognitive_echo/helpers/constants.rb
+- lib/legion/extensions/cognitive_echo/helpers/echo.rb
+- lib/legion/extensions/cognitive_echo/helpers/echo_engine.rb
+- lib/legion/extensions/cognitive_echo/runners/cognitive_echo.rb
+- lib/legion/extensions/cognitive_echo/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-echo
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-echo
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-echo
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-echo/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-echo/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-echo/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: Thought echo and residual activation tracking for LegionIO
+test_files: []