lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/metacognition/runners/metacognition_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Runners::Metacognition do
+  let(:store) { Legion::Extensions::Agentic::Self::Metacognition::Helpers::SnapshotStore.new }
+  let(:client) { Legion::Extensions::Agentic::Self::Metacognition::Client.new(snapshot_store: store) }
+
+  let(:tick_results) do
+    {
+      sensory_processing:         { spotlight_count: 3, total_signals: 8 },
+      emotional_evaluation:       { valence: 0.4, arousal: 0.6 },
+      prediction_engine:          { confidence: 0.85, mode: :functional_mapping },
+      working_memory_integration: { curiosity_intensity: 0.5, open_wonders: 3 },
+      action_selection:           { intentions: [{ drive: :curiosity }, { drive: :epistemic }] },
+      post_tick_reflection:       { cognitive_health: 0.88 }
+    }
+  end
+
+  describe '#introspect' do
+    it 'builds and caches a self-model' do
+      model = client.introspect(tick_results: tick_results)
+      expect(model).to have_key(:identity)
+      expect(model).to have_key(:architecture)
+      expect(model).to have_key(:cognitive)
+      expect(store.size).to eq(1)
+    end
+
+    it 'uses cached model when not stale' do
+      client.introspect(tick_results: tick_results)
+      second = client.introspect(tick_results: {})
+      expect(store.size).to eq(1)
+      expect(second.dig(:cognitive, :health)).to eq(0.88)
+    end
+
+    it 'rebuilds when stale' do
+      old = Legion::Extensions::Agentic::Self::Metacognition::Helpers::SelfModel.build(tick_results: tick_results)
+      old[:assembled_at] = Time.now.utc - 60
+      store.store(old)
+
+      new_results = tick_results.merge(post_tick_reflection: { cognitive_health: 0.95 })
+      model = client.introspect(tick_results: new_results)
+      expect(model.dig(:cognitive, :health)).to eq(0.95)
+      expect(store.size).to eq(2)
+    end
+  end
+
+  describe '#self_narrative' do
+    it 'returns prose description with model' do
+      result = client.self_narrative(tick_results: tick_results)
+      expect(result[:prose]).to be_a(String)
+      expect(result[:prose].length).to be > 20
+      expect(result[:health]).to eq(0.88)
+      expect(result).to have_key(:model)
+    end
+  end
+
+  describe '#explain_subsystem' do
+    it 'returns info about a loaded subsystem' do
+      client.introspect(tick_results: tick_results)
+      result = client.explain_subsystem(subsystem: :metacognition)
+      expect(result[:loaded]).to be true
+      expect(result[:category]).to eq(:introspection)
+    end
+
+    it 'returns info about an unloaded subsystem' do
+      result = client.explain_subsystem(subsystem: :memory)
+      expect(result[:subsystem]).to eq(:memory)
+    end
+  end
+
+  describe '#architecture_overview' do
+    it 'returns identity and capability info' do
+      client.introspect(tick_results: tick_results)
+      result = client.architecture_overview
+      expect(result[:identity][:framework]).to eq('LegionIO')
+      expect(result).to have_key(:capabilities)
+    end
+  end
+
+  describe '#health_trend' do
+    it 'returns trend data' do
+      3.times do |i|
+        model = Legion::Extensions::Agentic::Self::Metacognition::Helpers::SelfModel.build(tick_results: tick_results)
+        model[:cognitive] = { health: 0.8 + (i * 0.05) }
+        model[:assembled_at] = Time.now.utc - (100 - i)
+        store.store(model)
+      end
+
+      result = client.health_trend
+      expect(result).to have_key(:trend)
+      expect(result[:snapshots]).to eq(3)
+    end
+  end
+
+  describe '#architecture_changes' do
+    it 'returns change history' do
+      result = client.architecture_changes
+      expect(result[:changes]).to be_an(Array)
+    end
+  end
+
+  describe '#metacognition_stats' do
+    it 'returns aggregate stats' do
+      client.introspect(tick_results: tick_results)
+      result = client.metacognition_stats
+      expect(result[:snapshots_stored]).to eq(1)
+      expect(result[:loaded_extensions]).to be >= 1
+      expect(result[:cognitive_health]).to eq(0.88)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/metacognition/runners/registry_spec.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Metacognition::Runners::Registry do
+  subject(:runner) { described_class }
+
+  # Reset in-memory store between examples
+  before { runner.instance_variable_set(:@store, nil) }
+
+  let(:base_args) do
+    {
+      name:        'lex-memory',
+      module_name: 'Memory',
+      category:    'memory'
+    }
+  end
+
+  describe '#register_extension' do
+    it 'returns success: true with name and category' do
+      result = runner.register_extension(**base_args)
+      expect(result[:success]).to be true
+      expect(result[:name]).to eq('lex-memory')
+      expect(result[:category]).to eq('memory')
+    end
+
+    it 'stores the extension in-memory' do
+      runner.register_extension(**base_args)
+      status = runner.extension_status(name: 'lex-memory')
+      expect(status[:success]).to be true
+      expect(status[:extension][:module_name]).to eq('Memory')
+    end
+
+    it 'accepts optional description and cognitive_concept' do
+      runner.register_extension(
+        **base_args,
+        description:       'Trace-based episodic memory',
+        cognitive_concept: 'Hebbian learning'
+      )
+      ext = runner.extension_status(name: 'lex-memory')[:extension]
+      expect(ext[:description]).to eq('Trace-based episodic memory')
+      expect(ext[:cognitive_concept]).to eq('Hebbian learning')
+    end
+
+    it 'coerces category to string' do
+      runner.register_extension(**base_args, category: :perception)
+      ext = runner.extension_status(name: 'lex-memory')[:extension]
+      expect(ext[:category]).to eq('perception')
+    end
+
+    it 'defaults category to cognition when not provided' do
+      result = runner.register_extension(name: 'lex-tick', module_name: 'Tick')
+      expect(result[:category]).to eq('cognition')
+    end
+
+    it 'accepts spec_count and spec_pass_count' do
+      runner.register_extension(**base_args, spec_count: 42, spec_pass_count: 40)
+      ext = runner.extension_status(name: 'lex-memory')[:extension]
+      expect(ext[:spec_count]).to eq(42)
+      expect(ext[:spec_pass_count]).to eq(40)
+    end
+
+    it 'accepts build_batch' do
+      runner.register_extension(**base_args, build_batch: 3)
+      ext = runner.extension_status(name: 'lex-memory')[:extension]
+      expect(ext[:build_batch]).to eq(3)
+    end
+
+    it 'ignores extra keyword arguments via **' do
+      expect { runner.register_extension(**base_args, unknown_key: 'ignored') }.not_to raise_error
+    end
+  end
+
+  describe '#deregister_extension' do
+    before { runner.register_extension(**base_args) }
+
+    it 'returns success: true' do
+      result = runner.deregister_extension(name: 'lex-memory')
+      expect(result[:success]).to be true
+      expect(result[:name]).to eq('lex-memory')
+    end
+
+    it 'removes the extension from the store' do
+      runner.deregister_extension(name: 'lex-memory')
+      status = runner.extension_status(name: 'lex-memory')
+      expect(status[:success]).to be false
+      expect(status[:error]).to eq(:not_found)
+    end
+  end
+
+  describe '#list_extensions' do
+    before do
+      runner.register_extension(name: 'lex-memory',    module_name: 'Memory',    category: 'memory')
+      runner.register_extension(name: 'lex-emotion',   module_name: 'Emotion',   category: 'perception')
+      runner.register_extension(name: 'lex-tick',      module_name: 'Tick',      category: 'cognition')
+    end
+
+    it 'returns all extensions with no filter' do
+      result = runner.list_extensions
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(3)
+      expect(result[:extensions].size).to eq(3)
+    end
+
+    it 'filters by category' do
+      result = runner.list_extensions(category: 'memory')
+      expect(result[:count]).to eq(1)
+      expect(result[:extensions].first[:name]).to eq('lex-memory')
+    end
+
+    it 'filters by status' do
+      runner.update_extension(name: 'lex-tick', attrs: { status: 'inactive' })
+      result = runner.list_extensions(status: 'inactive')
+      expect(result[:count]).to eq(1)
+      expect(result[:extensions].first[:name]).to eq('lex-tick')
+    end
+
+    it 'returns empty list when no match' do
+      result = runner.list_extensions(category: 'nonexistent')
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#extension_status' do
+    it 'returns not_found for unknown extension' do
+      result = runner.extension_status(name: 'lex-unknown')
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'returns the extension data for a known extension' do
+      runner.register_extension(**base_args)
+      result = runner.extension_status(name: 'lex-memory')
+      expect(result[:success]).to be true
+      expect(result[:extension][:name]).to eq('lex-memory')
+    end
+  end
+
+  describe '#update_extension' do
+    before { runner.register_extension(**base_args) }
+
+    it 'returns success: true and updated data' do
+      result = runner.update_extension(name: 'lex-memory', attrs: { health_score: 0.6 })
+      expect(result[:success]).to be true
+      expect(result[:extension][:health_score]).to eq(0.6)
+    end
+
+    it 'returns not_found for unknown extension' do
+      result = runner.update_extension(name: 'lex-missing', attrs: { health_score: 0.5 })
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found)
+    end
+
+    it 'updates status' do
+      runner.update_extension(name: 'lex-memory', attrs: { status: 'degraded' })
+      ext = runner.extension_status(name: 'lex-memory')[:extension]
+      expect(ext[:status]).to eq('degraded')
+    end
+  end
+
+  describe '#category_distribution' do
+    before do
+      runner.register_extension(name: 'lex-memory',    module_name: 'Memory',    category: 'memory')
+      runner.register_extension(name: 'lex-emotion',   module_name: 'Emotion',   category: 'perception')
+      runner.register_extension(name: 'lex-tick',      module_name: 'Tick',      category: 'cognition')
+      runner.register_extension(name: 'lex-cortex',    module_name: 'Cortex',    category: 'cognition')
+    end
+
+    it 'returns success: true' do
+      expect(runner.category_distribution[:success]).to be true
+    end
+
+    it 'returns distribution counts' do
+      dist = runner.category_distribution[:distribution]
+      expect(dist['cognition']).to eq(2)
+      expect(dist['memory']).to eq(1)
+      expect(dist['perception']).to eq(1)
+    end
+
+    it 'returns percentage breakdown' do
+      percentages = runner.category_distribution[:percentages]
+      expect(percentages['cognition']).to eq(50.0)
+    end
+
+    it 'returns total count' do
+      expect(runner.category_distribution[:total]).to eq(4)
+    end
+
+    it 'returns zero percentages when store is empty' do
+      runner.instance_variable_set(:@store, nil)
+      result = runner.category_distribution
+      expect(result[:total]).to eq(0)
+      expect(result[:distribution]).to eq({})
+    end
+  end
+
+  describe '#degraded_extensions' do
+    before do
+      runner.register_extension(**base_args)
+      runner.update_extension(name: 'lex-memory', attrs: { health_score: 0.9 })
+      runner.register_extension(name: 'lex-emotion', module_name: 'Emotion', category: 'perception')
+      runner.update_extension(name: 'lex-emotion', attrs: { health_score: 0.2 })
+      runner.register_extension(name: 'lex-tick', module_name: 'Tick', category: 'cognition')
+      runner.update_extension(name: 'lex-tick', attrs: { health_score: 0.05 })
+    end
+
+    it 'returns success: true' do
+      expect(runner.degraded_extensions[:success]).to be true
+    end
+
+    it 'returns extensions below default threshold (0.4)' do
+      result = runner.degraded_extensions
+      expect(result[:count]).to eq(2)
+      result[:extensions].each { |e| expect(e[:health_score]).to be < 0.4 }
+    end
+
+    it 'accepts a custom threshold' do
+      result = runner.degraded_extensions(threshold: 0.1)
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns empty list when all are healthy' do
+      runner.update_extension(name: 'lex-emotion', attrs: { health_score: 0.95 })
+      runner.update_extension(name: 'lex-tick',    attrs: { health_score: 0.85 })
+      result = runner.degraded_extensions
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#seed_from_constants' do
+    let(:mock_capabilities) do
+      {
+        Memory:  :memory,
+        Emotion: :perception,
+        Tick:    :cognition
+      }
+    end
+
+    before do
+      stub_const(
+        'Legion::Extensions::Agentic::Self::Metacognition::Helpers::Constants::EXTENSION_CAPABILITIES',
+        mock_capabilities
+      )
+    end
+
+    it 'returns success: true' do
+      expect(runner.seed_from_constants[:success]).to be true
+    end
+
+    it 'seeds entries for all capabilities' do
+      result = runner.seed_from_constants
+      expect(result[:seeded]).to eq(3)
+      expect(result[:total]).to eq(3)
+    end
+
+    it 'skips already-registered extensions' do
+      runner.register_extension(name: 'lex-memory', module_name: 'Memory', category: 'memory')
+      result = runner.seed_from_constants
+      expect(result[:seeded]).to eq(2)
+    end
+
+    it 'seeds with correct lex name derived from module name' do
+      runner.seed_from_constants
+      expect(runner.extension_status(name: 'lex-memory')[:success]).to be true
+      expect(runner.extension_status(name: 'lex-emotion')[:success]).to be true
+      expect(runner.extension_status(name: 'lex-tick')[:success]).to be true
+    end
+
+    it 'seeds with correct category from capabilities map' do
+      runner.seed_from_constants
+      expect(runner.extension_status(name: 'lex-memory')[:extension][:category]).to eq('memory')
+      expect(runner.extension_status(name: 'lex-emotion')[:extension][:category]).to eq('perception')
+    end
+
+    it 'is idempotent — running twice does not duplicate entries' do
+      runner.seed_from_constants
+      result = runner.seed_from_constants
+      expect(result[:seeded]).to eq(0)
+      expect(runner.list_extensions[:count]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/metacognitive_monitoring/client_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/metacognitive_monitoring/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::MetacognitiveMonitoring::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to record_judgment' do
+    expect(client).to respond_to(:record_judgment)
+  end
+
+  it 'responds to resolve_judgment' do
+    expect(client).to respond_to(:resolve_judgment)
+  end
+
+  it 'responds to feeling_of_knowing' do
+    expect(client).to respond_to(:feeling_of_knowing)
+  end
+
+  it 'responds to judgment_of_learning' do
+    expect(client).to respond_to(:judgment_of_learning)
+  end
+
+  it 'responds to detect_overconfidence' do
+    expect(client).to respond_to(:detect_overconfidence)
+  end
+
+  it 'responds to detect_underconfidence' do
+    expect(client).to respond_to(:detect_underconfidence)
+  end
+
+  it 'responds to calibration_report' do
+    expect(client).to respond_to(:calibration_report)
+  end
+
+  it 'responds to monitoring_report' do
+    expect(client).to respond_to(:monitoring_report)
+  end
+
+  it 'responds to average_effort' do
+    expect(client).to respond_to(:average_effort)
+  end
+
+  it 'responds to calibration_curve' do
+    expect(client).to respond_to(:calibration_curve)
+  end
+
+  it 'accepts injected engine' do
+    engine = Legion::Extensions::Agentic::Self::MetacognitiveMonitoring::Helpers::MonitoringEngine.new
+    c      = described_class.new(engine: engine)
+    c.record_judgment(type: :confidence_rating, domain: :test)
+    expect(engine.judgments.size).to eq(1)
+  end
+
+  it 'creates its own engine when none injected' do
+    c = described_class.new
+    expect { c.record_judgment(type: :feeling_of_knowing, domain: :test) }.not_to raise_error
+  end
+end

data/spec/legion/extensions/agentic/self/metacognitive_monitoring/helpers/calibration_tracker_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::MetacognitiveMonitoring::Helpers::CalibrationTracker do
+  subject(:tracker) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty points' do
+      expect(tracker.points).to be_empty
+    end
+  end
+
+  describe '#add_point' do
+    it 'adds a point' do
+      tracker.add_point(predicted: 0.7, actual: 0.6)
+      expect(tracker.count).to eq(1)
+    end
+
+    it 'returns self for chaining' do
+      result = tracker.add_point(predicted: 0.7, actual: 0.6)
+      expect(result).to eq(tracker)
+    end
+
+    it 'clamps predicted above 1.0' do
+      tracker.add_point(predicted: 1.5, actual: 0.5)
+      expect(tracker.points.first[:predicted]).to eq(1.0)
+    end
+
+    it 'clamps actual below 0.0' do
+      tracker.add_point(predicted: 0.5, actual: -0.1)
+      expect(tracker.points.first[:actual]).to eq(0.0)
+    end
+
+    it 'respects MAX_CALIBRATION_POINTS limit' do
+      Legion::Extensions::Agentic::Self::MetacognitiveMonitoring::Helpers::MAX_CALIBRATION_POINTS.times do
+        tracker.add_point(predicted: 0.5, actual: 0.5)
+      end
+      tracker.add_point(predicted: 0.9, actual: 0.9)
+      expect(tracker.count).to eq(Legion::Extensions::Agentic::Self::MetacognitiveMonitoring::Helpers::MAX_CALIBRATION_POINTS)
+    end
+  end
+
+  describe '#mean_calibration_error' do
+    it 'returns 0.0 when no points' do
+      expect(tracker.mean_calibration_error).to eq(0.0)
+    end
+
+    it 'computes mean of (predicted - actual)' do
+      tracker.add_point(predicted: 0.8, actual: 0.6)
+      tracker.add_point(predicted: 0.6, actual: 0.6)
+      expect(tracker.mean_calibration_error).to eq(0.1)
+    end
+
+    it 'returns negative for underconfidence' do
+      tracker.add_point(predicted: 0.3, actual: 0.8)
+      expect(tracker.mean_calibration_error).to be < 0
+    end
+  end
+
+  describe '#calibration_score' do
+    it 'returns 1.0 for perfect calibration' do
+      tracker.add_point(predicted: 0.7, actual: 0.7)
+      expect(tracker.calibration_score).to eq(1.0)
+    end
+
+    it 'decreases with larger error' do
+      tracker.add_point(predicted: 0.9, actual: 0.1)
+      expect(tracker.calibration_score).to be < 0.5
+    end
+
+    it 'never goes below 0.0' do
+      tracker.add_point(predicted: 1.0, actual: 0.0)
+      expect(tracker.calibration_score).to be >= 0.0
+    end
+  end
+
+  describe '#overconfident?' do
+    it 'returns true when mean error > OVERCONFIDENCE_THRESHOLD' do
+      tracker.add_point(predicted: 0.9, actual: 0.4)
+      expect(tracker.overconfident?).to be true
+    end
+
+    it 'returns false when well calibrated' do
+      tracker.add_point(predicted: 0.7, actual: 0.65)
+      expect(tracker.overconfident?).to be false
+    end
+  end
+
+  describe '#underconfident?' do
+    it 'returns true when mean error < UNDERCONFIDENCE_THRESHOLD' do
+      tracker.add_point(predicted: 0.2, actual: 0.9)
+      expect(tracker.underconfident?).to be true
+    end
+
+    it 'returns false when well calibrated' do
+      tracker.add_point(predicted: 0.7, actual: 0.65)
+      expect(tracker.underconfident?).to be false
+    end
+  end
+
+  describe '#calibration_label' do
+    it 'returns :well_calibrated for high score' do
+      tracker.add_point(predicted: 0.7, actual: 0.7)
+      expect(tracker.calibration_label).to eq(:well_calibrated)
+    end
+
+    it 'returns a symbol label' do
+      tracker.add_point(predicted: 0.8, actual: 0.1)
+      expect(tracker.calibration_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#calibration_curve' do
+    before do
+      10.times { |i| tracker.add_point(predicted: i * 0.1, actual: i * 0.1) }
+    end
+
+    it 'returns an array of bin hashes' do
+      curve = tracker.calibration_curve(bins: 5)
+      expect(curve).to be_an(Array)
+      expect(curve.size).to eq(5)
+    end
+
+    it 'each bin has required keys' do
+      curve = tracker.calibration_curve(bins: 5)
+      curve.each do |bin|
+        expect(bin).to include(:predicted_range, :sample_count, :actual_accuracy)
+      end
+    end
+
+    it 'returns empty array when no points' do
+      empty = described_class.new
+      expect(empty.calibration_curve).to be_empty
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all summary keys' do
+      h = tracker.to_h
+      expect(h).to include(:count, :mean_calibration_error, :calibration_score, :calibration_label,
+                           :overconfident, :underconfident)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/metacognitive_monitoring/helpers/constants_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::MetacognitiveMonitoring::Helpers do
+  describe 'JUDGMENT_TYPES' do
+    subject(:types) { described_class::JUDGMENT_TYPES }
+
+    it 'includes feeling_of_knowing' do
+      expect(types).to include(:feeling_of_knowing)
+    end
+
+    it 'includes judgment_of_learning' do
+      expect(types).to include(:judgment_of_learning)
+    end
+
+    it 'includes confidence_rating' do
+      expect(types).to include(:confidence_rating)
+    end
+
+    it 'includes effort_estimate' do
+      expect(types).to include(:effort_estimate)
+    end
+
+    it 'includes error_detection' do
+      expect(types).to include(:error_detection)
+    end
+
+    it 'is frozen' do
+      expect(types).to be_frozen
+    end
+  end
+
+  describe 'CALIBRATION_LABELS' do
+    subject(:labels) { described_class::CALIBRATION_LABELS }
+
+    it 'maps high score to :well_calibrated' do
+      label = labels.find { |range, _| range.cover? 0.9 }&.last
+      expect(label).to eq(:well_calibrated)
+    end
+
+    it 'maps low score to :uncalibrated' do
+      label = labels.find { |range, _| range.cover? 0.1 }&.last
+      expect(label).to eq(:uncalibrated)
+    end
+  end
+
+  describe 'CONFIDENCE_LABELS' do
+    subject(:labels) { described_class::CONFIDENCE_LABELS }
+
+    it 'maps 0.9 to :very_high' do
+      label = labels.find { |range, _| range.cover? 0.9 }&.last
+      expect(label).to eq(:very_high)
+    end
+
+    it 'maps 0.1 to :very_low' do
+      label = labels.find { |range, _| range.cover? 0.1 }&.last
+      expect(label).to eq(:very_low)
+    end
+  end
+
+  describe 'EFFORT_LABELS' do
+    subject(:labels) { described_class::EFFORT_LABELS }
+
+    it 'maps 0.9 to :extreme' do
+      label = labels.find { |range, _| range.cover? 0.9 }&.last
+      expect(label).to eq(:extreme)
+    end
+
+    it 'maps 0.1 to :minimal' do
+      label = labels.find { |range, _| range.cover? 0.1 }&.last
+      expect(label).to eq(:minimal)
+    end
+  end
+
+  describe 'thresholds' do
+    it 'OVERCONFIDENCE_THRESHOLD is 0.2' do
+      expect(described_class::OVERCONFIDENCE_THRESHOLD).to eq(0.2)
+    end
+
+    it 'UNDERCONFIDENCE_THRESHOLD is -0.2' do
+      expect(described_class::UNDERCONFIDENCE_THRESHOLD).to eq(-0.2)
+    end
+
+    it 'DEFAULT_CONFIDENCE is 0.5' do
+      expect(described_class::DEFAULT_CONFIDENCE).to eq(0.5)
+    end
+
+    it 'CALIBRATION_WINDOW is 50' do
+      expect(described_class::CALIBRATION_WINDOW).to eq(50)
+    end
+  end
+end