lex-agentic-learning 0.1.0

data/spec/legion/extensions/agentic/learning/meta_learning/runners/meta_learning_spec.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/meta_learning/client'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::MetaLearning::Runners::MetaLearning do
+  let(:client) { Legion::Extensions::Agentic::Learning::MetaLearning::Client.new }
+
+  let(:domain_result) { client.create_learning_domain(name: 'ruby') }
+  let(:domain_id)     { domain_result[:id] }
+  let(:strategy_result) { client.register_learning_strategy(name: 'flash_cards', strategy_type: :repetition) }
+  let(:strategy_id) { strategy_result[:id] }
+
+  describe '#create_learning_domain' do
+    it 'returns a hash with id and name' do
+      result = client.create_learning_domain(name: 'python')
+      expect(result[:id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:name]).to eq('python')
+    end
+
+    it 'applies custom learning rate' do
+      result = client.create_learning_domain(name: 'go', learning_rate: 0.2)
+      expect(result[:learning_rate]).to be_within(0.0001).of(0.2)
+    end
+
+    it 'accepts related_domains array' do
+      result = client.create_learning_domain(name: 'typescript', related_domains: ['javascript'])
+      expect(result[:related_domains]).to include('javascript')
+    end
+
+    it 'returns error hash on limit reached' do
+      stub_const('Legion::Extensions::Agentic::Learning::MetaLearning::Helpers::Constants::MAX_DOMAINS', 0)
+      result = client.create_learning_domain(name: 'test')
+      expect(result[:error]).to eq(:limit_reached)
+    end
+  end
+
+  describe '#register_learning_strategy' do
+    it 'returns a hash with id and name' do
+      result = client.register_learning_strategy(name: 'analogy', strategy_type: :analogy)
+      expect(result[:id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:name]).to eq('analogy')
+    end
+
+    it 'returns error for invalid strategy_type' do
+      result = client.register_learning_strategy(name: 'bad', strategy_type: :invalid)
+      expect(result[:error]).to eq(:invalid_strategy_type)
+    end
+  end
+
+  describe '#record_learning_episode' do
+    it 'records a success and returns episode hash' do
+      result = client.record_learning_episode(domain_id: domain_id, success: true)
+      expect(result[:success]).to be true
+      expect(result[:domain_name]).to eq('ruby')
+    end
+
+    it 'records a failure' do
+      result = client.record_learning_episode(domain_id: domain_id, success: false)
+      expect(result[:success]).to be false
+    end
+
+    it 'returns error for unknown domain' do
+      result = client.record_learning_episode(domain_id: 'bad', success: true)
+      expect(result[:error]).to eq(:domain_not_found)
+    end
+
+    it 'accepts strategy_id' do
+      sid = strategy_id
+      result = client.record_learning_episode(domain_id: domain_id, strategy_id: sid, success: true)
+      expect(result[:strategy_id]).to eq(sid)
+    end
+  end
+
+  describe '#recommend_learning_strategy' do
+    it 'returns no_data when no strategy history' do
+      result = client.recommend_learning_strategy(domain_id: domain_id)
+      expect(result[:reason]).to eq(:no_data)
+    end
+
+    it 'recommends best strategy after episodes' do
+      sid = strategy_id
+      did = domain_id
+      3.times { client.record_learning_episode(domain_id: did, strategy_id: sid, success: true) }
+      result = client.recommend_learning_strategy(domain_id: did)
+      expect(result[:recommendation]).to eq('flash_cards')
+    end
+
+    it 'returns error for unknown domain' do
+      result = client.recommend_learning_strategy(domain_id: 'bad')
+      expect(result[:error]).to eq(:domain_not_found)
+    end
+  end
+
+  describe '#check_transfer_learning' do
+    it 'returns not eligible when source proficiency is low' do
+      d1 = client.create_learning_domain(name: 'source')
+      d2 = client.create_learning_domain(name: 'target', related_domains: ['source'])
+      result = client.check_transfer_learning(source_domain_id: d1[:id], target_domain_id: d2[:id])
+      expect(result[:eligible]).to be false
+    end
+
+    it 'returns error for unknown domains' do
+      result = client.check_transfer_learning(source_domain_id: 'bad', target_domain_id: 'also-bad')
+      expect(result[:error]).to eq(:domain_not_found)
+    end
+  end
+
+  describe '#apply_transfer_bonus' do
+    it 'returns not applied when not eligible' do
+      d1 = client.create_learning_domain(name: 'src')
+      d2 = client.create_learning_domain(name: 'tgt', related_domains: ['src'])
+      result = client.apply_transfer_bonus(source_domain_id: d1[:id], target_domain_id: d2[:id])
+      expect(result[:applied]).to be false
+    end
+
+    it 'returns error for unknown domains' do
+      result = client.apply_transfer_bonus(source_domain_id: 'x', target_domain_id: 'y')
+      expect(result[:error]).to eq(:domain_not_found)
+    end
+  end
+
+  describe '#learning_domain_ranking' do
+    it 'returns ranking and count' do
+      client.create_learning_domain(name: 'a')
+      client.create_learning_domain(name: 'b')
+      result = client.learning_domain_ranking
+      expect(result[:ranking]).to be_an(Array)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'respects limit parameter' do
+      5.times { |i| client.create_learning_domain(name: "d#{i}") }
+      result = client.learning_domain_ranking(limit: 2)
+      expect(result[:ranking].size).to eq(2)
+    end
+  end
+
+  describe '#learning_strategy_ranking' do
+    it 'returns ranking and count' do
+      client.register_learning_strategy(name: 's1', strategy_type: :repetition)
+      result = client.learning_strategy_ranking
+      expect(result[:ranking]).to be_an(Array)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#learning_curve_report' do
+    it 'returns error for unknown domain' do
+      result = client.learning_curve_report(domain_id: 'bad')
+      expect(result[:error]).to eq(:domain_not_found)
+    end
+
+    it 'returns curve data for valid domain' do
+      did = domain_id
+      2.times { client.record_learning_episode(domain_id: did, success: true) }
+      result = client.learning_curve_report(domain_id: did)
+      expect(result[:domain]).to eq('ruby')
+      expect(result[:curve].size).to eq(2)
+    end
+  end
+
+  describe '#update_meta_learning' do
+    it 'returns adapt, prune, and stats' do
+      result = client.update_meta_learning
+      expect(result).to include(:adapt, :prune, :stats)
+    end
+
+    it 'boosts rate for efficient domains' do
+      did = domain_id
+      5.times { client.record_learning_episode(domain_id: did, success: true) }
+      result = client.update_meta_learning
+      expect(result[:adapt][:count]).to eq(1)
+      expect(result[:adapt][:adapted].first[:direction]).to eq(:boost)
+    end
+  end
+
+  describe '#meta_learning_stats' do
+    it 'returns engine stats hash' do
+      domain_id
+      result = client.meta_learning_stats
+      expect(result).to include(:domain_count, :strategy_count, :episode_count, :overall_efficiency)
+      expect(result[:domain_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/plasticity/helpers/constants_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Plasticity::Helpers::Constants do
+  let(:klass) { Class.new { include Legion::Extensions::Agentic::Learning::Plasticity::Helpers::Constants } }
+
+  describe 'PLASTICITY_LABELS' do
+    it 'is a frozen hash' do
+      expect(klass::PLASTICITY_LABELS).to be_a(Hash).and be_frozen
+    end
+
+    it 'covers the full 0..1 range' do
+      labels = klass::PLASTICITY_LABELS
+      [0.0, 0.3, 0.5, 0.7, 0.9].each do |val|
+        match = labels.find { |range, _| range.cover?(val) }
+        expect(match).not_to be_nil, "no label for #{val}"
+      end
+    end
+  end
+
+  describe 'STRENGTH_LABELS' do
+    it 'is a frozen hash' do
+      expect(klass::STRENGTH_LABELS).to be_a(Hash).and be_frozen
+    end
+  end
+
+  describe 'PATHWAY_TYPES' do
+    it 'is a frozen array of symbols' do
+      expect(klass::PATHWAY_TYPES).to be_a(Array).and be_frozen
+      expect(klass::PATHWAY_TYPES).to all(be_a(Symbol))
+    end
+
+    it 'includes synaptic' do
+      expect(klass::PATHWAY_TYPES).to include(:synaptic)
+    end
+  end
+
+  describe 'numeric constants' do
+    it 'has positive MAX_PATHWAYS' do
+      expect(klass::MAX_PATHWAYS).to be > 0
+    end
+
+    it 'has STRENGTHENING_RATE between 0 and 1' do
+      expect(klass::STRENGTHENING_RATE).to be_between(0.0, 1.0)
+    end
+
+    it 'has CRITICAL_PERIOD_MULTIPLIER > 1' do
+      expect(klass::CRITICAL_PERIOD_MULTIPLIER).to be > 1.0
+    end
+
+    it 'has PRUNING_THRESHOLD between 0 and 1' do
+      expect(klass::PRUNING_THRESHOLD).to be_between(0.0, 1.0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/plasticity/helpers/neural_pathway_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Plasticity::Helpers::NeuralPathway do
+  subject(:pathway) { described_class.new(label: 'test_pathway') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(pathway.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets label' do
+      expect(pathway.label).to eq('test_pathway')
+    end
+
+    it 'defaults to synaptic type' do
+      expect(pathway.pathway_type).to eq(:synaptic)
+    end
+
+    it 'starts with default strength' do
+      expect(pathway.strength).to eq(0.3)
+    end
+
+    it 'starts with default learning rate as plasticity' do
+      default = Legion::Extensions::Agentic::Learning::Plasticity::Helpers::Constants::DEFAULT_LEARNING_RATE
+      expect(pathway.plasticity).to eq(default)
+    end
+
+    it 'starts with 0 activations' do
+      expect(pathway.activation_count).to eq(0)
+    end
+
+    it 'clamps initial strength to 0..1' do
+      high = described_class.new(label: 'h', initial_strength: 5.0)
+      expect(high.strength).to eq(1.0)
+    end
+  end
+
+  describe '#strengthen!' do
+    it 'increases strength' do
+      original = pathway.strength
+      pathway.strengthen!
+      expect(pathway.strength).to be > original
+    end
+
+    it 'increments activation_count' do
+      pathway.strengthen!
+      expect(pathway.activation_count).to eq(1)
+    end
+
+    it 'clamps at 1.0' do
+      p = described_class.new(label: 'strong', initial_strength: 0.99)
+      p.strengthen!(amount: 0.5)
+      expect(p.strength).to eq(1.0)
+    end
+
+    it 'applies critical period multiplier' do
+      p1 = described_class.new(label: 'normal')
+      p2 = described_class.new(label: 'critical')
+      p1.strengthen!(amount: 0.1)
+      p2.strengthen!(amount: 0.1, critical_period: true)
+      expect(p2.strength).to be > p1.strength
+    end
+
+    it 'returns self' do
+      expect(pathway.strengthen!).to eq(pathway)
+    end
+
+    it 'reduces plasticity (maturation)' do
+      original_plasticity = pathway.plasticity
+      pathway.strengthen!
+      expect(pathway.plasticity).to be < original_plasticity
+    end
+  end
+
+  describe '#weaken!' do
+    it 'decreases strength' do
+      original = pathway.strength
+      pathway.weaken!
+      expect(pathway.strength).to be < original
+    end
+
+    it 'clamps at 0.0' do
+      p = described_class.new(label: 'weak', initial_strength: 0.01)
+      p.weaken!(amount: 0.5)
+      expect(p.strength).to eq(0.0)
+    end
+  end
+
+  describe '#prune_candidate?' do
+    it 'is false for moderate strength' do
+      expect(pathway.prune_candidate?).to be false
+    end
+
+    it 'is true for very weak pathways' do
+      p = described_class.new(label: 'tiny', initial_strength: 0.1)
+      expect(p.prune_candidate?).to be true
+    end
+  end
+
+  describe '#rejuvenate!' do
+    it 'increases plasticity' do
+      pathway.strengthen!
+      reduced = pathway.plasticity
+      pathway.rejuvenate!(amount: 0.2)
+      expect(pathway.plasticity).to be > reduced
+    end
+
+    it 'clamps at 1.0' do
+      pathway.rejuvenate!(amount: 5.0)
+      expect(pathway.plasticity).to eq(1.0)
+    end
+  end
+
+  describe '#strength_label' do
+    it 'returns a symbol' do
+      expect(pathway.strength_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#plasticity_label' do
+    it 'returns a symbol' do
+      expect(pathway.plasticity_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = pathway.to_h
+      expect(hash).to include(
+        :id, :label, :pathway_type, :strength, :strength_label,
+        :plasticity, :plasticity_label, :activation_count,
+        :prune_candidate, :created_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/plasticity/helpers/plasticity_engine_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Plasticity::Helpers::PlasticityEngine do
+  subject(:engine) { described_class.new }
+
+  let(:pathway) { engine.create_pathway(label: 'test') }
+
+  describe '#create_pathway' do
+    it 'returns a NeuralPathway' do
+      expect(pathway).to be_a(Legion::Extensions::Agentic::Learning::Plasticity::Helpers::NeuralPathway)
+    end
+
+    it 'stores the pathway' do
+      pathway
+      expect(engine.to_h[:total_pathways]).to eq(1)
+    end
+  end
+
+  describe '#strengthen_pathway' do
+    it 'increases pathway strength' do
+      original = pathway.strength
+      engine.strengthen_pathway(pathway_id: pathway.id)
+      expect(pathway.strength).to be > original
+    end
+
+    it 'returns nil for unknown id' do
+      expect(engine.strengthen_pathway(pathway_id: 'fake')).to be_nil
+    end
+  end
+
+  describe '#weaken_pathway' do
+    it 'decreases pathway strength' do
+      original = pathway.strength
+      engine.weaken_pathway(pathway_id: pathway.id)
+      expect(pathway.strength).to be < original
+    end
+  end
+
+  describe '#rejuvenate_pathway' do
+    it 'increases pathway plasticity' do
+      engine.strengthen_pathway(pathway_id: pathway.id)
+      reduced = pathway.plasticity
+      engine.rejuvenate_pathway(pathway_id: pathway.id, amount: 0.2)
+      expect(pathway.plasticity).to be > reduced
+    end
+  end
+
+  describe '#critical_period' do
+    it 'starts as false' do
+      expect(engine.critical_period?).to be false
+    end
+
+    it 'can be entered and exited' do
+      engine.enter_critical_period!
+      expect(engine.critical_period?).to be true
+      engine.exit_critical_period!
+      expect(engine.critical_period?).to be false
+    end
+
+    it 'amplifies strengthening during critical period' do
+      p1 = engine.create_pathway(label: 'normal')
+      engine.strengthen_pathway(pathway_id: p1.id)
+      normal_strength = p1.strength
+
+      engine.enter_critical_period!
+      p2 = engine.create_pathway(label: 'boosted')
+      engine.strengthen_pathway(pathway_id: p2.id)
+      expect(p2.strength).to be > normal_strength
+    end
+  end
+
+  describe '#prune_weak_pathways!' do
+    it 'removes pathways below threshold' do
+      engine.create_pathway(label: 'weak', initial_strength: 0.05)
+      engine.create_pathway(label: 'strong', initial_strength: 0.8)
+      pruned = engine.prune_weak_pathways!
+      expect(pruned).to eq(1)
+      expect(engine.to_h[:total_pathways]).to eq(1)
+    end
+  end
+
+  describe '#pathways_by_type' do
+    it 'filters by type' do
+      engine.create_pathway(label: 'a', pathway_type: :structural)
+      engine.create_pathway(label: 'b', pathway_type: :synaptic)
+      result = engine.pathways_by_type(pathway_type: :structural)
+      expect(result.size).to eq(1)
+    end
+  end
+
+  describe '#strongest_pathways' do
+    it 'returns pathways sorted by strength descending' do
+      engine.create_pathway(label: 'weak', initial_strength: 0.2)
+      engine.create_pathway(label: 'strong', initial_strength: 0.9)
+      strongest = engine.strongest_pathways(limit: 1)
+      expect(strongest.first.label).to eq('strong')
+    end
+  end
+
+  describe '#weakest_pathways' do
+    it 'returns pathways sorted by strength ascending' do
+      engine.create_pathway(label: 'weak', initial_strength: 0.2)
+      engine.create_pathway(label: 'strong', initial_strength: 0.9)
+      weakest = engine.weakest_pathways(limit: 1)
+      expect(weakest.first.label).to eq('weak')
+    end
+  end
+
+  describe '#average_strength' do
+    it 'returns 0.0 with no pathways' do
+      expect(engine.average_strength).to eq(0.0)
+    end
+
+    it 'computes average across pathways' do
+      engine.create_pathway(label: 'a', initial_strength: 0.2)
+      engine.create_pathway(label: 'b', initial_strength: 0.8)
+      expect(engine.average_strength).to eq(0.5)
+    end
+  end
+
+  describe '#average_plasticity' do
+    it 'returns default with no pathways' do
+      default = Legion::Extensions::Agentic::Learning::Plasticity::Helpers::Constants::DEFAULT_LEARNING_RATE
+      expect(engine.average_plasticity).to eq(default)
+    end
+  end
+
+  describe '#plasticity_report' do
+    it 'includes all report fields' do
+      pathway
+      report = engine.plasticity_report
+      expect(report).to include(
+        :total_pathways, :critical_period, :average_strength,
+        :average_plasticity, :prune_candidates, :strongest
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes summary fields' do
+      hash = engine.to_h
+      expect(hash).to include(
+        :total_pathways, :critical_period, :average_strength,
+        :average_plasticity, :prune_candidates
+      )
+    end
+  end
+
+  describe 'pruning' do
+    it 'prunes weakest pathway when limit reached' do
+      stub_const('Legion::Extensions::Agentic::Learning::Plasticity::Helpers::Constants::MAX_PATHWAYS', 3)
+      eng = described_class.new
+      4.times { |i| eng.create_pathway(label: "p#{i}", initial_strength: (i + 1) * 0.2) }
+      expect(eng.to_h[:total_pathways]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/plasticity/runners/cognitive_plasticity_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Plasticity::Runners::CognitivePlasticity do
+  let(:client) { Legion::Extensions::Agentic::Learning::Plasticity::Client.new }
+
+  describe '#create_pathway' do
+    it 'returns success with pathway hash' do
+      result = client.create_pathway(label: 'test')
+      expect(result[:success]).to be true
+      expect(result[:pathway]).to include(:id, :label, :strength, :plasticity)
+    end
+  end
+
+  describe '#strengthen_pathway' do
+    it 'increases pathway strength' do
+      p = client.create_pathway(label: 'test')
+      pid = p[:pathway][:id]
+      result = client.strengthen_pathway(pathway_id: pid)
+      expect(result[:success]).to be true
+      expect(result[:pathway][:strength]).to be > 0.3
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.strengthen_pathway(pathway_id: 'fake')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#weaken_pathway' do
+    it 'decreases pathway strength' do
+      p = client.create_pathway(label: 'test')
+      pid = p[:pathway][:id]
+      result = client.weaken_pathway(pathway_id: pid)
+      expect(result[:success]).to be true
+      expect(result[:pathway][:strength]).to be < 0.3
+    end
+  end
+
+  describe '#rejuvenate_pathway' do
+    it 'increases pathway plasticity' do
+      p = client.create_pathway(label: 'test')
+      pid = p[:pathway][:id]
+      client.strengthen_pathway(pathway_id: pid)
+      result = client.rejuvenate_pathway(pathway_id: pid, amount: 0.2)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#enter_critical_period / #exit_critical_period' do
+    it 'toggles critical period' do
+      result = client.enter_critical_period
+      expect(result[:critical_period]).to be true
+      result = client.exit_critical_period
+      expect(result[:critical_period]).to be false
+    end
+  end
+
+  describe '#prune_weak_pathways' do
+    it 'returns pruned count' do
+      client.create_pathway(label: 'weak', initial_strength: 0.05)
+      result = client.prune_weak_pathways
+      expect(result[:success]).to be true
+      expect(result[:pruned_count]).to eq(1)
+    end
+  end
+
+  describe '#strongest_pathways' do
+    it 'returns pathways array' do
+      client.create_pathway(label: 'a')
+      result = client.strongest_pathways
+      expect(result[:success]).to be true
+      expect(result[:pathways]).to be_a(Array)
+    end
+  end
+
+  describe '#plasticity_report' do
+    it 'returns a full report' do
+      result = client.plasticity_report
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_pathways, :average_plasticity)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/preference_learning/client_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/preference_learning/client'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::PreferenceLearning::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:register_preference_option)
+    expect(client).to respond_to(:record_preference_comparison)
+    expect(client).to respond_to(:predict_preference_outcome)
+    expect(client).to respond_to(:top_preferences_report)
+    expect(client).to respond_to(:preference_stability_report)
+    expect(client).to respond_to(:update_preference_learning)
+    expect(client).to respond_to(:preference_learning_stats)
+  end
+end

data/spec/legion/extensions/agentic/learning/preference_learning/helpers/constants_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::PreferenceLearning::Helpers::Constants do
+  describe 'PREFERENCE_LABELS' do
+    subject(:labels) { described_class::PREFERENCE_LABELS }
+
+    it 'labels 0.9 as strongly_preferred' do
+      label = labels.find { |range, _| range.cover?(0.9) }&.last
+      expect(label).to eq(:strongly_preferred)
+    end
+
+    it 'labels 0.7 as preferred' do
+      label = labels.find { |range, _| range.cover?(0.7) }&.last
+      expect(label).to eq(:preferred)
+    end
+
+    it 'labels 0.5 as neutral' do
+      label = labels.find { |range, _| range.cover?(0.5) }&.last
+      expect(label).to eq(:neutral)
+    end
+
+    it 'labels 0.3 as disliked' do
+      label = labels.find { |range, _| range.cover?(0.3) }&.last
+      expect(label).to eq(:disliked)
+    end
+
+    it 'labels 0.1 as strongly_disliked' do
+      label = labels.find { |range, _| range.cover?(0.1) }&.last
+      expect(label).to eq(:strongly_disliked)
+    end
+  end
+
+  describe 'numeric constants' do
+    it 'defines MAX_OPTIONS' do
+      expect(described_class::MAX_OPTIONS).to eq(200)
+    end
+
+    it 'defines MAX_COMPARISONS' do
+      expect(described_class::MAX_COMPARISONS).to eq(1000)
+    end
+
+    it 'defines MAX_HISTORY' do
+      expect(described_class::MAX_HISTORY).to eq(500)
+    end
+
+    it 'defines DEFAULT_PREFERENCE as 0.5' do
+      expect(described_class::DEFAULT_PREFERENCE).to eq(0.5)
+    end
+
+    it 'defines PREFERENCE_FLOOR as 0.0' do
+      expect(described_class::PREFERENCE_FLOOR).to eq(0.0)
+    end
+
+    it 'defines PREFERENCE_CEILING as 1.0' do
+      expect(described_class::PREFERENCE_CEILING).to eq(1.0)
+    end
+
+    it 'WIN_BOOST is greater than LOSS_PENALTY inverted' do
+      expect(described_class::WIN_BOOST).to eq(0.08)
+      expect(described_class::LOSS_PENALTY).to eq(0.06)
+    end
+
+    it 'defines DECAY_RATE' do
+      expect(described_class::DECAY_RATE).to eq(0.01)
+    end
+  end
+end