lex-cognitive-fermentation 0.1.0

data/lib/legion/extensions/cognitive_fermentation/helpers/substrate.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveFermentation
+      module Helpers
+        class Substrate
+          include Constants
+
+          attr_reader :id, :substrate_type, :domain, :content, :potency,
+                      :maturity, :volatility, :stage, :created_at, :catalysts_applied
+
+          def initialize(substrate_type:, domain:, content: '', potency: nil, volatility: nil)
+            @id                = SecureRandom.uuid
+            @substrate_type    = substrate_type.to_sym
+            @domain            = domain.to_sym
+            @content           = content
+            @potency           = (potency || DEFAULT_POTENCY).to_f.clamp(0.0, 1.0)
+            @maturity          = 0.0
+            @volatility        = (volatility || 0.5).to_f.clamp(0.0, 1.0)
+            @stage             = :inoculation
+            @catalysts_applied = []
+            @created_at        = Time.now.utc
+          end
+
+          def ferment!(rate = MATURATION_RATE)
+            @maturity = (@maturity + rate).clamp(0.0, 1.0).round(10)
+            @volatility = (@volatility - VOLATILITY_DECAY).clamp(0.0, 1.0).round(10)
+            advance_stage!
+            @potency = compute_potency
+          end
+
+          def catalyze!(catalyst_type)
+            @catalysts_applied << catalyst_type.to_sym
+            @potency = (@potency + CATALYSIS_BOOST).clamp(0.0, 1.0).round(10)
+            @volatility = (@volatility + 0.05).clamp(0.0, 1.0).round(10)
+          end
+
+          def spoil!
+            @potency = (@potency * 0.5).round(10)
+            @stage = :over_fermented
+          end
+
+          def ripe? = @potency >= RIPE_THRESHOLD && @maturity >= 0.5
+          def peak? = @potency >= PEAK_THRESHOLD && @stage == :peak
+          def spoiled? = @potency < SPOILAGE_THRESHOLD
+          def raw? = @stage == :inoculation
+          def aging? = @stage == :aging
+          def over_fermented? = @stage == :over_fermented
+          def multi_catalyzed? = @catalysts_applied.uniq.size >= 3
+
+          STAGE_THRESHOLDS = {
+            (0.0...0.1)   => :inoculation,
+            (0.1...0.25)  => :primary_fermentation,
+            (0.25...0.4)  => :secondary_fermentation,
+            (0.4...0.55)  => :conditioning,
+            (0.55...0.7)  => :maturation,
+            (0.7...0.85)  => :aging,
+            (0.85...0.95) => :peak,
+            (0.95..)      => :over_fermented
+          }.freeze
+
+          def age
+            ((Time.now.utc - @created_at) / 60.0).round(2)
+          end
+
+          def to_h
+            {
+              id:                @id,
+              substrate_type:    @substrate_type,
+              domain:            @domain,
+              content:           @content,
+              potency:           @potency.round(10),
+              maturity:          @maturity.round(10),
+              volatility:        @volatility.round(10),
+              stage:             @stage,
+              ripe:              ripe?,
+              peak:              peak?,
+              spoiled:           spoiled?,
+              catalysts_applied: @catalysts_applied.uniq,
+              age_minutes:       age,
+              created_at:        @created_at.iso8601
+            }
+          end
+
+          private
+
+          def advance_stage!
+            @stage = STAGE_THRESHOLDS.each do |range, stage|
+              break stage if range.cover?(@maturity)
+            end
+          end
+
+          def compute_potency
+            base = @potency
+            base += 0.02 if @stage == :peak
+            base -= OVER_FERMENTED_DECAY if @stage == :over_fermented
+            base.clamp(0.0, 1.0).round(10)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveFermentation
+      module Runners
+        module CognitiveFermentation
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def create_substrate(substrate_type:, domain:, content: '', potency: nil,
+                               volatility: nil, engine: nil, **)
+            eng = engine || @default_engine
+            sub = eng.create_substrate(substrate_type: substrate_type, domain: domain,
+                                       content: content, potency: potency, volatility: volatility)
+            { success: true, substrate: sub.to_h }
+          end
+
+          def ferment(substrate_id:, rate: nil, engine: nil, **)
+            eng = engine || @default_engine
+            sub = eng.ferment(substrate_id: substrate_id,
+                              rate:         rate || Helpers::Constants::MATURATION_RATE)
+            return { success: false, error: 'substrate not found' } unless sub
+
+            { success: true, substrate: sub.to_h }
+          end
+
+          def catalyze(substrate_id:, catalyst_type:, engine: nil, **)
+            eng = engine || @default_engine
+            sub = eng.catalyze(substrate_id: substrate_id, catalyst_type: catalyst_type)
+            return { success: false, error: 'substrate not found' } unless sub
+
+            { success: true, substrate: sub.to_h }
+          end
+
+          def ferment_all(rate: nil, engine: nil, **)
+            eng = engine || @default_engine
+            eng.ferment_all!(rate: rate || Helpers::Constants::MATURATION_RATE)
+            { success: true }
+          end
+
+          def list_ripe(engine: nil, **)
+            eng = engine || @default_engine
+            ripe = eng.ripe_substrates
+            { success: true, count: ripe.size, substrates: ripe.map(&:to_h) }
+          end
+
+          def fermentation_status(engine: nil, **)
+            eng = engine || @default_engine
+            report = eng.fermentation_report
+            { success: true, **report }
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_fermentation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'cognitive_fermentation/version'
+require_relative 'cognitive_fermentation/helpers/constants'
+require_relative 'cognitive_fermentation/helpers/substrate'
+require_relative 'cognitive_fermentation/helpers/batch'
+require_relative 'cognitive_fermentation/helpers/fermentation_engine'
+require_relative 'cognitive_fermentation/runners/cognitive_fermentation'
+require_relative 'cognitive_fermentation/client'
+
+module Legion
+  module Extensions
+    module CognitiveFermentation
+    end
+  end
+end

