lex-agentic-attention 0.1.0

data/spec/legion/extensions/agentic/attention/blink/helpers/blink_engine_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Blink::Helpers::BlinkEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#submit_stimulus' do
+    it 'returns a processed Stimulus' do
+      result = engine.submit_stimulus(stimulus_type: :visual, content: 'flash', salience: 0.7)
+      expect(result).to be_a(Legion::Extensions::Agentic::Attention::Blink::Helpers::Stimulus)
+      expect(result.processed).to be true
+    end
+
+    it 'triggers blink for salient stimuli' do
+      engine.submit_stimulus(stimulus_type: :visual, content: 'bright', salience: 0.9)
+      expect(engine.blink_active?).to be true
+    end
+
+    it 'does not trigger blink for low-salience stimuli' do
+      engine.submit_stimulus(stimulus_type: :visual, content: 'dim', salience: 0.2)
+      expect(engine.blink_active?).to be false
+    end
+
+    it 'reduces processing quality during blink' do
+      engine.submit_stimulus(stimulus_type: :visual, content: 'trigger', salience: 0.9)
+      second = engine.submit_stimulus(stimulus_type: :visual, content: 'missed', salience: 0.3)
+      expect(second.processing_quality).to be < 0.6
+    end
+  end
+
+  describe '#blink_active?' do
+    it 'returns false initially' do
+      expect(engine.blink_active?).to be false
+    end
+  end
+
+  describe '#recovery_level' do
+    it 'returns 1.0 when no blink' do
+      expect(engine.recovery_level).to eq(1.0)
+    end
+  end
+
+  describe '#recovery_label' do
+    it 'returns :recovered when not blinking' do
+      expect(engine.recovery_label).to eq(:recovered)
+    end
+  end
+
+  describe '#force_blink!' do
+    it 'activates blink' do
+      result = engine.force_blink!(duration: 5.0)
+      expect(result[:blink_active]).to be true
+      expect(result[:total_blinks]).to eq(1)
+      expect(engine.blink_active?).to be true
+    end
+
+    it 'clamps duration' do
+      result = engine.force_blink!(duration: 0.1)
+      expect(result[:duration]).to be >= 0.5
+    end
+  end
+
+  describe '#force_recover!' do
+    it 'deactivates blink' do
+      engine.force_blink!
+      result = engine.force_recover!
+      expect(result[:blink_active]).to be false
+      expect(engine.blink_active?).to be false
+    end
+  end
+
+  describe '#adjust_blink_duration' do
+    it 'sets new duration' do
+      engine.adjust_blink_duration(duration: 7.0)
+      result = engine.force_blink!
+      expect(result[:duration]).to be <= 10.0
+    end
+  end
+
+  describe '#miss_rate' do
+    it 'returns 0.0 with no stimuli' do
+      expect(engine.miss_rate).to eq(0.0)
+    end
+
+    it 'tracks missed stimuli ratio' do
+      engine.force_blink!
+      5.times { engine.submit_stimulus(stimulus_type: :visual, content: 'x', salience: 0.1) }
+      expect(engine.miss_rate).to be >= 0.0
+    end
+  end
+
+  describe '#recent_stimuli' do
+    it 'returns empty when no stimuli' do
+      expect(engine.recent_stimuli).to be_empty
+    end
+
+    it 'returns most recent stimuli' do
+      3.times { |i| engine.submit_stimulus(stimulus_type: :auditory, content: "s#{i}", salience: 0.3) }
+      expect(engine.recent_stimuli(limit: 2).size).to eq(2)
+    end
+  end
+
+  describe '#missed_stimuli' do
+    it 'returns only missed stimuli' do
+      engine.force_blink!
+      engine.submit_stimulus(stimulus_type: :visual, content: 'dim', salience: 0.1)
+      missed = engine.missed_stimuli
+      expect(missed.all?(&:missed?)).to be true
+    end
+  end
+
+  describe '#stimuli_by_type' do
+    it 'filters by stimulus type' do
+      engine.submit_stimulus(stimulus_type: :visual, content: 'a', salience: 0.3)
+      engine.submit_stimulus(stimulus_type: :auditory, content: 'b', salience: 0.3)
+      result = engine.stimuli_by_type(stimulus_type: :visual)
+      expect(result.size).to eq(1)
+    end
+  end
+
+  describe '#processing_quality_average' do
+    it 'returns 0.0 with no stimuli' do
+      expect(engine.processing_quality_average).to eq(0.0)
+    end
+
+    it 'computes average quality' do
+      3.times { engine.submit_stimulus(stimulus_type: :visual, content: 'x', salience: 0.3) }
+      expect(engine.processing_quality_average).to be > 0.0
+    end
+  end
+
+  describe '#blink_report' do
+    it 'returns comprehensive report' do
+      engine.submit_stimulus(stimulus_type: :visual, content: 'x', salience: 0.3)
+      report = engine.blink_report
+      expect(report).to include(:total_stimuli, :total_blinks, :total_misses,
+                                :miss_rate, :blink_active, :recovery_level,
+                                :recovery_label, :avg_quality, :recent_missed)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns engine stats' do
+      h = engine.to_h
+      expect(h).to include(:total_stimuli, :total_blinks, :miss_rate, :blink_active, :avg_quality)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/blink/helpers/constants_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Blink::Helpers::Constants do
+  let(:klass) { Class.new { include Legion::Extensions::Agentic::Attention::Blink::Helpers::Constants } }
+
+  it 'defines MAX_STIMULI' do
+    expect(klass::MAX_STIMULI).to eq(500)
+  end
+
+  it 'defines DEFAULT_BLINK_DURATION' do
+    expect(klass::DEFAULT_BLINK_DURATION).to eq(3.0)
+  end
+
+  it 'defines PROCESSING_LABELS as frozen hash' do
+    expect(klass::PROCESSING_LABELS).to be_frozen
+    expect(klass::PROCESSING_LABELS.size).to eq(5)
+  end
+
+  it 'defines RECOVERY_LABELS as frozen hash' do
+    expect(klass::RECOVERY_LABELS).to be_frozen
+  end
+
+  it 'defines STIMULUS_TYPES as frozen array' do
+    expect(klass::STIMULUS_TYPES).to be_frozen
+    expect(klass::STIMULUS_TYPES).to include(:visual, :auditory, :threat)
+  end
+end

