lex-cognitive-echo-chamber 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9b14c32b92c7a3820386d857c0c8f447fc85ac2d0b4054d7a7c1caad9438eae0
+  data.tar.gz: 6fa1fb07bfa0c474f3e60d0ed47dc4dac10c2dbaa0f244ea251a8ce3f83af24e
+SHA512:
+  metadata.gz: 37da8e8f476ddb16589aa2ae0fb8adfe81795c16ac1e692ff72e5efb1e04c8d7de1d707b7161f5d959aa26dc094cd4d74446db682e1bb8260dfb47692c8c8944
+  data.tar.gz: '0841afec55c9c980ded78f596e9ade8f64340264ee4759e2a9b5c20c271680f04510919e2c2b8ef7ce7aca273134c9410dece066e58cc8412a985cecd7ef62a3'

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

data/.rubocop.yml

@@ -0,0 +1,61 @@
+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/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Naming/FileName:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Naming/PredicatePrefix:
+  Enabled: false
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/CLAUDE.md

@@ -0,0 +1,82 @@
+# lex-cognitive-echo-chamber
+
+**Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Models self-reinforcing belief loops — the cognitive echo chamber phenomenon where ideas amplify themselves without external correction. Unlike `lex-cognitive-echo` (which tracks individual transient residual activations), the echo chamber models a structured enclosure: echoes of type belief/assumption/bias/hypothesis/conviction circulate inside a Chamber with defined wall thickness. Disruption requires force exceeding the wall. Sealed chambers (wall_thickness >= 0.8) are nearly impervious to external correction.
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-echo-chamber`
+- **Version**: `0.1.0`
+- **Module**: `Legion::Extensions::CognitiveEchoChamber`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_echo_chamber/
+  cognitive_echo_chamber.rb
+  version.rb
+  client.rb
+  helpers/
+    constants.rb
+    chamber_engine.rb
+    echo.rb
+    chamber.rb
+  runners/
+    cognitive_echo_chamber.rb
+```
+
+## Key Constants
+
+From `helpers/constants.rb`:
+
+- `ECHO_TYPES` — `%i[belief assumption bias hypothesis conviction]`
+- `CHAMBER_STATES` — `%i[forming resonating saturated disrupted collapsed]`
+- `MAX_ECHOES` = `500`, `MAX_CHAMBERS` = `50`
+- `AMPLIFICATION_RATE` = `0.1`, `DECAY_RATE` = `0.02`
+- `DISRUPTION_THRESHOLD` = `0.7` (resonance level at which a chamber is considered saturated; also the echo amplitude threshold for `resonate?`)
+- `SEALED_THRESHOLD` = `0.8` (wall_thickness >= this = sealed, nearly impossible to disrupt)
+- `POROUS_THRESHOLD` = `0.3` (wall_thickness <= this = porous, easily disrupted)
+- `BREAKTHROUGH_BONUS` = `0.15` (fraction of breakthrough force subtracted from wall_thickness on successful disruption)
+- `SILENT_THRESHOLD` = `0.05`, `DEFAULT_AMPLITUDE` = `0.5`, `DEFAULT_WALL_THICKNESS` = `0.5`
+- `RESONANCE_LABELS` — range hash: `0.8+` = `:thunderous`, `0.6` = `:resonant`, `0.4` = `:humming`, `0.2` = `:fading`, below = `:silent`
+- `AMPLIFICATION_LABELS` — `0.8+` = `:deafening`, `0.6` = `:loud`, `0.4` = `:moderate`, `0.2` = `:quiet`, below = `:muted`
+- `CHAMBER_STATE_LABELS` — human-readable descriptions of each chamber state
+
+## Runners
+
+All methods in `Runners::CognitiveEchoChamber`:
+
+- `create_echo(content:, echo_type: :belief, domain: :general, source_agent: nil, amplitude: 0.5, engine: nil)` — creates a new echo in the pool; validates content non-empty; invalid echo_type defaults to `:belief`
+- `create_chamber(label:, domain: :general, wall_thickness: 0.5, engine: nil)` — creates a new named chamber enclosure
+- `amplify(echo_id:, rate: 0.1, engine: nil)` — increases echo amplitude; also increments echo frequency counter
+- `disrupt(chamber_id:, force:, engine: nil)` — attempts to break through a chamber's walls; fails if force <= wall_thickness; success reduces wall_thickness by `breakthrough * BREAKTHROUGH_BONUS` and dampens all enclosed echoes by the breakthrough amount
+- `list_echoes(echo_type: nil, domain: nil, engine: nil)` — returns active echoes; optionally filtered by type and/or domain
+- `chamber_status(engine: nil)` — full report: total echoes, active echoes, resonating echoes, total chambers, sealed/porous counts, disruption count, loudest 3 echoes
+
+## Helpers
+
+- `ChamberEngine` — manages `@echoes` hash and `@chambers` hash. `decay_all!` applies `DECAY_RATE` to all echoes and prunes silent ones. `add_echo_to_chamber(echo_id:, chamber_id:)` links an echo into a chamber. `disruption_history` returns a copy of the disruption log. Pruning: on overflow, silent echoes removed first; if still over limit, the faintest echo removed.
+- `Echo` — amplitude-tracked belief unit. `amplify!(rate)` increments both amplitude and frequency. `dampen!(rate)` reduces amplitude. Predicates: `resonate?` (amplitude >= 0.7), `fading?` (amplitude <= 0.3), `silent?` (amplitude <= 0.05). `frequency_label` uses `RESONANCE_LABELS` against a normalized frequency score (frequency / 20, capped at 1.0).
+- `Chamber` — enclosure with `wall_thickness`, `resonance_frequency`, `state`. `add_echo(echo)` adds to internal echo pool and recalculates resonance. `amplify_all!(rate)` amplifies every enclosed echo. `disrupt!(force)` returns `{ success: false }` if force <= wall_thickness, otherwise reduces wall and dampens echoes. `resonance_frequency` = ratio of resonating echoes to total echoes. State transitions: `:forming` -> `:resonating` (resonance >= 0.3) -> `:saturated` (resonance >= 0.7); disruption locks state to `:disrupted`.
+
+## Integration Points
+
+- `lex-cognitive-echo` models individual transient residual activations; `lex-cognitive-echo-chamber` models the structural enclosure effect where similar echoes reinforce each other and resist correction.
+- `disrupt` is the mechanism for injecting counter-evidence. Callers from `lex-tick` can call `disrupt` with external input force to model perspective-challenging interactions.
+- `source_agent` on echoes links chamber beliefs back to the originating agent — useful for `lex-mesh` multi-agent scenarios where one agent's beliefs propagate into another's echo chamber.
+- `chamber_status` resonating/sealed metrics can be surfaced during `lex-tick`'s `post_tick_reflection` phase to flag cognitive rigidity.
+
+## Development Notes
+
+- Chambers and echoes are separate pools — an echo must be explicitly added to a chamber via `add_echo_to_chamber`. Creating an echo does not auto-enroll it in any chamber.
+- `Chamber#disrupt!` reduces `wall_thickness` by `breakthrough * BREAKTHROUGH_BONUS`, not by the full breakthrough amount — chambers become easier to disrupt over time but never instantly destroyed.
+- Chamber state transitions are blocked once state is `:disrupted` or `:collapsed` — the engine must explicitly manage transition out of these states.
+- `resonance_frequency` on a Chamber is the ratio of `resonate?` echoes to total echoes — distinct from the global engine's `resonating_echoes` count.
+- `Echo#frequency` counts amplify calls, not time — it is a repetition counter, not a temporal frequency.

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/Gemfile.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: .
+  specs:
+    lex-cognitive-echo-chamber (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-echo-chamber!
+  rspec (~> 3.13)
+  rubocop (~> 1.75)
+  rubocop-rspec
+
+BUNDLED WITH
+   2.6.9

data/README.md

@@ -0,0 +1,57 @@
+# lex-cognitive-echo-chamber
+
+Self-reinforcing belief loop modeling for the LegionIO cognitive architecture. Tracks how beliefs, assumptions, and biases amplify inside an enclosed cognitive space — and models how external disruption can break through chamber walls.
+
+## What It Does
+
+An echo chamber is a named enclosure with a wall thickness that resists external input. Echoes (of type belief, assumption, bias, hypothesis, or conviction) are created in a shared pool and can be added to a chamber. Echoes inside a chamber amplify each other — the more a belief echoes, the stronger its amplitude grows. Disruption requires applying a force that exceeds the wall thickness; a successful disruption reduces the wall (making future disruptions easier) and dampens enclosed echoes.
+
+Chambers progress through states: `forming` (sparse) -> `resonating` (active reinforcement) -> `saturated` (maximum self-reinforcement). A sealed chamber (wall_thickness >= 0.8) is nearly impervious to correction. A porous chamber (wall_thickness <= 0.3) absorbs external input readily.
+
+## Usage
+
+```ruby
+client = Legion::Extensions::CognitiveEchoChamber::Client.new
+
+# Create an echo in the pool
+result = client.create_echo(
+  content: 'all uncertainty should be resolved before acting',
+  echo_type: :belief,
+  domain: :decision_making
+)
+echo_id = result[:echo][:id]
+
+# Create a chamber enclosure
+chamber_result = client.create_chamber(
+  label: 'conservative_bias',
+  domain: :decision_making,
+  wall_thickness: 0.6
+)
+chamber_id = chamber_result[:chamber][:id]
+
+# Amplify the echo — each call increases amplitude and frequency count
+client.amplify(echo_id: echo_id)
+
+# Attempt disruption with external counter-evidence
+client.disrupt(chamber_id: chamber_id, force: 0.8)
+# Returns: { success: true, breakthrough: 0.2, wall_remaining: 0.57 }
+# Or: { success: false, reason: 'insufficient_force' }
+
+# Query echoes
+client.list_echoes(echo_type: :belief, domain: :decision_making)
+
+# Status report
+client.chamber_status
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-echo-chamber.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_echo_chamber/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-echo-chamber'
+  spec.version       = Legion::Extensions::CognitiveEchoChamber::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Cognitive echo chamber dynamics for LegionIO agentic architecture'
+  spec.description   = 'Models cognitive echo chambers — when thoughts reinforce themselves without ' \
+                       'external challenge, creating self-reinforcing belief loops. Tracks amplification, ' \
+                       'resonance, and breakthrough events when external input disrupts the echo.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-echo-chamber'
+  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-chamber'
+  spec.metadata['documentation_uri']     = 'https://github.com/LegionIO/lex-cognitive-echo-chamber/blob/master/README.md'
+  spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/lex-cognitive-echo-chamber/blob/master/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri']       = 'https://github.com/LegionIO/lex-cognitive-echo-chamber/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_chamber/client.rb

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

data/lib/legion/extensions/cognitive_echo_chamber/helpers/chamber.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveEchoChamber
+      module Helpers
+        class Chamber
+          include Constants
+
+          attr_reader :id, :label, :domain, :state, :wall_thickness,
+                      :resonance_frequency, :created_at, :disruption_count
+
+          def initialize(label:, domain: :general, wall_thickness: DEFAULT_WALL_THICKNESS)
+            @id                  = SecureRandom.uuid
+            @label               = label
+            @domain              = domain.to_sym
+            @state               = :forming
+            @wall_thickness      = wall_thickness.to_f.clamp(0.0, 1.0).round(10)
+            @resonance_frequency = 0.0
+            @echoes              = {}
+            @disruption_count    = 0
+            @created_at          = Time.now.utc
+          end
+
+          def add_echo(echo)
+            return false if @echoes.size >= MAX_ECHOES
+
+            @echoes[echo.id] = echo
+            recalculate_resonance
+            update_state
+            true
+          end
+
+          def remove_echo(echo_id)
+            removed = @echoes.delete(echo_id)
+            recalculate_resonance if removed
+            update_state
+            !removed.nil?
+          end
+
+          def amplify_all!(rate = AMPLIFICATION_RATE)
+            @echoes.each_value { |e| e.amplify!(rate) }
+            recalculate_resonance
+            update_state
+            { amplified: @echoes.size, resonance_frequency: @resonance_frequency }
+          end
+
+          def disrupt!(force)
+            force = force.to_f.clamp(0.0, 1.0)
+            return { success: false, reason: 'insufficient_force', force: force, wall: @wall_thickness } if force <= @wall_thickness
+
+            @disruption_count += 1
+            breakthrough = force - @wall_thickness
+            @wall_thickness = (@wall_thickness - (breakthrough * BREAKTHROUGH_BONUS)).clamp(0.0, 1.0).round(10)
+            @echoes.each_value { |e| e.dampen!(breakthrough.round(10)) }
+            @state = :disrupted
+            recalculate_resonance
+            { success: true, force: force, breakthrough: breakthrough.round(10), wall_remaining: @wall_thickness }
+          end
+
+          def sealed?
+            @wall_thickness >= SEALED_THRESHOLD
+          end
+
+          def porous?
+            @wall_thickness <= POROUS_THRESHOLD
+          end
+
+          def resonance_level
+            Constants.label_for(RESONANCE_LABELS, @resonance_frequency)
+          end
+
+          def echo_count
+            @echoes.size
+          end
+
+          def active_echoes
+            @echoes.values.reject(&:silent?)
+          end
+
+          def resonating_echoes
+            @echoes.values.select(&:resonate?)
+          end
+
+          def to_h
+            {
+              id:                  @id,
+              label:               @label,
+              domain:              @domain,
+              state:               @state,
+              wall_thickness:      @wall_thickness,
+              resonance_frequency: @resonance_frequency,
+              resonance_level:     resonance_level,
+              sealed:              sealed?,
+              porous:              porous?,
+              echo_count:          echo_count,
+              active_echo_count:   active_echoes.size,
+              disruption_count:    @disruption_count,
+              created_at:          @created_at
+            }
+          end
+
+          private
+
+          def recalculate_resonance
+            return @resonance_frequency = 0.0 if @echoes.empty?
+
+            resonating = resonating_echoes
+            @resonance_frequency = (resonating.size.to_f / @echoes.size).round(10)
+          end
+
+          def update_state
+            return if @state == :disrupted || @state == :collapsed
+            return @state = :forming if @echoes.empty?
+
+            @state = if @resonance_frequency >= DISRUPTION_THRESHOLD
+                       :saturated
+                     elsif @resonance_frequency >= POROUS_THRESHOLD
+                       :resonating
+                     else
+                       :forming
+                     end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_echo_chamber/helpers/chamber_engine.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveEchoChamber
+      module Helpers
+        class ChamberEngine
+          include Constants
+
+          def initialize
+            @echoes           = {}
+            @chambers         = {}
+            @disruption_history = []
+          end
+
+          def create_echo(content:, echo_type: :belief, domain: :general,
+                          source_agent: nil, amplitude: DEFAULT_AMPLITUDE)
+            prune_echoes
+            echo = Echo.new(
+              content:      content,
+              echo_type:    echo_type,
+              domain:       domain,
+              source_agent: source_agent,
+              amplitude:    amplitude
+            )
+            @echoes[echo.id] = echo
+            echo
+          end
+
+          def create_chamber(label:, domain: :general, wall_thickness: DEFAULT_WALL_THICKNESS)
+            prune_chambers
+            chamber = Chamber.new(label: label, domain: domain, wall_thickness: wall_thickness)
+            @chambers[chamber.id] = chamber
+            chamber
+          end
+
+          def amplify_echo(echo_id:, rate: AMPLIFICATION_RATE)
+            echo = @echoes[echo_id]
+            return nil unless echo
+
+            echo.amplify!(rate)
+            echo
+          end
+
+          def disrupt_chamber(chamber_id:, force:)
+            chamber = @chambers[chamber_id]
+            return { success: false, error: 'chamber not found' } unless chamber
+
+            result = chamber.disrupt!(force)
+            record_disruption(chamber_id: chamber_id, force: force, result: result) if result[:success]
+            result
+          end
+
+          def decay_all!
+            echo_count = @echoes.size
+            @echoes.each_value { |e| e.dampen!(DECAY_RATE) }
+            prune_silent_echoes
+            { decayed: echo_count, remaining: @echoes.size, pruned: echo_count - @echoes.size }
+          end
+
+          def echoes_by_type(echo_type:)
+            @echoes.values.select { |e| e.echo_type == echo_type.to_sym }
+          end
+
+          def loudest_echoes(limit: 5)
+            @echoes.values.sort_by { |e| -e.amplitude }.first(limit)
+          end
+
+          def most_sealed_chambers(limit: 5)
+            @chambers.values.sort_by { |c| -c.wall_thickness }.first(limit)
+          end
+
+          def disruption_history
+            @disruption_history.dup
+          end
+
+          def add_echo_to_chamber(echo_id:, chamber_id:)
+            echo    = @echoes[echo_id]
+            chamber = @chambers[chamber_id]
+            return { success: false, error: 'echo not found' } unless echo
+            return { success: false, error: 'chamber not found' } unless chamber
+
+            added = chamber.add_echo(echo)
+            { success: added, echo_id: echo_id, chamber_id: chamber_id }
+          end
+
+          def echo_report
+            {
+              total_echoes:      @echoes.size,
+              active_echoes:     active_echoes.size,
+              resonating_echoes: resonating_echoes.size,
+              total_chambers:    @chambers.size,
+              sealed_chambers:   @chambers.values.count(&:sealed?),
+              porous_chambers:   @chambers.values.count(&:porous?),
+              disruption_count:  @disruption_history.size,
+              loudest:           loudest_echoes(limit: 3).map(&:to_h)
+            }
+          end
+
+          def active_echoes
+            @echoes.values.reject(&:silent?)
+          end
+
+          def resonating_echoes
+            @echoes.values.select(&:resonate?)
+          end
+
+          def chamber_by_id(chamber_id)
+            @chambers[chamber_id]
+          end
+
+          def echo_by_id(echo_id)
+            @echoes[echo_id]
+          end
+
+          private
+
+          def prune_echoes
+            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(&:amplitude)
+            @echoes.delete(faintest.id) if faintest
+          end
+
+          def prune_chambers
+            return if @chambers.size < MAX_CHAMBERS
+
+            collapsed = @chambers.values.select { |c| c.state == :collapsed }
+            collapsed.each { |c| @chambers.delete(c.id) }
+          end
+
+          def prune_silent_echoes
+            @echoes.select { |_, e| e.silent? }.each_key { |id| @echoes.delete(id) }
+          end
+
+          def record_disruption(chamber_id:, force:, result:)
+            @disruption_history << {
+              chamber_id:   chamber_id,
+              force:        force,
+              breakthrough: result[:breakthrough],
+              occurred_at:  Time.now.utc
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveEchoChamber
+      module Helpers
+        module Constants
+          MAX_ECHOES             = 500
+          MAX_CHAMBERS           = 50
+          AMPLIFICATION_RATE     = 0.1
+          DECAY_RATE             = 0.02
+          DISRUPTION_THRESHOLD   = 0.7
+          SEALED_THRESHOLD       = 0.8
+          POROUS_THRESHOLD       = 0.3
+          BREAKTHROUGH_BONUS     = 0.15
+          SILENT_THRESHOLD       = 0.05
+          DEFAULT_AMPLITUDE      = 0.5
+          DEFAULT_WALL_THICKNESS = 0.5
+
+          ECHO_TYPES = %i[belief assumption bias hypothesis conviction].freeze
+
+          CHAMBER_STATES = %i[forming resonating saturated disrupted collapsed].freeze
+
+          RESONANCE_LABELS = {
+            (0.8..)     => :thunderous,
+            (0.6...0.8) => :resonant,
+            (0.4...0.6) => :humming,
+            (0.2...0.4) => :fading,
+            (..0.2)     => :silent
+          }.freeze
+
+          AMPLIFICATION_LABELS = {
+            (0.8..)     => :deafening,
+            (0.6...0.8) => :loud,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :quiet,
+            (..0.2)     => :muted
+          }.freeze
+
+          CHAMBER_STATE_LABELS = {
+            forming:    'Chamber is newly formed, echoes still accumulating',
+            resonating: 'Chamber is actively reinforcing beliefs',
+            saturated:  'Chamber has reached maximum self-reinforcement',
+            disrupted:  'External input has broken through the chamber walls',
+            collapsed:  'Chamber has lost coherence and dissolved'
+          }.freeze
+
+          def self.label_for(table, value)
+            match = table.find { |range, _| range.cover?(value) }
+            match&.last
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveEchoChamber
+      module Helpers
+        class Echo
+          include Constants
+
+          attr_reader :id, :content, :echo_type, :domain, :source_agent,
+                      :amplitude, :frequency, :original_amplitude, :created_at
+
+          def initialize(content:, echo_type: :belief, domain: :general,
+                         source_agent: nil, amplitude: DEFAULT_AMPLITUDE)
+            @id               = SecureRandom.uuid
+            @content          = content
+            @echo_type        = validate_type(echo_type)
+            @domain           = domain.to_sym
+            @source_agent     = source_agent
+            @amplitude        = amplitude.to_f.clamp(0.0, 1.0).round(10)
+            @original_amplitude = @amplitude
+            @frequency        = 1
+            @created_at       = Time.now.utc
+          end
+
+          def amplify!(rate = AMPLIFICATION_RATE)
+            @frequency += 1
+            @amplitude = (@amplitude + rate).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def dampen!(rate = DECAY_RATE)
+            @amplitude = (@amplitude - rate).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def resonate?
+            @amplitude >= DISRUPTION_THRESHOLD
+          end
+
+          def fading?
+            @amplitude <= POROUS_THRESHOLD
+          end
+
+          def silent?
+            @amplitude <= SILENT_THRESHOLD
+          end
+
+          def frequency_label
+            Constants.label_for(RESONANCE_LABELS, frequency_score)
+          end
+
+          def amplitude_label
+            Constants.label_for(AMPLIFICATION_LABELS, @amplitude)
+          end
+
+          def to_h
+            {
+              id:                 @id,
+              content:            @content,
+              echo_type:          @echo_type,
+              domain:             @domain,
+              source_agent:       @source_agent,
+              amplitude:          @amplitude,
+              original_amplitude: @original_amplitude,
+              frequency:          @frequency,
+              frequency_label:    frequency_label,
+              amplitude_label:    amplitude_label,
+              resonate:           resonate?,
+              fading:             fading?,
+              silent:             silent?,
+              created_at:         @created_at
+            }
+          end
+
+          private
+
+          def validate_type(type)
+            sym = type.to_sym
+            ECHO_TYPES.include?(sym) ? sym : :belief
+          end
+
+          def frequency_score
+            [@frequency.to_f / 20.0, 1.0].min.round(10)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveEchoChamber
+      module Runners
+        module CognitiveEchoChamber
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def create_echo(content:, echo_type: :belief, domain: :general,
+                          source_agent: nil, amplitude: 0.5, engine: nil, **)
+            raise ArgumentError, 'content cannot be empty' if content.to_s.strip.empty?
+
+            eng  = engine || default_engine
+            echo = eng.create_echo(
+              content:      content,
+              echo_type:    echo_type,
+              domain:       domain,
+              source_agent: source_agent,
+              amplitude:    amplitude
+            )
+            Legion::Logging.debug "[cognitive_echo_chamber] echo created id=#{echo.id} type=#{echo_type} domain=#{domain}"
+            { success: true, echo: echo.to_h }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def create_chamber(label:, domain: :general, wall_thickness: 0.5, engine: nil, **)
+            raise ArgumentError, 'label cannot be empty' if label.to_s.strip.empty?
+
+            eng     = engine || default_engine
+            chamber = eng.create_chamber(label: label, domain: domain, wall_thickness: wall_thickness)
+            Legion::Logging.debug "[cognitive_echo_chamber] chamber created id=#{chamber.id} label=#{label}"
+            { success: true, chamber: chamber.to_h }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def amplify(echo_id:, rate: 0.1, engine: nil, **)
+            eng  = engine || default_engine
+            echo = eng.amplify_echo(echo_id: echo_id, rate: rate)
+            return { success: false, error: 'echo not found' } unless echo
+
+            Legion::Logging.debug "[cognitive_echo_chamber] amplified echo=#{echo_id} amplitude=#{echo.amplitude}"
+            { success: true, echo: echo.to_h }
+          end
+
+          def disrupt(chamber_id:, force:, engine: nil, **)
+            eng    = engine || default_engine
+            result = eng.disrupt_chamber(chamber_id: chamber_id, force: force)
+            Legion::Logging.debug "[cognitive_echo_chamber] disrupt chamber=#{chamber_id} success=#{result[:success]}"
+            result
+          end
+
+          def list_echoes(echo_type: nil, domain: nil, engine: nil, **)
+            eng    = engine || default_engine
+            echoes = if echo_type
+                       eng.echoes_by_type(echo_type: echo_type)
+                     else
+                       eng.active_echoes
+                     end
+            echoes = echoes.select { |e| e.domain == domain.to_sym } if domain
+            { success: true, echoes: echoes.map(&:to_h), count: echoes.size }
+          end
+
+          def chamber_status(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, **eng.echo_report }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::ChamberEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_echo_chamber.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'cognitive_echo_chamber/version'
+require_relative 'cognitive_echo_chamber/helpers/constants'
+require_relative 'cognitive_echo_chamber/helpers/echo'
+require_relative 'cognitive_echo_chamber/helpers/chamber'
+require_relative 'cognitive_echo_chamber/helpers/chamber_engine'
+require_relative 'cognitive_echo_chamber/runners/cognitive_echo_chamber'
+require_relative 'cognitive_echo_chamber/client'
+
+module Legion
+  module Extensions
+    module CognitiveEchoChamber
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-echo-chamber
+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 cognitive echo chambers — when thoughts reinforce themselves without
+  external challenge, creating self-reinforcing belief loops. Tracks amplification,
+  resonance, and breakthrough events when external input disrupts the echo.
+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-echo-chamber.gemspec
+- lib/legion/extensions/cognitive_echo_chamber.rb
+- lib/legion/extensions/cognitive_echo_chamber/client.rb
+- lib/legion/extensions/cognitive_echo_chamber/helpers/chamber.rb
+- lib/legion/extensions/cognitive_echo_chamber/helpers/chamber_engine.rb
+- lib/legion/extensions/cognitive_echo_chamber/helpers/constants.rb
+- lib/legion/extensions/cognitive_echo_chamber/helpers/echo.rb
+- lib/legion/extensions/cognitive_echo_chamber/runners/cognitive_echo_chamber.rb
+- lib/legion/extensions/cognitive_echo_chamber/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-echo-chamber
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-echo-chamber
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-echo-chamber
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-echo-chamber/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-echo-chamber/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-echo-chamber/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: Cognitive echo chamber dynamics for LegionIO agentic architecture
+test_files: []