data/spec/legion/extensions/cognitive_fermentation/client_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveFermentation::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:create_substrate, :ferment, :catalyze, :fermentation_status)
+  end
+
+  it 'runs a full fermentation lifecycle' do
+    result = client.create_substrate(substrate_type: :raw_idea, domain: :cognitive, content: 'test')
+    sub_id = result[:substrate][:id]
+
+    client.catalyze(substrate_id: sub_id, catalyst_type: :analogy)
+    10.times { client.ferment(substrate_id: sub_id) }
+
+    status = client.fermentation_status
+    expect(status[:total_substrates]).to eq(1)
+    expect(status[:success]).to be true
+  end
+
+  it 'lists ripe substrates' do
+    result = client.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.8)
+    sub_id = result[:substrate][:id]
+    15.times { client.ferment(substrate_id: sub_id, rate: 0.05) }
+    ripe = client.list_ripe
+    expect(ripe[:success]).to be true
+  end
+
+  it 'ferments all substrates' do
+    client.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+    client.create_substrate(substrate_type: :raw_idea, domain: :emotional)
+    result = client.ferment_all
+    expect(result[:success]).to be true
+  end
+end

data/spec/legion/extensions/cognitive_fermentation/helpers/batch_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveFermentation::Helpers::Batch do
+  subject(:batch) { described_class.new(domain: :cognitive) }
+
+  let(:substrate_class) { Legion::Extensions::CognitiveFermentation::Helpers::Substrate }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(batch.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores domain' do
+      expect(batch.domain).to eq(:cognitive)
+    end
+
+    it 'starts with empty substrates' do
+      expect(batch.substrates).to be_empty
+    end
+  end
+
+  describe '#add_substrate' do
+    it 'adds substrate to batch' do
+      sub = substrate_class.new(substrate_type: :raw_idea, domain: :cognitive)
+      batch.add_substrate(sub)
+      expect(batch.substrates.size).to eq(1)
+    end
+  end
+
+  describe '#ferment_all!' do
+    it 'ferments all substrates' do
+      sub = substrate_class.new(substrate_type: :raw_idea, domain: :cognitive)
+      batch.add_substrate(sub)
+      batch.ferment_all!
+      expect(sub.maturity).to be > 0.0
+    end
+  end
+
+  describe '#average_potency' do
+    it 'returns 0.0 for empty batch' do
+      expect(batch.average_potency).to eq(0.0)
+    end
+
+    it 'computes average' do
+      s1 = substrate_class.new(substrate_type: :raw_idea, domain: :cognitive, potency: 0.6)
+      s2 = substrate_class.new(substrate_type: :raw_idea, domain: :cognitive, potency: 0.4)
+      batch.add_substrate(s1)
+      batch.add_substrate(s2)
+      expect(batch.average_potency).to eq(0.5)
+    end
+  end
+
+  describe '#yield_rate' do
+    it 'returns 0.0 for empty batch' do
+      expect(batch.yield_rate).to eq(0.0)
+    end
+  end
+
+  describe '#ready_to_harvest?' do
+    it 'returns false when no ripe substrates' do
+      expect(batch).not_to be_ready_to_harvest
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with batch stats' do
+      h = batch.to_h
+      expect(h).to include(:id, :domain, :substrate_count, :average_potency,
+                           :average_maturity, :ripe_count, :yield_rate)
+    end
+  end
+end

data/spec/legion/extensions/cognitive_fermentation/helpers/fermentation_engine_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveFermentation::Helpers::FermentationEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_substrate' do
+    it 'creates and returns a substrate' do
+      sub = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      expect(sub).to be_a(Legion::Extensions::CognitiveFermentation::Helpers::Substrate)
+    end
+
+    it 'adds substrate to a batch' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      report = engine.fermentation_report
+      expect(report[:total_batches]).to eq(1)
+    end
+
+    it 'reuses batch for same domain' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      engine.create_substrate(substrate_type: :dormant_association, domain: :cognitive)
+      expect(engine.fermentation_report[:total_batches]).to eq(1)
+    end
+
+    it 'creates separate batches per domain' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      engine.create_substrate(substrate_type: :raw_idea, domain: :emotional)
+      expect(engine.fermentation_report[:total_batches]).to eq(2)
+    end
+  end
+
+  describe '#ferment' do
+    it 'ferments an existing substrate' do
+      sub = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      result = engine.ferment(substrate_id: sub.id)
+      expect(result.maturity).to be > 0.0
+    end
+
+    it 'returns nil for unknown substrate' do
+      expect(engine.ferment(substrate_id: 'nonexistent')).to be_nil
+    end
+  end
+
+  describe '#catalyze' do
+    it 'catalyzes an existing substrate' do
+      sub = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.3)
+      result = engine.catalyze(substrate_id: sub.id, catalyst_type: :analogy)
+      expect(result.potency).to be > 0.3
+    end
+
+    it 'returns nil for unknown substrate' do
+      expect(engine.catalyze(substrate_id: 'x', catalyst_type: :analogy)).to be_nil
+    end
+  end
+
+  describe '#ferment_all!' do
+    it 'advances all substrates' do
+      s1 = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      s2 = engine.create_substrate(substrate_type: :raw_idea, domain: :emotional)
+      engine.ferment_all!
+      expect(s1.maturity).to be > 0.0
+      expect(s2.maturity).to be > 0.0
+    end
+  end
+
+  describe 'query methods' do
+    before do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.5)
+      engine.create_substrate(substrate_type: :dormant_association, domain: :emotional, potency: 0.3)
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.8)
+    end
+
+    it 'filters by domain' do
+      expect(engine.substrates_by_domain(domain: :cognitive).size).to eq(2)
+    end
+
+    it 'filters by type' do
+      expect(engine.substrates_by_type(type: :raw_idea).size).to eq(2)
+    end
+
+    it 'filters by stage' do
+      expect(engine.substrates_by_stage(stage: :inoculation).size).to eq(3)
+    end
+
+    it 'returns raw substrates' do
+      expect(engine.raw_substrates.size).to eq(3)
+    end
+
+    it 'returns most potent' do
+      results = engine.most_potent(limit: 2)
+      expect(results.size).to eq(2)
+      expect(results.first.potency).to be >= results.last.potency
+    end
+  end
+
+  describe 'aggregate metrics' do
+    it 'returns 0.0 overall_potency for empty engine' do
+      expect(engine.overall_potency).to eq(0.0)
+    end
+
+    it 'computes overall_potency' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.6)
+      expect(engine.overall_potency).to be > 0.0
+    end
+
+    it 'computes overall_maturity' do
+      sub = engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      engine.ferment(substrate_id: sub.id)
+      expect(engine.overall_maturity).to be > 0.0
+    end
+
+    it 'computes yield_rate' do
+      expect(engine.yield_rate).to eq(0.0)
+    end
+
+    it 'computes stage_distribution' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive)
+      dist = engine.stage_distribution
+      expect(dist[:inoculation]).to eq(1)
+    end
+  end
+
+  describe '#fermentation_report' do
+    it 'returns comprehensive report' do
+      engine.create_substrate(substrate_type: :raw_idea, domain: :cognitive, potency: 0.5)
+      report = engine.fermentation_report
+      expect(report).to include(:total_substrates, :total_batches, :overall_potency,
+                                :potency_label, :overall_maturity, :maturity_label,
+                                :yield_rate, :stage_distribution, :batches, :most_potent)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      h = engine.to_h
+      expect(h).to include(:total_substrates, :total_batches, :potency, :maturity, :volatility)
+    end
+  end
+end