data/spec/legion/extensions/agentic/attention/blink/helpers/stimulus_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Blink::Helpers::Stimulus do
+  subject(:stimulus) { described_class.new(stimulus_type: :visual, content: 'flash', salience: 0.7) }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(stimulus.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets type and content' do
+      expect(stimulus.stimulus_type).to eq(:visual)
+      expect(stimulus.content).to eq('flash')
+    end
+
+    it 'starts unprocessed' do
+      expect(stimulus.processed).to be false
+      expect(stimulus.processing_quality).to eq(0.0)
+    end
+  end
+
+  describe '#salient?' do
+    it 'returns true when salience >= threshold' do
+      expect(stimulus.salient?).to be true
+    end
+
+    it 'returns false when below threshold' do
+      s = described_class.new(stimulus_type: :visual, content: 'dim', salience: 0.3)
+      expect(s.salient?).to be false
+    end
+  end
+
+  describe '#process!' do
+    it 'marks as processed with quality' do
+      stimulus.process!(quality: 0.8)
+      expect(stimulus.processed).to be true
+      expect(stimulus.processing_quality).to eq(0.8)
+    end
+
+    it 'clamps quality to 0..1' do
+      stimulus.process!(quality: 1.5)
+      expect(stimulus.processing_quality).to eq(1.0)
+    end
+  end
+
+  describe '#processing_label' do
+    it 'returns :blinked when unprocessed' do
+      expect(stimulus.processing_label).to eq(:blinked)
+    end
+
+    it 'returns :fully_available for high quality' do
+      stimulus.process!(quality: 0.9)
+      expect(stimulus.processing_label).to eq(:fully_available)
+    end
+  end
+
+  describe '#missed?' do
+    it 'returns true when processed with very low quality' do
+      stimulus.process!(quality: 0.1)
+      expect(stimulus.missed?).to be true
+    end
+
+    it 'returns false for adequate quality' do
+      stimulus.process!(quality: 0.5)
+      expect(stimulus.missed?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      h = stimulus.to_h
+      expect(h).to include(:id, :stimulus_type, :content, :salience,
+                           :processed, :processing_quality, :processing_label,
+                           :salient, :missed, :arrival_time, :created_at)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/blink/runners/attentional_blink_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Blink::Runners::AttentionalBlink do
+  subject(:runner) do
+    Class.new do
+      include Legion::Extensions::Agentic::Attention::Blink::Runners::AttentionalBlink
+
+      def engine
+        @engine ||= Legion::Extensions::Agentic::Attention::Blink::Helpers::BlinkEngine.new
+      end
+    end.new
+  end
+
+  describe '#submit_stimulus' do
+    it 'returns success with stimulus data' do
+      result = runner.submit_stimulus(stimulus_type: :visual, content: 'flash', salience: 0.7)
+      expect(result[:success]).to be true
+      expect(result[:stimulus_type]).to eq(:visual)
+    end
+  end
+
+  describe '#check_blink_status' do
+    it 'returns blink status' do
+      result = runner.check_blink_status
+      expect(result[:success]).to be true
+      expect(result[:blink_active]).to be false
+    end
+  end
+
+  describe '#force_blink' do
+    it 'activates blink' do
+      result = runner.force_blink(duration: 5.0)
+      expect(result[:success]).to be true
+      expect(result[:blink_active]).to be true
+    end
+  end
+
+  describe '#force_recover' do
+    it 'deactivates blink' do
+      runner.force_blink
+      result = runner.force_recover
+      expect(result[:success]).to be true
+      expect(result[:blink_active]).to be false
+    end
+  end
+
+  describe '#recent_stimuli_report' do
+    it 'returns stimuli list' do
+      runner.submit_stimulus(stimulus_type: :visual, content: 'x')
+      result = runner.recent_stimuli_report(limit: 5)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#missed_stimuli_report' do
+    it 'returns missed stimuli' do
+      result = runner.missed_stimuli_report
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#blink_report' do
+    it 'returns comprehensive report' do
+      result = runner.blink_report
+      expect(result).to include(:total_stimuli, :total_blinks, :miss_rate)
+    end
+  end
+
+  describe '#attentional_blink_stats' do
+    it 'returns engine stats' do
+      result = runner.attentional_blink_stats
+      expect(result).to include(:total_stimuli, :total_blinks, :miss_rate)
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/economy/client_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/economy/client'
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Economy::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:add_demand)
+    expect(client).to respond_to(:allocate_demand)
+    expect(client).to respond_to(:deallocate_demand)
+    expect(client).to respond_to(:recover_budget)
+    expect(client).to respond_to(:prioritized_demands)
+    expect(client).to respond_to(:best_roi_demands)
+    expect(client).to respond_to(:rebalance_budget)
+    expect(client).to respond_to(:attention_status)
+    expect(client).to respond_to(:attention_snapshot)
+  end
+
+  it 'starts with empty demands' do
+    expect(client.attention_status[:demand_count]).to eq(0)
+  end
+
+  it 'maintains isolated state per instance' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.add_demand(label: 'solo', demand_type: :task, priority: 0.5, cost: 0.1)
+    expect(c2.attention_status[:demand_count]).to eq(0)
+  end
+end

data/spec/legion/extensions/agentic/attention/economy/helpers/attention_budget_spec.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/economy/helpers/attention_budget'
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Economy::Helpers::AttentionBudget do
+  subject(:budget) { described_class.new }
+
+  def add_demand(label: 'work', demand_type: :task, priority: 0.5, cost: 0.2, roi: 0.6)
+    budget.create_demand(label: label, demand_type: demand_type, priority: priority, cost: cost, roi: roi)
+  end
+
+  describe '#initialize' do
+    it 'starts with full available budget' do
+      expect(budget.available_budget).to eq(1.0)
+    end
+
+    it 'starts with 0.0 spent' do
+      expect(budget.spent).to eq(0.0)
+    end
+
+    it 'starts with 0.0 recovered' do
+      expect(budget.recovered).to eq(0.0)
+    end
+
+    it 'accepts custom total_budget' do
+      b = described_class.new(total_budget: 2.0)
+      expect(b.total_budget).to eq(2.0)
+    end
+  end
+
+  describe '#create_demand' do
+    it 'returns a Demand object' do
+      demand = add_demand
+      expect(demand).to be_a(Legion::Extensions::Agentic::Attention::Economy::Helpers::Demand)
+    end
+
+    it 'raises ArgumentError for invalid demand_type' do
+      expect { budget.create_demand(label: 'x', demand_type: :invalid, priority: 0.5, cost: 0.1) }
+        .to raise_error(ArgumentError, /demand_type/)
+    end
+
+    it 'raises ArgumentError when max demands reached' do
+      stub_const('Legion::Extensions::Agentic::Attention::Economy::Helpers::Constants::MAX_DEMANDS', 1)
+      add_demand(label: 'first')
+      expect { add_demand(label: 'second') }.to raise_error(ArgumentError, /max demands/)
+    end
+  end
+
+  describe '#allocate' do
+    it 'allocates demand at its cost' do
+      demand = add_demand(cost: 0.3)
+      result = budget.allocate(demand_id: demand.id)
+      expect(result[:allocated]).to be true
+      expect(result[:amount]).to eq(0.3)
+    end
+
+    it 'deducts from budget' do
+      demand = add_demand(cost: 0.3)
+      budget.allocate(demand_id: demand.id)
+      expect(budget.available_budget).to be_within(0.001).of(0.7)
+    end
+
+    it 'allows explicit amount override' do
+      demand = add_demand(cost: 0.3)
+      result = budget.allocate(demand_id: demand.id, amount: 0.1)
+      expect(result[:amount]).to eq(0.1)
+    end
+
+    it 'returns not_found for unknown demand_id' do
+      result = budget.allocate(demand_id: 'nonexistent')
+      expect(result[:allocated]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'returns insufficient_budget when budget exhausted' do
+      add_demand(cost: 0.9).tap { |d| budget.allocate(demand_id: d.id) }
+      demand2 = add_demand(label: 'big', cost: 0.5)
+      result = budget.allocate(demand_id: demand2.id)
+      expect(result[:allocated]).to be false
+      expect(result[:reason]).to eq(:insufficient_budget)
+    end
+  end
+
+  describe '#deallocate' do
+    it 'frees allocated amount' do
+      demand = add_demand(cost: 0.4)
+      budget.allocate(demand_id: demand.id)
+      result = budget.deallocate(demand_id: demand.id)
+      expect(result[:deallocated]).to be true
+      expect(result[:freed]).to be_within(0.001).of(0.4)
+      expect(budget.available_budget).to be_within(0.001).of(1.0)
+    end
+
+    it 'returns not_found for unknown demand_id' do
+      result = budget.deallocate(demand_id: 'unknown')
+      expect(result[:deallocated]).to be false
+    end
+  end
+
+  describe '#recover!' do
+    it 'restores budget by recovery rate' do
+      demand = add_demand(cost: 0.3)
+      budget.allocate(demand_id: demand.id)
+      budget.recover!
+      expect(budget.spent).to be_within(0.001).of(0.25)
+    end
+
+    it 'accepts custom amount' do
+      demand = add_demand(cost: 0.5)
+      budget.allocate(demand_id: demand.id)
+      budget.recover!(amount: 0.2)
+      expect(budget.spent).to be_within(0.001).of(0.3)
+    end
+
+    it 'does not go below 0 spent' do
+      budget.recover!(amount: 0.5)
+      expect(budget.spent).to eq(0.0)
+    end
+
+    it 'accumulates recovered total' do
+      demand = add_demand(cost: 0.3)
+      budget.allocate(demand_id: demand.id)
+      budget.recover!
+      expect(budget.recovered).to be > 0
+    end
+  end
+
+  describe '#utilization' do
+    it 'returns 0.0 when nothing spent' do
+      expect(budget.utilization).to eq(0.0)
+    end
+
+    it 'returns proportion of budget spent' do
+      demand = add_demand(cost: 0.5)
+      budget.allocate(demand_id: demand.id)
+      expect(budget.utilization).to be_within(0.001).of(0.5)
+    end
+  end
+
+  describe '#prioritized_demands' do
+    it 'returns demands sorted by priority descending' do
+      budget.create_demand(label: 'low', demand_type: :task, priority: 0.2, cost: 0.1)
+      budget.create_demand(label: 'high', demand_type: :task, priority: 0.9, cost: 0.1)
+      budget.create_demand(label: 'mid', demand_type: :task, priority: 0.5, cost: 0.1)
+      sorted = budget.prioritized_demands
+      expect(sorted.first.priority).to be >= sorted.last.priority
+    end
+  end
+
+  describe '#best_roi' do
+    it 'returns top demands by efficiency' do
+      budget.create_demand(label: 'poor', demand_type: :task, priority: 0.5, cost: 0.9, roi: 0.1)
+      budget.create_demand(label: 'great', demand_type: :task, priority: 0.5, cost: 0.1, roi: 0.9)
+      best = budget.best_roi(limit: 1)
+      expect(best.first.label).to eq('great')
+    end
+
+    it 'respects limit parameter' do
+      3.times { |i| budget.create_demand(label: "d#{i}", demand_type: :task, priority: 0.5, cost: 0.1, roi: 0.5) }
+      expect(budget.best_roi(limit: 2).size).to eq(2)
+    end
+  end
+
+  describe '#over_budget?' do
+    it 'returns false when within budget' do
+      expect(budget.over_budget?).to be false
+    end
+  end
+
+  describe '#budget_pressure' do
+    it 'equals utilization' do
+      expect(budget.budget_pressure).to eq(budget.utilization)
+    end
+  end
+
+  describe '#rebalance' do
+    it 'returns rebalanced: 0 when not over budget' do
+      result = budget.rebalance
+      expect(result[:rebalanced]).to eq(0)
+    end
+
+    it 'frees lowest-priority demands when over budget' do
+      b = described_class.new(total_budget: 0.5)
+      d1 = b.create_demand(label: 'lo', demand_type: :task, priority: 0.1, cost: 0.3)
+      d2 = b.create_demand(label: 'hi', demand_type: :task, priority: 0.9, cost: 0.3)
+      b.allocate(demand_id: d1.id)
+      b.allocate(demand_id: d2.id)
+      b.instance_variable_set(:@spent, 0.7)
+      result = b.rebalance
+      expect(result[:rebalanced]).to be >= 1
+    end
+  end
+
+  describe '#budget_report' do
+    it 'includes all expected keys' do
+      report = budget.budget_report
+      %i[total_budget spent available utilization recovered over_budget budget_pressure demand_count allocated_count].each do |key|
+        expect(report).to have_key(key)
+      end
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes demands array' do
+      add_demand
+      h = budget.to_h
+      expect(h[:demands]).to be_an(Array)
+      expect(h[:demands].size).to eq(1)
+    end
+  end
+
+  describe '#find_demand' do
+    it 'returns demand by id' do
+      demand = add_demand
+      expect(budget.find_demand(demand.id)).to eq(demand)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(budget.find_demand('nope')).to be_nil
+    end
+  end
+end

data/spec/legion/extensions/agentic/attention/economy/helpers/constants_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/economy/helpers/demand'
+
+RSpec.describe Legion::Extensions::Agentic::Attention::Economy::Helpers::Constants do
+  describe 'MAX_DEMANDS' do
+    it 'is 200' do
+      expect(described_class::MAX_DEMANDS).to eq(200)
+    end
+  end
+
+  describe 'DEFAULT_BUDGET' do
+    it 'is 1.0' do
+      expect(described_class::DEFAULT_BUDGET).to eq(1.0)
+    end
+  end
+
+  describe 'BUDGET_RECOVERY_RATE' do
+    it 'is 0.05' do
+      expect(described_class::BUDGET_RECOVERY_RATE).to eq(0.05)
+    end
+  end
+
+  describe 'MIN_ALLOCATION' do
+    it 'is 0.01' do
+      expect(described_class::MIN_ALLOCATION).to eq(0.01)
+    end
+  end
+
+  describe 'PRIORITY_LABELS via Demand#priority_label' do
+    def demand_with_priority(pri)
+      Legion::Extensions::Agentic::Attention::Economy::Helpers::Demand.new(
+        label: 'x', demand_type: :task, priority: pri, cost: 0.1
+      )
+    end
+
+    it 'labels 0.9 as critical' do
+      expect(demand_with_priority(0.9).priority_label).to eq(:critical)
+    end
+
+    it 'labels 0.7 as high' do
+      expect(demand_with_priority(0.7).priority_label).to eq(:high)
+    end
+
+    it 'labels 0.5 as moderate' do
+      expect(demand_with_priority(0.5).priority_label).to eq(:moderate)
+    end
+
+    it 'labels 0.3 as low' do
+      expect(demand_with_priority(0.3).priority_label).to eq(:low)
+    end
+
+    it 'labels 0.1 as background' do
+      expect(demand_with_priority(0.1).priority_label).to eq(:background)
+    end
+
+    it 'labels boundary 0.8 as critical' do
+      expect(demand_with_priority(0.8).priority_label).to eq(:critical)
+    end
+
+    it 'labels boundary 0.6 as high' do
+      expect(demand_with_priority(0.6).priority_label).to eq(:high)
+    end
+  end
+
+  describe 'EFFICIENCY_LABELS via Demand#efficiency_label' do
+    def demand_with_efficiency(roi, cost)
+      Legion::Extensions::Agentic::Attention::Economy::Helpers::Demand.new(
+        label: 'x', demand_type: :task, priority: 0.5, cost: cost, roi: roi
+      )
+    end
+
+    it 'labels 0.9 efficiency as excellent' do
+      d = demand_with_efficiency(0.9, 1.0)
+      expect(d.efficiency_label).to eq(:excellent)
+    end
+
+    it 'labels 0.7 efficiency as good' do
+      d = demand_with_efficiency(0.7, 1.0)
+      expect(d.efficiency_label).to eq(:good)
+    end
+
+    it 'labels 0.5 efficiency as adequate' do
+      d = demand_with_efficiency(0.5, 1.0)
+      expect(d.efficiency_label).to eq(:adequate)
+    end
+
+    it 'labels 0.3 efficiency as poor' do
+      d = demand_with_efficiency(0.3, 1.0)
+      expect(d.efficiency_label).to eq(:poor)
+    end
+
+    it 'labels 0.1 efficiency as wasted' do
+      d = demand_with_efficiency(0.1, 1.0)
+      expect(d.efficiency_label).to eq(:wasted)
+    end
+  end
+
+  describe 'DEMAND_TYPES' do
+    it 'includes all six types' do
+      expect(described_class::DEMAND_TYPES).to include(:task, :sensory, :social, :emotional, :cognitive, :maintenance)
+    end
+
+    it 'is frozen' do
+      expect(described_class::DEMAND_TYPES).to be_frozen
+    end
+
+    it 'has exactly six types' do
+      expect(described_class::DEMAND_TYPES.size).to eq(6)
+    end
+  end
+end