lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/momentum/helpers/momentum_engine_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Momentum::Helpers::MomentumEngine do
+  subject(:engine) { described_class.new }
+
+  let(:idea) { engine.create_idea(content: 'test', idea_type: :belief, domain: :general) }
+
+  describe '#create_idea' do
+    it 'creates and stores an idea' do
+      result = engine.create_idea(content: 'hello', idea_type: :goal, domain: :work)
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::Momentum::Helpers::Idea)
+      expect(result.content).to eq('hello')
+    end
+
+    it 'records history' do
+      engine.create_idea(content: 'x', idea_type: :belief, domain: :d)
+      expect(engine.history.last[:event]).to eq(:created)
+    end
+
+    it 'evicts oldest when at capacity' do
+      max = Legion::Extensions::Agentic::Inference::Momentum::Helpers::Constants::MAX_IDEAS
+      max.times { |idx| engine.create_idea(content: "idea_#{idx}", idea_type: :belief, domain: :d) }
+      engine.create_idea(content: 'overflow', idea_type: :belief, domain: :d)
+      expect(engine.to_h[:total_ideas]).to eq(max)
+    end
+  end
+
+  describe '#reinforce_idea' do
+    it 'reinforces an existing idea' do
+      result = engine.reinforce_idea(idea_id: idea.id)
+      expect(result[:success]).to be true
+      expect(result[:momentum]).to be > 0
+    end
+
+    it 'returns not_found for missing idea' do
+      result = engine.reinforce_idea(idea_id: 'missing')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#challenge_idea' do
+    it 'challenges an existing idea' do
+      idea
+      engine.reinforce_idea(idea_id: idea.id)
+      result = engine.challenge_idea(idea_id: idea.id)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#apply_force' do
+    it 'applies force to an idea' do
+      result = engine.apply_force(idea_id: idea.id, force: 0.2)
+      expect(result[:success]).to be true
+      expect(result[:velocity]).to be > 0
+    end
+
+    it 'returns not_found for missing idea' do
+      result = engine.apply_force(idea_id: 'missing', force: 0.1)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#surging_ideas' do
+    it 'returns ideas with high momentum' do
+      10.times { engine.reinforce_idea(idea_id: idea.id) }
+      expect(engine.surging_ideas).to include(idea)
+    end
+
+    it 'excludes low momentum ideas' do
+      idea
+      expect(engine.surging_ideas).to be_empty
+    end
+  end
+
+  describe '#reversing_ideas' do
+    it 'returns ideas with negative momentum' do
+      5.times { engine.challenge_idea(idea_id: idea.id) }
+      expect(engine.reversing_ideas).to include(idea)
+    end
+  end
+
+  describe '#entrenched_ideas' do
+    it 'returns ideas with high mass' do
+      10.times { engine.reinforce_idea(idea_id: idea.id) }
+      expect(engine.entrenched_ideas).to include(idea)
+    end
+  end
+
+  describe '#ideas_by_type' do
+    it 'filters by idea type' do
+      engine.create_idea(content: 'a', idea_type: :goal, domain: :d)
+      engine.create_idea(content: 'b', idea_type: :belief, domain: :d)
+      expect(engine.ideas_by_type(idea_type: :goal).size).to eq(1)
+    end
+  end
+
+  describe '#ideas_by_domain' do
+    it 'filters by domain' do
+      engine.create_idea(content: 'a', idea_type: :belief, domain: :work)
+      engine.create_idea(content: 'b', idea_type: :belief, domain: :play)
+      expect(engine.ideas_by_domain(domain: :work).size).to eq(1)
+    end
+  end
+
+  describe '#highest_momentum' do
+    it 'returns ideas sorted by momentum desc' do
+      engine.create_idea(content: 'low', idea_type: :belief, domain: :d)
+      high = engine.create_idea(content: 'high', idea_type: :belief, domain: :d)
+      5.times { engine.reinforce_idea(idea_id: high.id) }
+      result = engine.highest_momentum(limit: 2)
+      expect(result.first).to eq(high)
+    end
+  end
+
+  describe '#most_entrenched' do
+    it 'returns ideas sorted by mass desc' do
+      engine.create_idea(content: 'light', idea_type: :belief, domain: :d)
+      heavy = engine.create_idea(content: 'heavy', idea_type: :belief, domain: :d, mass: 0.9)
+      result = engine.most_entrenched(limit: 2)
+      expect(result.first).to eq(heavy)
+    end
+  end
+
+  describe '#apply_friction_all' do
+    it 'reduces velocity on all ideas' do
+      engine.reinforce_idea(idea_id: idea.id)
+      old_velocity = idea.velocity
+      engine.apply_friction_all
+      expect(idea.velocity).to be < old_velocity
+    end
+  end
+
+  describe '#prune_at_rest' do
+    it 'removes at-rest minimal-mass ideas' do
+      engine.create_idea(content: 'light', idea_type: :belief, domain: :d, mass: 0.1)
+      expect(engine.prune_at_rest).to eq(1)
+    end
+
+    it 'does not prune ideas with mass' do
+      idea
+      expect(engine.prune_at_rest).to eq(0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash' do
+      idea
+      stats = engine.to_h
+      expect(stats).to include(:total_ideas, :surging_count, :reversing_count,
+                               :entrenched_count, :avg_momentum, :history_count)
+      expect(stats[:total_ideas]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/momentum/runners/cognitive_momentum_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Momentum::Runners::CognitiveMomentum do
+  let(:client) { Legion::Extensions::Agentic::Inference::Momentum::Helpers::Client.new }
+
+  describe '#create_cognitive_idea' do
+    it 'creates an idea' do
+      result = client.create_cognitive_idea(content: 'test', idea_type: :belief, domain: :work)
+      expect(result[:success]).to be true
+      expect(result[:idea][:content]).to eq('test')
+    end
+  end
+
+  describe '#reinforce_cognitive_idea' do
+    it 'reinforces an idea' do
+      created = client.create_cognitive_idea(content: 'x', idea_type: :goal, domain: :d)
+      result = client.reinforce_cognitive_idea(idea_id: created[:idea][:id])
+      expect(result[:success]).to be true
+      expect(result[:momentum]).to be > 0
+    end
+  end
+
+  describe '#challenge_cognitive_idea' do
+    it 'challenges an idea' do
+      created = client.create_cognitive_idea(content: 'x', idea_type: :goal, domain: :d)
+      client.reinforce_cognitive_idea(idea_id: created[:idea][:id])
+      result = client.challenge_cognitive_idea(idea_id: created[:idea][:id])
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#apply_cognitive_force' do
+    it 'applies force' do
+      created = client.create_cognitive_idea(content: 'x', idea_type: :belief, domain: :d)
+      result = client.apply_cognitive_force(idea_id: created[:idea][:id], force: 0.3)
+      expect(result[:success]).to be true
+      expect(result[:velocity]).to be > 0
+    end
+  end
+
+  describe '#surging_ideas_report' do
+    it 'returns surging ideas' do
+      created = client.create_cognitive_idea(content: 'x', idea_type: :belief, domain: :d)
+      10.times { client.reinforce_cognitive_idea(idea_id: created[:idea][:id]) }
+      result = client.surging_ideas_report
+      expect(result[:success]).to be true
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#reversing_ideas_report' do
+    it 'returns reversing ideas' do
+      result = client.reversing_ideas_report
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#entrenched_ideas_report' do
+    it 'returns entrenched ideas' do
+      result = client.entrenched_ideas_report
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#highest_momentum_ideas' do
+    it 'returns top momentum ideas' do
+      client.create_cognitive_idea(content: 'a', idea_type: :belief, domain: :d)
+      result = client.highest_momentum_ideas(limit: 3)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#ideas_by_domain' do
+    it 'filters by domain' do
+      client.create_cognitive_idea(content: 'a', idea_type: :belief, domain: :work)
+      result = client.ideas_by_domain(domain: :work)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#update_cognitive_momentum' do
+    it 'applies friction and prunes' do
+      result = client.update_cognitive_momentum
+      expect(result[:success]).to be true
+      expect(result).to have_key(:pruned)
+    end
+  end
+
+  describe '#cognitive_momentum_stats' do
+    it 'returns stats' do
+      result = client.cognitive_momentum_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:total_ideas, :surging_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/perceptual_inference/client_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/perceptual_inference/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::PerceptualInference::Client do
+  subject(:client) { described_class.new }
+
+  it 'can be instantiated without arguments' do
+    expect(client).to be_a(described_class)
+  end
+
+  it 'includes the runner module' do
+    expect(client).to respond_to(:register_percept_hypothesis)
+    expect(client).to respond_to(:present_perceptual_evidence)
+    expect(client).to respond_to(:select_percept)
+    expect(client).to respond_to(:check_rivalry)
+    expect(client).to respond_to(:current_percept)
+    expect(client).to respond_to(:adapt_perception)
+    expect(client).to respond_to(:suppress_percept)
+    expect(client).to respond_to(:perceptual_ambiguity)
+    expect(client).to respond_to(:update_perceptual_inference)
+    expect(client).to respond_to(:perceptual_inference_stats)
+  end
+
+  it 'accepts an injected PerceptualField' do
+    custom_field = Legion::Extensions::Agentic::Inference::PerceptualInference::Helpers::PerceptualField.new
+    custom_field.register_hypothesis(content: 'injected', modality: :visual)
+    client_with_field = described_class.new(field: custom_field)
+    stats = client_with_field.perceptual_inference_stats
+    expect(stats[:stats][:hypotheses_total]).to eq(1)
+  end
+
+  it 'maintains isolated state across instances' do
+    c_one = described_class.new
+    c_two = described_class.new
+    c_one.register_percept_hypothesis(content: 'cat', modality: :visual)
+    expect(c_two.perceptual_inference_stats[:stats][:hypotheses_total]).to eq(0)
+  end
+end

data/spec/legion/extensions/agentic/inference/perceptual_inference/helpers/constants_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::PerceptualInference::Helpers do
+  describe 'constants' do
+    it 'defines MAX_HYPOTHESES as 30' do
+      expect(described_class::MAX_HYPOTHESES).to eq(30)
+    end
+
+    it 'defines MAX_EVIDENCE as 100' do
+      expect(described_class::MAX_EVIDENCE).to eq(100)
+    end
+
+    it 'defines MAX_HISTORY as 200' do
+      expect(described_class::MAX_HISTORY).to eq(200)
+    end
+
+    it 'defines DEFAULT_PRIOR as 0.5' do
+      expect(described_class::DEFAULT_PRIOR).to be_within(0.001).of(0.5)
+    end
+
+    it 'defines PRIOR_FLOOR as 0.01' do
+      expect(described_class::PRIOR_FLOOR).to be_within(0.001).of(0.01)
+    end
+
+    it 'defines PRIOR_CEILING as 0.99' do
+      expect(described_class::PRIOR_CEILING).to be_within(0.001).of(0.99)
+    end
+
+    it 'defines SELECTION_THRESHOLD as 0.6' do
+      expect(described_class::SELECTION_THRESHOLD).to be_within(0.001).of(0.6)
+    end
+
+    it 'defines RIVALRY_MARGIN as 0.1' do
+      expect(described_class::RIVALRY_MARGIN).to be_within(0.001).of(0.1)
+    end
+
+    it 'defines EVIDENCE_STRENGTH_FLOOR as 0.05' do
+      expect(described_class::EVIDENCE_STRENGTH_FLOOR).to be_within(0.001).of(0.05)
+    end
+
+    it 'defines ADAPTATION_RATE as 0.1' do
+      expect(described_class::ADAPTATION_RATE).to be_within(0.001).of(0.1)
+    end
+
+    it 'defines DECAY_RATE as 0.01' do
+      expect(described_class::DECAY_RATE).to be_within(0.001).of(0.01)
+    end
+
+    it 'defines 7 MODALITIES' do
+      expect(described_class::MODALITIES.size).to eq(7)
+    end
+
+    it 'includes visual modality' do
+      expect(described_class::MODALITIES).to include(:visual)
+    end
+
+    it 'includes auditory modality' do
+      expect(described_class::MODALITIES).to include(:auditory)
+    end
+
+    it 'includes vestibular modality' do
+      expect(described_class::MODALITIES).to include(:vestibular)
+    end
+
+    it 'freezes MODALITIES' do
+      expect(described_class::MODALITIES).to be_frozen
+    end
+
+    it 'defines 4 HYPOTHESIS_STATES' do
+      expect(described_class::HYPOTHESIS_STATES).to eq(%i[active selected suppressed decayed])
+    end
+
+    it 'defines PERCEPT_LABELS with 5 entries' do
+      expect(described_class::PERCEPT_LABELS.size).to eq(5)
+    end
+
+    it 'labels posterior >= 0.8 as vivid' do
+      label = described_class::PERCEPT_LABELS.find { |range, _| range.cover?(0.9) }&.last
+      expect(label).to eq(:vivid)
+    end
+
+    it 'labels posterior 0.6..0.8 as clear' do
+      label = described_class::PERCEPT_LABELS.find { |range, _| range.cover?(0.7) }&.last
+      expect(label).to eq(:clear)
+    end
+
+    it 'labels posterior 0.4..0.6 as ambiguous' do
+      label = described_class::PERCEPT_LABELS.find { |range, _| range.cover?(0.5) }&.last
+      expect(label).to eq(:ambiguous)
+    end
+
+    it 'labels posterior < 0.2 as subliminal' do
+      label = described_class::PERCEPT_LABELS.find { |range, _| range.cover?(0.1) }&.last
+      expect(label).to eq(:subliminal)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/perceptual_inference/helpers/perceptual_field_spec.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::PerceptualInference::Helpers::PerceptualField do
+  subject(:field) { described_class.new }
+
+  def register_visual(content, prior: 0.5)
+    field.register_hypothesis(content: content, modality: :visual, prior: prior)
+  end
+
+  describe '#initialize' do
+    it 'starts with empty hypotheses' do
+      expect(field.hypotheses).to be_empty
+    end
+
+    it 'starts with empty evidence_log' do
+      expect(field.evidence_log).to be_empty
+    end
+  end
+
+  describe '#register_hypothesis' do
+    it 'returns a PerceptualHypothesis' do
+      h = register_visual('cat')
+      expect(h).to be_a(Legion::Extensions::Agentic::Inference::PerceptualInference::Helpers::PerceptualHypothesis)
+    end
+
+    it 'stores hypothesis in @hypotheses by id' do
+      h = register_visual('cat')
+      expect(field.hypotheses[h.id]).to eq(h)
+    end
+
+    it 'raises ArgumentError for unknown modality' do
+      expect { field.register_hypothesis(content: 'x', modality: :unknown) }.to raise_error(ArgumentError)
+    end
+
+    it 'defaults domain to :general' do
+      h = register_visual('cat')
+      expect(h.domain).to eq(:general)
+    end
+
+    it 'accepts custom domain' do
+      h = field.register_hypothesis(content: 'bark', modality: :auditory, domain: :animals)
+      expect(h.domain).to eq(:animals)
+    end
+
+    it 'stores hypothesis with provided prior' do
+      h = register_visual('dog', prior: 0.8)
+      expect(h.prior).to be_within(0.001).of(0.8)
+    end
+  end
+
+  describe '#present_evidence' do
+    before { register_visual('cat') }
+
+    it 'returns count of hypotheses in modality' do
+      count = field.present_evidence(modality: :visual, content: 'cat', strength: 0.7)
+      expect(count).to eq(1)
+    end
+
+    it 'logs evidence in evidence_log' do
+      field.present_evidence(modality: :visual, content: 'cat', strength: 0.7)
+      expect(field.evidence_log.last[:content]).to eq('cat')
+    end
+
+    it 'raises ArgumentError for unknown modality' do
+      expect { field.present_evidence(modality: :unknown, content: 'x', strength: 0.5) }.to raise_error(ArgumentError)
+    end
+
+    it 'updates hypotheses posteriors' do
+      h = field.hypotheses.values.first
+      field.present_evidence(modality: :visual, content: 'cat', strength: 0.9)
+      expect(h.posterior).to be_between(0.0, 1.0)
+    end
+
+    it 'caps evidence log at MAX_EVIDENCE' do
+      101.times { |i| field.register_hypothesis(content: "h#{i}", modality: :auditory) }
+      101.times { |i| field.present_evidence(modality: :auditory, content: "x#{i}", strength: 0.5) }
+      expect(field.evidence_log.size).to be <= Legion::Extensions::Agentic::Inference::PerceptualInference::Helpers::MAX_EVIDENCE
+    end
+  end
+
+  describe '#select_percept' do
+    it 'returns nil when no hypotheses exist' do
+      expect(field.select_percept(modality: :visual)).to be_nil
+    end
+
+    it 'raises ArgumentError for unknown modality' do
+      expect { field.select_percept(modality: :unknown) }.to raise_error(ArgumentError)
+    end
+
+    it 'selects the highest-posterior hypothesis when above threshold' do
+      h = register_visual('necker', prior: 0.9)
+      field.present_evidence(modality: :visual, content: 'necker', strength: 0.95)
+      winner = field.select_percept(modality: :visual)
+      expect(winner).to eq(h)
+    end
+
+    it 'returns nil when best hypothesis is below SELECTION_THRESHOLD' do
+      register_visual('weak', prior: 0.1)
+      result = field.select_percept(modality: :visual)
+      expect(result).to be_nil
+    end
+
+    it 'suppresses non-winning hypotheses when a winner is found' do
+      register_visual('strong', prior: 0.9)
+      register_visual('weak', prior: 0.1)
+      field.present_evidence(modality: :visual, content: 'strong', strength: 0.95)
+      field.select_percept(modality: :visual)
+      suppressed = field.hypotheses.values.select { |h| h.state == :suppressed }
+      expect(suppressed).not_to be_empty
+    end
+  end
+
+  describe '#rivalry?' do
+    it 'returns false with no hypotheses' do
+      expect(field.rivalry?(modality: :visual)).to be false
+    end
+
+    it 'raises ArgumentError for unknown modality' do
+      expect { field.rivalry?(modality: :bad) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns false with only one hypothesis' do
+      register_visual('cat')
+      expect(field.rivalry?(modality: :visual)).to be false
+    end
+
+    it 'detects rivalry when posteriors are close' do
+      h_one = register_visual('cat', prior: 0.55)
+      h_two = register_visual('dog', prior: 0.55)
+      h_one.instance_variable_set(:@posterior, 0.62)
+      h_two.instance_variable_set(:@posterior, 0.63)
+      expect(field.rivalry?(modality: :visual)).to be true
+    end
+
+    it 'returns false when posteriors are far apart' do
+      h_one = register_visual('cat', prior: 0.9)
+      h_two = register_visual('dog', prior: 0.1)
+      h_one.instance_variable_set(:@posterior, 0.9)
+      h_two.instance_variable_set(:@posterior, 0.2)
+      expect(field.rivalry?(modality: :visual)).to be false
+    end
+  end
+
+  describe '#current_percept' do
+    it 'returns nil when nothing is selected' do
+      register_visual('cat')
+      expect(field.current_percept(modality: :visual)).to be_nil
+    end
+
+    it 'returns the selected hypothesis' do
+      h = register_visual('necker', prior: 0.95)
+      field.present_evidence(modality: :visual, content: 'necker', strength: 0.99)
+      field.select_percept(modality: :visual)
+      expect(field.current_percept(modality: :visual)).to eq(h)
+    end
+
+    it 'raises ArgumentError for unknown modality' do
+      expect { field.current_percept(modality: :invalid) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#hypotheses_for' do
+    it 'returns only hypotheses for the given modality' do
+      register_visual('cat')
+      field.register_hypothesis(content: 'bark', modality: :auditory)
+      visual = field.hypotheses_for(:visual)
+      expect(visual.all? { |h| h.modality == :visual }).to be true
+    end
+
+    it 'returns empty array when no hypotheses for modality' do
+      expect(field.hypotheses_for(:olfactory)).to be_empty
+    end
+  end
+
+  describe '#suppress_hypothesis' do
+    it 'suppresses a hypothesis by id' do
+      h = register_visual('cat')
+      result = field.suppress_hypothesis(hypothesis_id: h.id)
+      expect(result).to be true
+      expect(h.state).to eq(:suppressed)
+    end
+
+    it 'returns false for unknown hypothesis id' do
+      result = field.suppress_hypothesis(hypothesis_id: 'nonexistent-uuid')
+      expect(result).to be false
+    end
+  end
+
+  describe '#adapt_priors' do
+    it 'increases prior of correct hypothesis' do
+      h = register_visual('cat', prior: 0.5)
+      old_prior = h.prior
+      field.adapt_priors(modality: :visual, correct_hypothesis_id: h.id)
+      expect(h.prior).to be > old_prior
+    end
+
+    it 'decreases prior of incorrect hypotheses' do
+      h_correct = register_visual('cat', prior: 0.5)
+      h_wrong   = register_visual('dog', prior: 0.5)
+      old_wrong_prior = h_wrong.prior
+      field.adapt_priors(modality: :visual, correct_hypothesis_id: h_correct.id)
+      expect(h_wrong.prior).to be < old_wrong_prior
+    end
+
+    it 'raises ArgumentError for unknown modality' do
+      expect { field.adapt_priors(modality: :bad, correct_hypothesis_id: 'x') }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#ambiguity_level' do
+    it 'returns 0.0 with no hypotheses' do
+      expect(field.ambiguity_level).to be_within(0.001).of(0.0)
+    end
+
+    it 'returns a value between 0 and 1' do
+      register_visual('cat')
+      expect(field.ambiguity_level).to be_between(0.0, 1.0)
+    end
+
+    it 'is higher when more modalities have rivalry' do
+      h_one = register_visual('cat', prior: 0.55)
+      h_two = register_visual('dog', prior: 0.55)
+      h_one.instance_variable_set(:@posterior, 0.62)
+      h_two.instance_variable_set(:@posterior, 0.63)
+      expect(field.ambiguity_level).to be > 0.0
+    end
+  end
+
+  describe '#decay_all' do
+    it 'calls decay on each hypothesis' do
+      register_visual('cat', prior: 0.9)
+      field.decay_all
+      h = field.hypotheses.values.first
+      expect(h).not_to be_nil
+      expect(h.prior).to be <= 0.9
+    end
+
+    it 'removes decayed hypotheses after suppression' do
+      h = register_visual('ghost', prior: 0.5)
+      h.suppress!
+      30.times { field.decay_all }
+      expect(field.hypotheses[h.id]).to be_nil
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with hypotheses_total' do
+      register_visual('cat')
+      result = field.to_h
+      expect(result[:hypotheses_total]).to eq(1)
+    end
+
+    it 'returns a hash with ambiguity_level' do
+      result = field.to_h
+      expect(result).to have_key(:ambiguity_level)
+    end
+
+    it 'returns a hash with by_modality' do
+      register_visual('cat')
+      result = field.to_h
+      expect(result[:by_modality]).to have_key(:visual)
+    end
+
+    it 'omits empty modalities from by_modality' do
+      register_visual('cat')
+      result = field.to_h
+      expect(result[:by_modality]).not_to have_key(:olfactory)
+    end
+  end
+end