data/spec/legion/extensions/cognitive_fermentation/helpers/substrate_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveFermentation::Helpers::Substrate do
+  subject(:substrate) do
+    described_class.new(substrate_type: :raw_idea, domain: :cognitive, content: 'test idea')
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(substrate.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores substrate_type as symbol' do
+      expect(substrate.substrate_type).to eq(:raw_idea)
+    end
+
+    it 'stores domain as symbol' do
+      expect(substrate.domain).to eq(:cognitive)
+    end
+
+    it 'stores content' do
+      expect(substrate.content).to eq('test idea')
+    end
+
+    it 'defaults potency' do
+      expect(substrate.potency).to eq(0.3)
+    end
+
+    it 'starts at inoculation stage' do
+      expect(substrate.stage).to eq(:inoculation)
+    end
+
+    it 'starts with zero maturity' do
+      expect(substrate.maturity).to eq(0.0)
+    end
+
+    it 'starts with empty catalysts' do
+      expect(substrate.catalysts_applied).to be_empty
+    end
+
+    it 'clamps potency to valid range' do
+      s = described_class.new(substrate_type: :raw_idea, domain: :cognitive, potency: 1.5)
+      expect(s.potency).to eq(1.0)
+    end
+  end
+
+  describe '#ferment!' do
+    it 'increases maturity' do
+      substrate.ferment!
+      expect(substrate.maturity).to be > 0.0
+    end
+
+    it 'decreases volatility' do
+      initial = substrate.volatility
+      substrate.ferment!
+      expect(substrate.volatility).to be < initial
+    end
+
+    it 'advances stage with enough fermentation' do
+      5.times { substrate.ferment!(0.1) }
+      expect(substrate.stage).not_to eq(:inoculation)
+    end
+
+    it 'reaches peak stage' do
+      18.times { substrate.ferment!(0.05) }
+      expect(substrate.stage).to eq(:peak)
+    end
+
+    it 'reaches over_fermented stage' do
+      25.times { substrate.ferment!(0.05) }
+      expect(substrate.stage).to eq(:over_fermented)
+    end
+  end
+
+  describe '#catalyze!' do
+    it 'boosts potency' do
+      initial = substrate.potency
+      substrate.catalyze!(:analogy)
+      expect(substrate.potency).to be > initial
+    end
+
+    it 'records catalyst type' do
+      substrate.catalyze!(:dream_residue)
+      expect(substrate.catalysts_applied).to include(:dream_residue)
+    end
+
+    it 'slightly increases volatility' do
+      initial = substrate.volatility
+      substrate.catalyze!(:analogy)
+      expect(substrate.volatility).to be > initial
+    end
+  end
+
+  describe '#spoil!' do
+    it 'halves potency' do
+      initial = substrate.potency
+      substrate.spoil!
+      expect(substrate.potency).to be < initial
+    end
+
+    it 'sets stage to over_fermented' do
+      substrate.spoil!
+      expect(substrate.stage).to eq(:over_fermented)
+    end
+  end
+
+  describe 'predicate methods' do
+    it 'reports ripe when potency and maturity are high' do
+      s = described_class.new(substrate_type: :raw_idea, domain: :cognitive, potency: 0.8)
+      10.times { s.ferment!(0.06) }
+      expect(s).to be_ripe
+    end
+
+    it 'reports spoiled when potency is very low' do
+      s = described_class.new(substrate_type: :raw_idea, domain: :cognitive, potency: 0.05)
+      s.spoil!
+      expect(s).to be_spoiled
+    end
+
+    it 'reports raw at inoculation' do
+      expect(substrate).to be_raw
+    end
+
+    it 'reports multi_catalyzed with 3+ catalysts' do
+      substrate.catalyze!(:analogy)
+      substrate.catalyze!(:contrast)
+      substrate.catalyze!(:dream_residue)
+      expect(substrate).to be_multi_catalyzed
+    end
+  end
+
+  describe '#age' do
+    it 'returns age in minutes' do
+      expect(substrate.age).to be >= 0.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with all fields' do
+      h = substrate.to_h
+      expect(h).to include(:id, :substrate_type, :domain, :content, :potency,
+                           :maturity, :volatility, :stage, :ripe, :peak,
+                           :spoiled, :catalysts_applied, :created_at)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/cognitive_fermentation'
+
+module Legion
+  module Extensions
+    module Helpers
+      module Lex; end
+    end
+  end
+
+  module Logging
+    def self.method_missing(_, *) = nil
+    def self.respond_to_missing?(_, _ = false) = true
+  end
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.order = :random
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-fermentation
+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 fermentation — the slow transformation of raw ideas
+  into refined insights through unconscious incubation and catalysis
+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-fermentation.gemspec
+- lib/legion/extensions/cognitive_fermentation.rb
+- lib/legion/extensions/cognitive_fermentation/client.rb
+- lib/legion/extensions/cognitive_fermentation/helpers/batch.rb
+- lib/legion/extensions/cognitive_fermentation/helpers/constants.rb
+- lib/legion/extensions/cognitive_fermentation/helpers/fermentation_engine.rb
+- lib/legion/extensions/cognitive_fermentation/helpers/substrate.rb
+- lib/legion/extensions/cognitive_fermentation/runners/cognitive_fermentation.rb
+- lib/legion/extensions/cognitive_fermentation/version.rb
+- spec/legion/extensions/cognitive_fermentation/client_spec.rb
+- spec/legion/extensions/cognitive_fermentation/helpers/batch_spec.rb
+- spec/legion/extensions/cognitive_fermentation/helpers/fermentation_engine_spec.rb
+- spec/legion/extensions/cognitive_fermentation/helpers/substrate_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-cognitive-fermentation
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-fermentation
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-fermentation
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-fermentation/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-fermentation/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-fermentation/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: Slow unconscious cognitive processing for LegionIO agents
+test_files: []