lex-cognitive-prism 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2866c399e77ba7a627177c1260044518ba6605ddb64b0e22b7372b82739733f2
+  data.tar.gz: 55b48aeea65122c92cd15f280aee3b9fe4a02875a51496cce44f17fe78238a56
+SHA512:
+  metadata.gz: 2d6a93e60168661c0e8c62ed3e671c2afd8356d1c87e63e8294ef71066ba29c0da92b4f11f50b77b58fb76c9b538a7488d51c6fbe1b777ed526d8df37f82915d
+  data.tar.gz: 57e618e9139a6701313b3baf52df1a6faa88d53fc7a77fedb02204b3c44d84cb87b551d8cd97e26b4f63df41e9ac7e8b2f74efdc04121151deb1d758c641ea5d

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

data/.rubocop.yml

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

data/CLAUDE.md

@@ -0,0 +1,111 @@
+# lex-cognitive-prism
+
+**Level 3 Leaf Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+
+## Purpose
+
+Light prism metaphor for cognitive decomposition and synthesis. A beam of cognitive content (idea, concept, problem) is passed through a prism to decompose it into spectral components across eight bands: infrared (meta_contextual), red (concrete), orange (applied), yellow (structural), green (relational), blue (conceptual), violet (abstract), ultraviolet (transcendent). Each band maps to an abstraction level. Components can be attenuated (faded) or amplified (boosted). Decomposed beams can be recomposed from selected active components into a synthesized view.
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-prism`
+- **Module**: `Legion::Extensions::CognitivePrism`
+- **Version**: `0.1.0`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_prism/
+  version.rb
+  client.rb
+  helpers/
+    constants.rb
+    spectral_component.rb
+    beam.rb
+    prism_engine.rb
+  runners/
+    cognitive_prism.rb
+```
+
+## Key Constants
+
+| Constant | Value | Purpose |
+|---|---|---|
+| `SPECTRAL_BANDS` | `%i[infrared red orange yellow green blue violet ultraviolet]` | Eight cognitive abstraction levels |
+| `WAVELENGTH_RANGES` | hash | Wavelength integer ranges per band (700–1000 for infrared down to 10–379 for ultraviolet) |
+| `MAX_BEAMS` | `200` | Per-engine beam capacity (raises `ArgumentError` at limit) |
+| `INTENSITY_LABELS` | array of range/label hashes | From `:trace` to `:brilliant` |
+| `PURITY_LABELS` | array of range/label hashes | From `:turbid` to `:prismatic` |
+
+## Helpers
+
+### `Helpers::SpectralComponent`
+One spectral band of a decomposed beam. Has `band`, `wavelength`, `intensity` (0.0–1.0), and `content` (chunk of original content for that band).
+
+Constants on the class: `ATTENUATION_RATE_DEFAULT = 0.05`, `AMPLIFY_BOOST_DEFAULT = 0.1`, `DOMINANT_THRESHOLD = 0.7`, `FADED_THRESHOLD = 0.1`.
+
+- `attenuate!(rate:)` — reduces intensity
+- `amplify!(boost:)` — increases intensity
+- `dominant?` — intensity >= 0.7
+- `faded?` — intensity <= 0.1
+- `intensity_label`
+- `to_h`
+
+### `Helpers::Beam`
+Cognitive content beam awaiting or having undergone decomposition. Has `beam_id`, `domain`, `content`, `components` (array), and `purity`.
+
+- `decompose!` — chunks content by band using `assign_bands`; assigns abstraction levels; computes intensity per band via `compute_intensity` (base from chunk length × abstraction weight); computes purity
+- `recompose` → string synthesizing active non-faded components sorted by intensity
+- `dominant_band` → band with highest intensity (or first dominant band)
+- `spectral_balance` → hash of `band => fraction_of_total`
+- `purity` — uniformity metric: 1.0 = perfectly even distribution; 0.0 = single dominant band. Formula normalizes dominance ratio against ideal uniform ratio.
+- `to_h`
+
+**Abstraction weights** (applied in `compute_intensity`): concrete = 1.0, applied = 0.9, structural = 0.85, relational = 0.8, conceptual = 0.75, abstract = 0.7, meta_contextual = 0.6, transcendent = 0.5. Concrete bands produce higher intensity from same content length.
+
+### `Helpers::PrismEngine`
+Top-level store.
+
+- `create_beam(domain:, content:, beam_id:)` → creation result or raises `ArgumentError` at `MAX_BEAMS`
+- `decompose(beam_id)` → decomposition result with `component_count`, `dominant_band`, `purity`
+- `recompose(component_ids)` → synthesis result from selected component IDs
+- `attenuate_all!(rate:)` → count of attenuated components
+- `dominant_bands` → frequency hash of which bands dominate across all beams
+- `most_intense(limit:)` → top N components across all beams
+- `spectral_report` → aggregate stats
+- `get_beam(beam_id)` → beam object
+- `clear!` → empties all beams and components
+
+## Runners
+
+Module: `Runners::CognitivePrism`
+
+| Runner Method | Description |
+|---|---|
+| `create_beam(domain:, content:, beam_id:)` | Register a new beam |
+| `decompose(beam_id:)` | Decompose beam into spectral components |
+| `recompose(component_ids:)` | Synthesize from selected components |
+| `attenuate_all(rate:)` | Attenuate all components (decay) |
+| `dominant_bands` | Frequency of dominant bands across all beams |
+| `most_intense(limit:)` | Top N most intense components |
+| `spectral_report` | Aggregate stats |
+
+All runners return `{success: true/false, ...}` hashes. Error responses on `ArgumentError` (e.g., capacity exceeded, unknown band).
+
+## Integration Points
+
+- `lex-tick` `action_selection` phase: decompose the current situation → dominant band determines reasoning style (concrete band dominant → ground action in facts; abstract band dominant → conceptual reasoning)
+- `lex-memory`: decomposed beams can be stored per-band as semantic traces with band as domain tag
+- `lex-emotion`: ultraviolet (transcendent) band intensity reflects metacognitive depth; can influence arousal
+- Purity score: high purity = balanced multi-perspective analysis; low purity = narrow single-mode thinking
+
+## Development Notes
+
+- `Client` instantiates `@default_engine = Helpers::PrismEngine.new` via runner memoization
+- `decompose!` splits content by equal chunks across 8 bands: `chunk_size = content.length / 8` (ceiling). Short content means small chunks per band.
+- Purity formula: `1.0 - |(dominance_ratio - 1/n) * n / (n-1)|` — measures deviation from perfect uniformity; high purity ≠ high clarity, it means balanced spectral distribution
+- `recompose(component_ids)` looks up IDs in `@components` hash keyed by `"#{beam_id}:#{band}"` format
+- `MAX_BEAMS = 200` raises `ArgumentError` (not returns error hash) — rescue is in the runner layer

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'
+  gem 'rubocop-rspec', require: false
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/Gemfile.lock

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

