lex-cognitive-tide 0.1.1

data/spec/legion/extensions/cognitive_tide/helpers/tide_engine_spec.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveTide::Helpers::TideEngine do
+  let(:engine) { described_class.new }
+
+  def add_primary(eng = engine, amplitude: 1.0)
+    eng.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: amplitude)
+  end
+
+  def add_secondary(eng = engine, amplitude: 0.5)
+    eng.add_oscillator(oscillator_type: :secondary, period: 43_200, amplitude: amplitude)
+  end
+
+  describe '#initialize' do
+    it 'starts with no oscillators' do
+      expect(engine.oscillators).to be_empty
+    end
+
+    it 'starts with no pools' do
+      expect(engine.pools).to be_empty
+    end
+  end
+
+  describe '#add_oscillator' do
+    it 'returns an Oscillator instance' do
+      osc = add_primary
+      expect(osc).to be_a(Legion::Extensions::CognitiveTide::Helpers::Oscillator)
+    end
+
+    it 'appends to oscillators' do
+      add_primary
+      expect(engine.oscillators.size).to eq(1)
+    end
+
+    it 'allows multiple oscillators' do
+      add_primary
+      add_secondary
+      expect(engine.oscillators.size).to eq(2)
+    end
+
+    it 'raises ArgumentError for unknown oscillator_type' do
+      expect { engine.add_oscillator(oscillator_type: :invalid, period: 3600) }
+        .to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#composite_tide_level' do
+    it 'returns 0.0 with no oscillators' do
+      expect(engine.composite_tide_level).to eq(0.0)
+    end
+
+    it 'returns a value in [0, 1]' do
+      add_primary
+      add_secondary
+      level = engine.composite_tide_level
+      expect(level).to be >= 0.0
+      expect(level).to be <= 1.0
+    end
+
+    it 'is deterministic for the same time' do
+      t = Time.utc(2026, 1, 1, 12, 0, 0)
+      allow(Time).to receive(:now).and_return(t)
+      add_primary
+      expect(engine.composite_tide_level).to eq(engine.composite_tide_level)
+    end
+
+    it 'returns 0.0 when all amplitudes are 0' do
+      engine.add_oscillator(oscillator_type: :primary, period: 3600, amplitude: 0.0)
+      expect(engine.composite_tide_level).to eq(0.0)
+    end
+
+    it 'respects amplitude weighting with a single oscillator' do
+      eng = described_class.new
+      eng.add_oscillator(oscillator_type: :primary, period: 3600, amplitude: 1.0, phase_offset: 0.0)
+      level = eng.composite_tide_level
+      expect(level).to be >= 0.0
+      expect(level).to be <= 1.0
+    end
+  end
+
+  describe '#current_phase' do
+    it 'returns one of the four tide phases' do
+      add_primary
+      expect(Legion::Extensions::CognitiveTide::Helpers::Constants::TIDE_PHASES)
+        .to include(engine.current_phase)
+    end
+
+    it 'returns :high_tide when level >= 0.65' do
+      # Force high level: sin at peak with phase_offset = PI/2, at t=0
+      t = Time.utc(2026, 1, 1)
+      allow(Time).to receive(:now).and_return(t)
+      # phase_offset = PI/2 means sin = 1.0 at t=0
+      engine.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0,
+                            phase_offset: Math::PI / 2.0)
+      expect(engine.current_phase).to eq(:high_tide)
+    end
+
+    it 'returns :low_tide when level <= 0.35' do
+      t = Time.utc(2026, 1, 1)
+      allow(Time).to receive(:now).and_return(t)
+      # phase_offset = -PI/2 means sin = -1.0 at t=0 → value_at = 0.0
+      engine.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0,
+                            phase_offset: -Math::PI / 2.0)
+      expect(engine.current_phase).to eq(:low_tide)
+    end
+  end
+
+  describe '#create_pool' do
+    it 'creates a pool for a domain' do
+      pool = engine.create_pool(domain: 'philosophy')
+      expect(pool).to be_a(Legion::Extensions::CognitiveTide::Helpers::TidalPool)
+      expect(pool.domain).to eq('philosophy')
+    end
+
+    it 'appends to pools' do
+      engine.create_pool(domain: 'philosophy')
+      expect(engine.pools.size).to eq(1)
+    end
+
+    it 'returns existing pool if domain already exists' do
+      p1 = engine.create_pool(domain: 'ideas')
+      p2 = engine.create_pool(domain: 'ideas')
+      expect(p1.id).to eq(p2.id)
+      expect(engine.pools.size).to eq(1)
+    end
+
+    it 'returns nil when MAX_POOLS is reached' do
+      max = Legion::Extensions::CognitiveTide::Helpers::Constants::MAX_POOLS
+      max.times { |i| engine.create_pool(domain: "domain_#{i}") }
+      result = engine.create_pool(domain: 'overflow')
+      expect(result).to be_nil
+    end
+
+    it 'does not add a pool when at capacity' do
+      max = Legion::Extensions::CognitiveTide::Helpers::Constants::MAX_POOLS
+      max.times { |i| engine.create_pool(domain: "domain_#{i}") }
+      engine.create_pool(domain: 'overflow')
+      expect(engine.pools.size).to eq(max)
+    end
+  end
+
+  describe '#deposit_to_pool' do
+    it 'deposits an item into a new domain pool' do
+      result = engine.deposit_to_pool(domain: 'ideas', item: 'refactor this')
+      expect(result).to be(true)
+    end
+
+    it 'auto-creates the pool if not present' do
+      engine.deposit_to_pool(domain: 'fresh_domain', item: 'test idea')
+      expect(engine.pools.size).to eq(1)
+    end
+
+    it 'deposits into existing pool for domain' do
+      engine.deposit_to_pool(domain: 'ideas', item: 'idea 1')
+      engine.deposit_to_pool(domain: 'ideas', item: 'idea 2')
+      pool = engine.pools.first
+      expect(pool.size).to eq(2)
+    end
+
+    it 'returns false when MAX_POOLS is reached and domain is new' do
+      max = Legion::Extensions::CognitiveTide::Helpers::Constants::MAX_POOLS
+      max.times { |i| engine.create_pool(domain: "domain_#{i}") }
+      result = engine.deposit_to_pool(domain: 'overflow', item: 'idea')
+      expect(result).to be(false)
+    end
+  end
+
+  describe '#harvest_pools' do
+    before do
+      add_primary
+      engine.deposit_to_pool(domain: 'ideas', item: 'alpha')
+      engine.deposit_to_pool(domain: 'ideas', item: 'beta')
+    end
+
+    it 'returns empty hash when tide is not rising' do
+      # Make the engine report non-rising phase
+      allow(engine).to receive(:rising?).and_return(false)
+      expect(engine.harvest_pools).to eq({})
+    end
+
+    it 'returns harvested items by domain when rising' do
+      allow(engine).to receive(:rising?).and_return(true)
+      result = engine.harvest_pools
+      expect(result).to have_key('ideas')
+      expect(result['ideas'].size).to eq(2)
+    end
+
+    it 'clears pools after harvest' do
+      allow(engine).to receive(:rising?).and_return(true)
+      engine.harvest_pools
+      expect(engine.pools.first.size).to eq(0)
+    end
+
+    it 'respects min_depth threshold' do
+      allow(engine).to receive(:rising?).and_return(true)
+      # Pool has 2 items with capacity 20 → depth = 0.1; skip pools below 0.5
+      result = engine.harvest_pools(min_depth: 0.5)
+      expect(result).not_to have_key('ideas')
+    end
+
+    it 'skips empty pools' do
+      allow(engine).to receive(:rising?).and_return(true)
+      engine.create_pool(domain: 'empty_pool')
+      result = engine.harvest_pools
+      expect(result).not_to have_key('empty_pool')
+    end
+  end
+
+  describe '#evaporate_all!' do
+    it 'returns total items removed across all pools' do
+      20.times { |i| engine.deposit_to_pool(domain: 'ideas', item: "idea #{i}") }
+      removed = engine.evaporate_all!(0.1)
+      expect(removed).to be > 0
+    end
+
+    it 'evaporates all pools' do
+      engine.deposit_to_pool(domain: 'alpha', item: 'idea a')
+      engine.deposit_to_pool(domain: 'beta', item: 'idea b')
+      removed = engine.evaporate_all!(1.0)
+      expect(removed).to eq(2)
+    end
+
+    it 'returns 0 when no pools' do
+      expect(engine.evaporate_all!).to eq(0)
+    end
+  end
+
+  describe '#tide_forecast' do
+    it 'returns empty array with no oscillators' do
+      expect(engine.tide_forecast(3600)).to eq([])
+    end
+
+    it 'returns forecast entries for duration' do
+      add_primary
+      forecast = engine.tide_forecast(3600)
+      expect(forecast).not_to be_empty
+    end
+
+    it 'each entry has time, level, and label' do
+      add_primary
+      entry = engine.tide_forecast(3600).first
+      expect(entry[:time]).to be_a(Time)
+      expect(entry[:level]).to be_between(0.0, 1.0)
+      expect(entry[:label]).to be_a(String)
+    end
+
+    it 'number of steps is ceil(duration / FORECAST_RESOLUTION)' do
+      resolution = Legion::Extensions::CognitiveTide::Helpers::Constants::FORECAST_RESOLUTION
+      add_primary
+      steps = engine.tide_forecast(resolution * 4).size
+      expect(steps).to eq(4)
+    end
+  end
+
+  describe '#high_tide?' do
+    it 'returns true when level >= 0.65' do
+      t = Time.utc(2026, 1, 1)
+      allow(Time).to receive(:now).and_return(t)
+      engine.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0,
+                            phase_offset: Math::PI / 2.0)
+      expect(engine.high_tide?).to be(true)
+    end
+
+    it 'returns false when level < 0.65' do
+      t = Time.utc(2026, 1, 1)
+      allow(Time).to receive(:now).and_return(t)
+      engine.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0,
+                            phase_offset: -Math::PI / 2.0)
+      expect(engine.high_tide?).to be(false)
+    end
+  end
+
+  describe '#low_tide?' do
+    it 'returns true when level <= 0.35' do
+      t = Time.utc(2026, 1, 1)
+      allow(Time).to receive(:now).and_return(t)
+      engine.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0,
+                            phase_offset: -Math::PI / 2.0)
+      expect(engine.low_tide?).to be(true)
+    end
+
+    it 'returns false when level > 0.35' do
+      t = Time.utc(2026, 1, 1)
+      allow(Time).to receive(:now).and_return(t)
+      engine.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0,
+                            phase_offset: Math::PI / 2.0)
+      expect(engine.low_tide?).to be(false)
+    end
+  end
+
+  describe '#tide_report' do
+    it 'returns a hash with expected keys' do
+      add_primary
+      report = engine.tide_report
+      expect(report.keys).to include(:level, :phase, :label, :oscillator_count, :pool_count,
+                                     :high_tide, :low_tide, :pools, :oscillators)
+    end
+
+    it 'oscillator_count matches registered oscillators' do
+      add_primary
+      add_secondary
+      expect(engine.tide_report[:oscillator_count]).to eq(2)
+    end
+
+    it 'pool_count matches created pools' do
+      engine.create_pool(domain: 'alpha')
+      engine.create_pool(domain: 'beta')
+      expect(engine.tide_report[:pool_count]).to eq(2)
+    end
+
+    it 'pools is an array of pool hashes' do
+      engine.create_pool(domain: 'phi')
+      pools = engine.tide_report[:pools]
+      expect(pools).to be_an(Array)
+      expect(pools.first).to be_a(Hash)
+    end
+
+    it 'oscillators is an array of oscillator hashes' do
+      add_primary
+      osc_list = engine.tide_report[:oscillators]
+      expect(osc_list).to be_an(Array)
+      expect(osc_list.first).to be_a(Hash)
+    end
+  end
+end

data/spec/legion/extensions/cognitive_tide/runners/cognitive_tide_spec.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::CognitiveTide::Runners::CognitiveTide do
+  let(:engine) { Legion::Extensions::CognitiveTide::Helpers::TideEngine.new }
+
+  # Use extend self — call module methods directly
+  subject(:runner) { described_class }
+
+  describe '.add_oscillator' do
+    it 'returns success: true with oscillator hash' do
+      result = runner.add_oscillator(oscillator_type: :primary, period: 86_400, engine: engine)
+      expect(result[:success]).to be(true)
+      expect(result[:oscillator]).to be_a(Hash)
+    end
+
+    it 'adds the oscillator to the engine' do
+      runner.add_oscillator(oscillator_type: :primary, period: 3600, engine: engine)
+      expect(engine.oscillators.size).to eq(1)
+    end
+
+    it 'accepts all oscillator_types' do
+      %i[primary secondary lunar].each do |type|
+        result = runner.add_oscillator(oscillator_type: type, period: 3600, engine: engine)
+        expect(result[:success]).to be(true)
+      end
+    end
+
+    it 'returns success: false for unknown oscillator_type' do
+      result = runner.add_oscillator(oscillator_type: :invalid, period: 3600, engine: engine)
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to be_a(String)
+    end
+
+    it 'returns success: false for non-positive period' do
+      result = runner.add_oscillator(oscillator_type: :primary, period: 0, engine: engine)
+      expect(result[:success]).to be(false)
+    end
+
+    it 'accepts amplitude and phase_offset kwargs' do
+      result = runner.add_oscillator(oscillator_type: :secondary, period: 43_200,
+                                     amplitude: 0.5, phase_offset: 1.5, engine: engine)
+      expect(result[:success]).to be(true)
+      expect(result[:oscillator][:amplitude]).to eq(0.5)
+    end
+
+    it 'accepts extra kwargs via ** splat without error' do
+      result = runner.add_oscillator(oscillator_type: :primary, period: 3600,
+                                     extra_key: 'ignored', engine: engine)
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '.check_tide' do
+    before { runner.add_oscillator(oscillator_type: :primary, period: 86_400, engine: engine) }
+
+    it 'returns success: true' do
+      expect(runner.check_tide(engine: engine)[:success]).to be(true)
+    end
+
+    it 'returns level in [0, 1]' do
+      level = runner.check_tide(engine: engine)[:level]
+      expect(level).to be >= 0.0
+      expect(level).to be <= 1.0
+    end
+
+    it 'returns a valid phase symbol' do
+      phase = runner.check_tide(engine: engine)[:phase]
+      expect(Legion::Extensions::CognitiveTide::Helpers::Constants::TIDE_PHASES).to include(phase)
+    end
+
+    it 'returns a string label' do
+      expect(runner.check_tide(engine: engine)[:label]).to be_a(String)
+    end
+
+    it 'works with no oscillators (returns 0.0 level)' do
+      empty_engine = Legion::Extensions::CognitiveTide::Helpers::TideEngine.new
+      result = runner.check_tide(engine: empty_engine)
+      expect(result[:success]).to be(true)
+      expect(result[:level]).to eq(0.0)
+    end
+  end
+
+  describe '.deposit_idea' do
+    it 'deposits an idea and returns success: true' do
+      result = runner.deposit_idea(domain: 'philosophy', idea: 'consciousness is emergent',
+                                   engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns domain in response' do
+      result = runner.deposit_idea(domain: 'test', idea: 'x', engine: engine)
+      expect(result[:domain]).to eq('test')
+    end
+
+    it 'skips deposit when tide is above threshold' do
+      t = Time.utc(2026, 1, 1)
+      allow(Time).to receive(:now).and_return(t)
+      engine.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0,
+                            phase_offset: Math::PI / 2.0)
+      result = runner.deposit_idea(domain: 'ideas', idea: 'blocked', tide_threshold: 0.1, engine: engine)
+      expect(result[:success]).to be(false)
+      expect(result[:reason]).to eq(:tide_too_high)
+    end
+
+    it 'deposits when tide is below threshold' do
+      t = Time.utc(2026, 1, 1)
+      allow(Time).to receive(:now).and_return(t)
+      engine.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0,
+                            phase_offset: -Math::PI / 2.0)
+      result = runner.deposit_idea(domain: 'ideas', idea: 'allowed', tide_threshold: 0.5, engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'skips threshold check when tide_threshold is nil' do
+      result = runner.deposit_idea(domain: 'ideas', idea: 'any tide', tide_threshold: nil, engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'accepts ** splat kwargs' do
+      result = runner.deposit_idea(domain: 'ideas', idea: 'test', extra: 'ignored', engine: engine)
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '.harvest' do
+    before do
+      engine.add_oscillator(oscillator_type: :primary, period: 86_400, amplitude: 1.0)
+      runner.deposit_idea(domain: 'ideas', idea: 'harvest me', engine: engine)
+    end
+
+    it 'returns success: true' do
+      result = runner.harvest(engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns harvested hash and total_items count' do
+      allow(engine).to receive(:rising?).and_return(true)
+      result = runner.harvest(engine: engine)
+      expect(result[:harvested]).to be_a(Hash)
+      expect(result[:total_items]).to be_a(Integer)
+    end
+
+    it 'returns total_items: 0 when not rising' do
+      allow(engine).to receive(:rising?).and_return(false)
+      result = runner.harvest(engine: engine)
+      expect(result[:total_items]).to eq(0)
+    end
+
+    it 'accepts min_depth kwarg' do
+      allow(engine).to receive(:rising?).and_return(true)
+      result = runner.harvest(min_depth: 0.99, engine: engine)
+      expect(result[:success]).to be(true)
+      # pool depth is well below 0.99, so nothing harvested
+      expect(result[:total_items]).to eq(0)
+    end
+
+    it 'accepts ** splat kwargs' do
+      result = runner.harvest(extra: 'ignored', engine: engine)
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '.tide_forecast' do
+    before { engine.add_oscillator(oscillator_type: :primary, period: 86_400) }
+
+    it 'returns success: true' do
+      result = runner.tide_forecast(duration: 3600, engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'returns forecast array' do
+      result = runner.tide_forecast(duration: 3600, engine: engine)
+      expect(result[:forecast]).to be_an(Array)
+    end
+
+    it 'returns correct duration in response' do
+      result = runner.tide_forecast(duration: 7200, engine: engine)
+      expect(result[:duration]).to eq(7200)
+    end
+
+    it 'returns empty forecast for engine with no oscillators' do
+      empty_engine = Legion::Extensions::CognitiveTide::Helpers::TideEngine.new
+      result = runner.tide_forecast(duration: 3600, engine: empty_engine)
+      expect(result[:forecast]).to eq([])
+    end
+
+    it 'accepts ** splat kwargs' do
+      result = runner.tide_forecast(duration: 3600, extra: 'ignored', engine: engine)
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '.tide_status' do
+    before { engine.add_oscillator(oscillator_type: :primary, period: 86_400) }
+
+    it 'returns success: true' do
+      expect(runner.tide_status(engine: engine)[:success]).to be(true)
+    end
+
+    it 'includes tide report fields' do
+      result = runner.tide_status(engine: engine)
+      expect(result.keys).to include(:level, :phase, :label, :oscillator_count, :pool_count)
+    end
+
+    it 'returns oscillator_count matching registered oscillators' do
+      expect(runner.tide_status(engine: engine)[:oscillator_count]).to eq(1)
+    end
+
+    it 'accepts ** splat kwargs' do
+      result = runner.tide_status(extra: 'ignored', engine: engine)
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '.tide_maintenance' do
+    before { engine.add_oscillator(oscillator_type: :primary, period: 86_400) }
+
+    it 'returns pools_maintained, current_phase, and tide_level' do
+      result = runner.tide_maintenance(engine: engine)
+      expect(result).to include(:pools_maintained, :current_phase, :tide_level)
+    end
+
+    it 'returns pools_maintained as an integer' do
+      expect(runner.tide_maintenance(engine: engine)[:pools_maintained]).to be_a(Integer)
+    end
+
+    it 'returns a valid phase symbol' do
+      phase = runner.tide_maintenance(engine: engine)[:current_phase]
+      expect(Legion::Extensions::CognitiveTide::Helpers::Constants::TIDE_PHASES).to include(phase)
+    end
+
+    it 'returns tide_level in [0, 1]' do
+      level = runner.tide_maintenance(engine: engine)[:tide_level]
+      expect(level).to be >= 0.0
+      expect(level).to be <= 1.0
+    end
+
+    it 'reflects deposited pools in pools_maintained' do
+      engine.deposit_to_pool(domain: 'ideas', item: 'test idea')
+      result = runner.tide_maintenance(engine: engine)
+      expect(result[:pools_maintained]).to eq(1)
+    end
+
+    it 'accepts ** splat kwargs' do
+      result = runner.tide_maintenance(extra: 'ignored', engine: engine)
+      expect(result).to include(:pools_maintained)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+module Legion
+  module Logging
+    def self.debug(_msg); end
+    def self.info(_msg); end
+    def self.warn(_msg); end
+    def self.error(_msg); end
+  end
+
+  module Extensions
+    module Helpers
+      module Lex; end
+    end
+  end
+end
+
+require 'legion/extensions/cognitive_tide'
+require 'legion/extensions/cognitive_tide/client'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-tide
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+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: Circadian-like cognitive rhythm engine for brain-modeled agentic AI —
+  tidal oscillators, composite tide levels, and tidal pool idea accumulation
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- lex-cognitive-tide.gemspec
+- lib/legion/extensions/cognitive_tide.rb
+- lib/legion/extensions/cognitive_tide/actors/tide_cycle.rb
+- lib/legion/extensions/cognitive_tide/client.rb
+- lib/legion/extensions/cognitive_tide/helpers/constants.rb
+- lib/legion/extensions/cognitive_tide/helpers/oscillator.rb
+- lib/legion/extensions/cognitive_tide/helpers/tidal_pool.rb
+- lib/legion/extensions/cognitive_tide/helpers/tide_engine.rb
+- lib/legion/extensions/cognitive_tide/runners/cognitive_tide.rb
+- lib/legion/extensions/cognitive_tide/version.rb
+- spec/legion/extensions/cognitive_tide/actors/tide_cycle_spec.rb
+- spec/legion/extensions/cognitive_tide/client_spec.rb
+- spec/legion/extensions/cognitive_tide/helpers/constants_spec.rb
+- spec/legion/extensions/cognitive_tide/helpers/oscillator_spec.rb
+- spec/legion/extensions/cognitive_tide/helpers/tidal_pool_spec.rb
+- spec/legion/extensions/cognitive_tide/helpers/tide_engine_spec.rb
+- spec/legion/extensions/cognitive_tide/runners/cognitive_tide_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-cognitive-tide
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-tide
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-tide
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-tide
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-tide
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-tide/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 CognitiveTide
+test_files: []