data/README.md

@@ -0,0 +1,61 @@
+# lex-cognitive-prism
+
+Light prism decomposition model for LegionIO cognitive agents. Cognitive beams (ideas, problems, concepts) are decomposed into eight spectral bands across abstraction levels from concrete to transcendent. Bands can be attenuated or amplified; active components can be recomposed into a synthesized view.
+
+## What It Does
+
+- Eight spectral bands mapping to abstraction levels:
+  - `infrared` → meta_contextual
+  - `red` → concrete
+  - `orange` → applied
+  - `yellow` → structural
+  - `green` → relational
+  - `blue` → conceptual
+  - `violet` → abstract
+  - `ultraviolet` → transcendent
+- Decompose: split content across bands with intensity based on chunk size × abstraction weight
+- Purity score: uniformity of spectral distribution (high = balanced multi-perspective)
+- Dominant band: highest-intensity spectral component
+- Recompose: synthesize a view from selected active (non-faded) component IDs
+- Attenuation: fade all components (global decay cycle)
+
+## Usage
+
+```ruby
+# Create a beam
+result = runner.create_beam(domain: :architecture,
+                              content: 'decompose the service by bounded context applying DDD')
+
+# Decompose into spectral components
+runner.decompose(beam_id: result[:beam_id])
+# => { success: true, component_count: 8, dominant_band: :red, purity: 0.72 }
+
+# Get all beams dominant band distribution
+runner.dominant_bands
+# => { success: true, bands: { red: 3, blue: 1, violet: 1 } }
+
+# Most intense components across all beams
+runner.most_intense(limit: 3)
+
+# Recompose from specific component IDs
+runner.recompose(component_ids: ['beam-id:red', 'beam-id:blue', 'beam-id:violet'])
+# => { success: true, synthesis: 'red(...): ... | blue(...): ... | violet(...): ...' }
+
+# Attenuate all (periodic fade)
+runner.attenuate_all(rate: 0.05)
+
+# Status
+runner.spectral_report
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-prism.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_prism/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-prism'
+  spec.version       = Legion::Extensions::CognitivePrism::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Cognitive Prism'
+  spec.description   = 'Spectral decomposition of complex ideas into band-specific components — ' \
+                       'white light in, rainbow out. Decompose ideas across abstraction wavelengths, ' \
+                       'attenuate and amplify components, then recompose synthesized understanding.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-prism'
+  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-prism'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-cognitive-prism'
+  spec.metadata['changelog_uri']     = 'https://github.com/LegionIO/lex-cognitive-prism'
+  spec.metadata['bug_tracker_uri']   = 'https://github.com/LegionIO/lex-cognitive-prism/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePrism
+      class Client
+        include Runners::CognitivePrism
+
+        attr_reader :engine
+
+        def initialize(engine: nil, **)
+          @engine         = engine || Helpers::PrismEngine.new
+          @default_engine = @engine
+        end
+
+        private
+
+        attr_writer :default_engine
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_prism/helpers/beam.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePrism
+      module Helpers
+        class Beam
+          BAND_MIDPOINTS = Constants::WAVELENGTH_RANGES.transform_values do |range|
+            ((range.min + range.max) / 2.0).round
+          end.freeze
+
+          attr_reader :beam_id, :domain, :content, :components
+
+          def initialize(beam_id:, domain:, content:)
+            @beam_id    = beam_id
+            @domain     = domain
+            @content    = content
+            @components = []
+            @purity     = 0.0
+          end
+
+          def purity
+            @purity.round(10)
+          end
+
+          def decompose!
+            @components = []
+            bands = assign_bands(content)
+
+            bands.each do |band, band_content|
+              wavelength = BAND_MIDPOINTS.fetch(band)
+              intensity  = compute_intensity(band, band_content)
+              @components << SpectralComponent.new(
+                band:       band,
+                wavelength: wavelength,
+                intensity:  intensity,
+                content:    band_content
+              )
+            end
+
+            @purity = compute_purity
+            self
+          end
+
+          def recompose
+            return '' if @components.empty?
+
+            active = @components.reject(&:faded?)
+            sorted = active.sort_by { |c| -c.intensity }
+            parts  = sorted.map { |c| "#{c.band}(#{c.intensity.round(3)}): #{summarize(c.content)}" }
+            parts.join(' | ')
+          end
+
+          def dominant_band
+            return nil if @components.empty?
+
+            dominant = @components.select(&:dominant?)
+            candidates = dominant.any? ? dominant : @components
+            candidates.max_by(&:intensity)&.band
+          end
+
+          def spectral_balance
+            return {} if @components.empty?
+
+            total = @components.sum(&:intensity)
+            return {} if total.zero?
+
+            @components.to_h do |c|
+              [c.band, (c.intensity / total).round(10)]
+            end
+          end
+
+          def to_h
+            {
+              beam_id:          @beam_id,
+              domain:           @domain,
+              content:          @content,
+              purity:           purity,
+              purity_label:     purity_label,
+              dominant_band:    dominant_band,
+              spectral_balance: spectral_balance,
+              component_count:  @components.size,
+              components:       @components.map(&:to_h)
+            }
+          end
+
+          private
+
+          def assign_bands(raw_content)
+            content_str = raw_content.is_a?(String) ? raw_content : raw_content.to_s
+            total_length = content_str.length
+            chunk_size   = total_length.positive? ? (total_length.to_f / Constants::SPECTRAL_BANDS.size).ceil : 1
+
+            Constants::SPECTRAL_BANDS.each_with_index.with_object({}) do |(band, idx), acc|
+              start_pos  = idx * chunk_size
+              chunk      = total_length.positive? ? content_str[start_pos, chunk_size] || '' : ''
+              acc[band]  = { raw: chunk, abstraction_level: abstraction_level_for(band) }
+            end
+          end
+
+          def abstraction_level_for(band)
+            abstraction_map = {
+              infrared:    :meta_contextual,
+              red:         :concrete,
+              orange:      :applied,
+              yellow:      :structural,
+              green:       :relational,
+              blue:        :conceptual,
+              violet:      :abstract,
+              ultraviolet: :transcendent
+            }
+            abstraction_map.fetch(band, :unknown)
+          end
+
+          def compute_intensity(_band, band_content)
+            raw     = band_content[:raw].to_s
+            level   = band_content[:abstraction_level]
+            base    = raw.empty? ? 0.1 : (raw.length.to_f / 20).clamp(0.1, 1.0)
+            weight  = abstraction_weight(level)
+            (base * weight).clamp(0.0, 1.0).round(10)
+          end
+
+          def abstraction_weight(level)
+            weights = {
+              meta_contextual: 0.6,
+              concrete:        1.0,
+              applied:         0.9,
+              structural:      0.85,
+              relational:      0.8,
+              conceptual:      0.75,
+              abstract:        0.7,
+              transcendent:    0.5
+            }
+            weights.fetch(level, 0.7)
+          end
+
+          def compute_purity
+            return 0.0 if @components.empty?
+
+            intensities = @components.map(&:intensity)
+            total       = intensities.sum
+            return 0.0 if total.zero?
+
+            max = intensities.max
+            dominance_ratio = max / total
+            n = Constants::SPECTRAL_BANDS.size.to_f
+            uniformity = 1.0 - ((dominance_ratio - (1.0 / n)) * n / (n - 1)).abs
+            uniformity.clamp(0.0, 1.0).round(10)
+          end
+
+          def purity_label
+            Constants::PURITY_LABELS.find { |entry| entry[:range].cover?(@purity) }&.fetch(:label, :unknown)
+          end
+
+          def summarize(band_content)
+            return '' unless band_content.is_a?(Hash)
+
+            raw = band_content[:raw].to_s
+            raw.length > 30 ? "#{raw[0, 30]}..." : raw
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePrism
+      module Helpers
+        module Constants
+          SPECTRAL_BANDS = %i[infrared red orange yellow green blue violet ultraviolet].freeze
+
+          WAVELENGTH_RANGES = {
+            infrared:    700..1000,
+            red:         620..699,
+            orange:      590..619,
+            yellow:      560..589,
+            green:       490..559,
+            blue:        450..489,
+            violet:      380..449,
+            ultraviolet: 10..379
+          }.freeze
+
+          MAX_BEAMS = 200
+
+          INTENSITY_LABELS = [
+            { range: 0.0..0.19,  label: :trace },
+            { range: 0.2..0.39,  label: :faint },
+            { range: 0.4..0.59,  label: :moderate },
+            { range: 0.6..0.79,  label: :strong },
+            { range: 0.8..1.0,   label: :brilliant }
+          ].freeze
+
+          PURITY_LABELS = [
+            { range: 0.0..0.24,  label: :turbid },
+            { range: 0.25..0.49, label: :murky },
+            { range: 0.5..0.74,  label: :clear },
+            { range: 0.75..0.89, label: :pure },
+            { range: 0.9..1.0,   label: :prismatic }
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_prism/helpers/prism_engine.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePrism
+      module Helpers
+        class PrismEngine
+          def initialize
+            @beams      = {}
+            @components = {}
+          end
+
+          def create_beam(domain:, content:, beam_id: nil)
+            raise ArgumentError, "MAX_BEAMS (#{Constants::MAX_BEAMS}) reached" if @beams.size >= Constants::MAX_BEAMS
+
+            id   = beam_id || SecureRandom.uuid
+            beam = Beam.new(beam_id: id, domain: domain, content: content)
+            @beams[id] = beam
+            { success: true, beam_id: id, domain: domain }
+          end
+
+          def decompose(beam_id)
+            beam = @beams.fetch(beam_id) { return { success: false, error: "Beam #{beam_id} not found" } }
+
+            beam.decompose!
+            beam.components.each { |c| @components["#{beam_id}:#{c.band}"] = c }
+
+            Legion::Logging.debug "[cognitive_prism] decompose: beam=#{beam_id[0..7]} components=#{beam.components.size} purity=#{beam.purity.round(4)}"
+            {
+              success:         true,
+              beam_id:         beam_id,
+              component_count: beam.components.size,
+              dominant_band:   beam.dominant_band,
+              purity:          beam.purity
+            }
+          end
+
+          def recompose(component_ids)
+            selected = component_ids.filter_map { |cid| resolve_component(cid) }
+            active   = selected.reject(&:faded?)
+            return { success: true, synthesis: '', active_count: 0, total_count: 0 } if active.empty?
+
+            synthesis = build_synthesis(active)
+            { success: true, synthesis: synthesis, active_count: active.size, total_count: selected.size }
+          end
+
+          def attenuate_all!(rate: SpectralComponent::ATTENUATION_RATE_DEFAULT)
+            count = 0
+            @beams.each_value do |beam|
+              beam.components.each do |c|
+                c.attenuate!(rate: rate)
+                count += 1
+              end
+            end
+            { success: true, attenuated: count, rate: rate }
+          end
+
+          def dominant_bands
+            result = Hash.new(0)
+            @beams.each_value do |beam|
+              band = beam.dominant_band
+              result[band] += 1 if band
+            end
+            result.sort_by { |_, v| -v }.to_h
+          end
+
+          def most_intense(limit: 5)
+            all_components = @beams.values.flat_map(&:components)
+            all_components
+              .sort_by { |c| -c.intensity }
+              .first(limit)
+              .map(&:to_h)
+          end
+
+          def spectral_report
+            total_beams      = @beams.size
+            total_components = @beams.values.sum { |b| b.components.size }
+            decomposed_beams = @beams.count { |_, b| b.components.any? }
+
+            avg_purity = if decomposed_beams.positive?
+                           purity_sum = @beams.values.select { |b| b.components.any? }.sum(&:purity)
+                           (purity_sum / decomposed_beams).round(10)
+                         else
+                           0.0
+                         end
+
+            {
+              total_beams:      total_beams,
+              decomposed_beams: decomposed_beams,
+              total_components: total_components,
+              dominant_bands:   dominant_bands,
+              avg_purity:       avg_purity,
+              most_intense:     most_intense(limit: 3)
+            }
+          end
+
+          def get_beam(beam_id)
+            @beams[beam_id]
+          end
+
+          def beam_count
+            @beams.size
+          end
+
+          def clear!
+            @beams.clear
+            @components.clear
+            self
+          end
+
+          private
+
+          def resolve_component(cid)
+            return @components[cid] if @components.key?(cid)
+
+            @components.values.find { |c| component_key(c.band) == cid }
+          end
+
+          def build_synthesis(active)
+            active.sort_by { |c| -c.intensity }
+                  .map { |c| "[#{c.band}/#{c.wavelength}nm #{c.intensity.round(3)}]: #{c.content}" }
+                  .join(' | ')
+          end
+
+          def component_key(band)
+            band.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_prism/helpers/spectral_component.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePrism
+      module Helpers
+        class SpectralComponent
+          ATTENUATION_RATE_DEFAULT = 0.05
+          AMPLIFY_BOOST_DEFAULT    = 0.1
+          DOMINANT_THRESHOLD       = 0.7
+          FADED_THRESHOLD          = 0.1
+
+          attr_reader :band, :wavelength, :content
+
+          def initialize(band:, wavelength:, intensity:, content:)
+            raise ArgumentError, "Unknown band: #{band}" unless Constants::SPECTRAL_BANDS.include?(band)
+
+            range = Constants::WAVELENGTH_RANGES.fetch(band)
+            raise ArgumentError, "Wavelength #{wavelength} out of range for #{band}" unless range.cover?(wavelength)
+
+            @band       = band
+            @wavelength = wavelength
+            @intensity  = intensity.clamp(0.0, 1.0)
+            @content    = content
+          end
+
+          def intensity
+            @intensity.round(10)
+          end
+
+          def attenuate!(rate: ATTENUATION_RATE_DEFAULT)
+            @intensity = (@intensity - rate.to_f.abs).clamp(0.0, 1.0)
+            self
+          end
+
+          def amplify!(boost: AMPLIFY_BOOST_DEFAULT)
+            @intensity = (@intensity + boost.to_f.abs).clamp(0.0, 1.0)
+            self
+          end
+
+          def dominant?
+            @intensity >= DOMINANT_THRESHOLD
+          end
+
+          def faded?
+            @intensity <= FADED_THRESHOLD
+          end
+
+          def intensity_label
+            Constants::INTENSITY_LABELS.find { |entry| entry[:range].cover?(@intensity) }&.fetch(:label, :unknown)
+          end
+
+          def to_h
+            {
+              band:            @band,
+              wavelength:      @wavelength,
+              intensity:       intensity,
+              intensity_label: intensity_label,
+              content:         @content,
+              dominant:        dominant?,
+              faded:           faded?
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitivePrism
+      module Runners
+        module CognitivePrism
+          extend self
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def create_beam(domain:, content:, beam_id: nil, engine: nil, **)
+            prism = engine || default_engine
+            prism.create_beam(domain: domain, content: content, beam_id: beam_id)
+          rescue ArgumentError => e
+            Legion::Logging.warn "[cognitive_prism] create_beam failed: #{e.message}"
+            { success: false, error: e.message }
+          end
+
+          def decompose(beam_id:, engine: nil, **)
+            prism = engine || default_engine
+            prism.decompose(beam_id)
+          rescue ArgumentError => e
+            Legion::Logging.warn "[cognitive_prism] decompose failed: #{e.message}"
+            { success: false, error: e.message }
+          end
+
+          def recompose(component_ids:, engine: nil, **)
+            prism = engine || default_engine
+            prism.recompose(component_ids)
+          rescue ArgumentError => e
+            Legion::Logging.warn "[cognitive_prism] recompose failed: #{e.message}"
+            { success: false, error: e.message }
+          end
+
+          def attenuate_all(rate: Helpers::SpectralComponent::ATTENUATION_RATE_DEFAULT, engine: nil, **)
+            prism = engine || default_engine
+            prism.attenuate_all!(rate: rate)
+          rescue ArgumentError => e
+            Legion::Logging.warn "[cognitive_prism] attenuate_all failed: #{e.message}"
+            { success: false, error: e.message }
+          end
+
+          def dominant_bands(engine: nil, **)
+            prism = engine || default_engine
+            { success: true, bands: prism.dominant_bands }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def most_intense(limit: 5, engine: nil, **)
+            prism = engine || default_engine
+            { success: true, components: prism.most_intense(limit: limit) }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def spectral_report(engine: nil, **)
+            prism = engine || default_engine
+            report = prism.spectral_report
+            { success: true }.merge(report)
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::PrismEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_prism.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'cognitive_prism/version'
+require_relative 'cognitive_prism/helpers/constants'
+require_relative 'cognitive_prism/helpers/spectral_component'
+require_relative 'cognitive_prism/helpers/beam'
+require_relative 'cognitive_prism/helpers/prism_engine'
+require_relative 'cognitive_prism/runners/cognitive_prism'
+require_relative 'cognitive_prism/client'
+
+module Legion
+  module Extensions
+    module CognitivePrism
+      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-prism
+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: Spectral decomposition of complex ideas into band-specific components
+  — white light in, rainbow out. Decompose ideas across abstraction wavelengths, attenuate
+  and amplify components, then recompose synthesized understanding.
+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-prism.gemspec
+- lib/legion/extensions/cognitive_prism.rb
+- lib/legion/extensions/cognitive_prism/client.rb
+- lib/legion/extensions/cognitive_prism/helpers/beam.rb
+- lib/legion/extensions/cognitive_prism/helpers/constants.rb
+- lib/legion/extensions/cognitive_prism/helpers/prism_engine.rb
+- lib/legion/extensions/cognitive_prism/helpers/spectral_component.rb
+- lib/legion/extensions/cognitive_prism/runners/cognitive_prism.rb
+- lib/legion/extensions/cognitive_prism/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-prism
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-prism
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-prism
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-prism
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-prism
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-prism/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Cognitive Prism
+test_files: []