lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/hypothesis_testing/runners/hypothesis_testing_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/hypothesis_testing/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::HypothesisTesting::Runners::HypothesisTesting do
+  let(:client) { Legion::Extensions::Agentic::Inference::HypothesisTesting::Client.new }
+
+  describe '#propose_hypothesis' do
+    it 'returns a hypothesis_id uuid' do
+      result = client.propose_hypothesis(description: 'water boils at 100C')
+      expect(result[:hypothesis_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns the description' do
+      result = client.propose_hypothesis(description: 'gravity exists')
+      expect(result[:description]).to eq('gravity exists')
+    end
+
+    it 'returns the domain' do
+      result = client.propose_hypothesis(description: 'test', domain: 'physics')
+      expect(result[:domain]).to eq('physics')
+    end
+
+    it 'defaults domain to general' do
+      result = client.propose_hypothesis(description: 'test')
+      expect(result[:domain]).to eq('general')
+    end
+
+    it 'returns status :proposed' do
+      result = client.propose_hypothesis(description: 'test')
+      expect(result[:status]).to eq(:proposed)
+    end
+
+    it 'returns a confidence_label' do
+      result = client.propose_hypothesis(description: 'test', prior: 0.9)
+      expect(result[:confidence_label]).to eq('certain')
+    end
+
+    it 'sets prior and posterior to the given prior' do
+      result = client.propose_hypothesis(description: 'test', prior: 0.7)
+      expect(result[:prior]).to eq(0.7)
+      expect(result[:posterior]).to eq(0.7)
+    end
+  end
+
+  describe '#test_hypothesis' do
+    let(:proposed) { client.propose_hypothesis(description: 'testable') }
+
+    it 'returns tested: true for a known hypothesis' do
+      result = client.test_hypothesis(hypothesis_id: proposed[:hypothesis_id], evidence_strength: 0.5, supporting: true)
+      expect(result[:tested]).to be true
+    end
+
+    it 'returns tested: false for an unknown id' do
+      result = client.test_hypothesis(hypothesis_id: 'missing', evidence_strength: 0.5, supporting: true)
+      expect(result[:tested]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'includes updated posterior' do
+      result = client.test_hypothesis(hypothesis_id: proposed[:hypothesis_id], evidence_strength: 1.0, supporting: true)
+      expect(result[:posterior]).to be > proposed[:posterior]
+    end
+
+    it 'includes updated evidence_count' do
+      result = client.test_hypothesis(hypothesis_id: proposed[:hypothesis_id], evidence_strength: 0.5, supporting: true)
+      expect(result[:evidence_count]).to eq(1)
+    end
+
+    it 'includes status' do
+      result = client.test_hypothesis(hypothesis_id: proposed[:hypothesis_id], evidence_strength: 0.5, supporting: true)
+      expect(result.key?(:status)).to be true
+    end
+
+    it 'returns :confirmed status when posterior crosses threshold' do
+      h = client.propose_hypothesis(description: 'high prior', prior: 0.79)
+      result = client.test_hypothesis(hypothesis_id: h[:hypothesis_id], evidence_strength: 1.0, supporting: true)
+      expect(result[:status]).to eq(:confirmed)
+    end
+  end
+
+  describe '#evaluate_hypothesis' do
+    it 'returns found: false for unknown id' do
+      result = client.evaluate_hypothesis(hypothesis_id: 'ghost')
+      expect(result[:found]).to be false
+    end
+
+    it 'returns found: true for known hypothesis' do
+      h      = client.propose_hypothesis(description: 'evaluatable')
+      result = client.evaluate_hypothesis(hypothesis_id: h[:hypothesis_id])
+      expect(result[:found]).to be true
+    end
+
+    it 'confirms hypothesis when posterior is above threshold' do
+      h = client.propose_hypothesis(description: 'high', prior: 0.9)
+      result = client.evaluate_hypothesis(hypothesis_id: h[:hypothesis_id])
+      expect(result[:status]).to eq(:confirmed)
+    end
+  end
+
+  describe '#competing_hypotheses' do
+    it 'returns hypotheses in the given domain' do
+      client.propose_hypothesis(description: 'h1', domain: 'biology')
+      client.propose_hypothesis(description: 'h2', domain: 'biology')
+      client.propose_hypothesis(description: 'h3', domain: 'chemistry')
+      result = client.competing_hypotheses(domain: 'biology')
+      expect(result[:count]).to eq(2)
+      expect(result[:domain]).to eq('biology')
+    end
+
+    it 'returns empty list for unrepresented domain' do
+      result = client.competing_hypotheses(domain: 'astrology')
+      expect(result[:count]).to eq(0)
+      expect(result[:hypotheses]).to be_empty
+    end
+  end
+
+  describe '#most_confident_hypotheses' do
+    it 'returns hypotheses sorted by descending posterior' do
+      client.propose_hypothesis(description: 'low',  prior: 0.2)
+      client.propose_hypothesis(description: 'high', prior: 0.9)
+      result = client.most_confident_hypotheses(limit: 2)
+      expect(result[:hypotheses].first[:posterior]).to be >= result[:hypotheses].last[:posterior]
+    end
+
+    it 'respects the limit' do
+      5.times { |i| client.propose_hypothesis(description: "h#{i}") }
+      result = client.most_confident_hypotheses(limit: 3)
+      expect(result[:count]).to be <= 3
+    end
+  end
+
+  describe '#hypothesis_report' do
+    it 'includes total, by_status, confirmation_rate, most_confident' do
+      client.propose_hypothesis(description: 'reported')
+      result = client.hypothesis_report
+      expect(result.keys).to include(:total, :by_status, :confirmation_rate, :most_confident)
+    end
+
+    it 'counts total correctly' do
+      3.times { |i| client.propose_hypothesis(description: "h#{i}") }
+      expect(client.hypothesis_report[:total]).to eq(3)
+    end
+  end
+
+  describe '#get_hypothesis' do
+    it 'returns found: false for unknown id' do
+      result = client.get_hypothesis(hypothesis_id: 'nope')
+      expect(result[:found]).to be false
+    end
+
+    it 'returns found: true and hypothesis hash for known id' do
+      h      = client.propose_hypothesis(description: 'gettable')
+      result = client.get_hypothesis(hypothesis_id: h[:hypothesis_id])
+      expect(result[:found]).to be true
+      expect(result[:hypothesis][:id]).to eq(h[:hypothesis_id])
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Intuition::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes the Intuition runner' do
+    expect(client).to respond_to(:intuit_response)
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::Agentic::Inference::Intuition::Helpers::IntuitionEngine.new
+    c = described_class.new(engine: engine)
+    expect(c.intuition_stats[:success]).to be true
+  end
+
+  it 'supports full learn-recognize-reinforce cycle' do
+    cue = { weather: :sunny, wind: :low }
+    created = client.learn_intuitive_pattern(cue: cue, response: :go_outside, strength: 0.6)
+    expect(created[:success]).to be true
+
+    result = client.intuit_response(input_cue: cue)
+    expect(result[:response]).to eq(:go_outside)
+
+    reinforced = client.reinforce_intuition(pattern_id: created[:pattern_id], success: true)
+    expect(reinforced[:strength]).to be > 0.6
+  end
+
+  it 'supports heuristic lifecycle' do
+    created = client.add_intuitive_heuristic(name: 'quick scan', heuristic_type: :recognition)
+    applied = client.apply_intuitive_heuristic(heuristic_id: created[:heuristic_id])
+    expect(applied[:uses]).to eq(1)
+  end
+end

data/spec/legion/extensions/agentic/inference/intuition/helpers/heuristic_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Intuition::Helpers::Heuristic do
+  subject(:heuristic) do
+    described_class.new(
+      id:             :heur_one,
+      name:           'take the best',
+      heuristic_type: :take_the_best,
+      domain:         :decision
+    )
+  end
+
+  describe '#initialize' do
+    it 'sets attributes' do
+      expect(heuristic.name).to eq('take the best')
+      expect(heuristic.heuristic_type).to eq(:take_the_best)
+      expect(heuristic.domain).to eq(:decision)
+      expect(heuristic.uses).to eq(0)
+      expect(heuristic.successes).to eq(0)
+    end
+
+    it 'defaults invalid type to :fast_and_frugal' do
+      h = described_class.new(id: :x, name: 'test', heuristic_type: :bogus)
+      expect(h.heuristic_type).to eq(:fast_and_frugal)
+    end
+  end
+
+  describe '#apply' do
+    it 'increments uses' do
+      heuristic.apply
+      expect(heuristic.uses).to eq(1)
+    end
+  end
+
+  describe '#record_outcome' do
+    it 'increments successes on success' do
+      heuristic.record_outcome(success: true)
+      expect(heuristic.successes).to eq(1)
+    end
+
+    it 'does not increment on failure' do
+      heuristic.record_outcome(success: false)
+      expect(heuristic.successes).to eq(0)
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0.0 with no uses' do
+      expect(heuristic.success_rate).to eq(0.0)
+    end
+
+    it 'calculates correctly' do
+      3.times { heuristic.apply }
+      2.times { heuristic.record_outcome(success: true) }
+      heuristic.record_outcome(success: false)
+      expect(heuristic.success_rate).to be_within(0.01).of(0.67)
+    end
+  end
+
+  describe '#effective?' do
+    it 'returns false with few uses' do
+      expect(heuristic.effective?).to be false
+    end
+
+    it 'returns true with enough successful uses' do
+      4.times do
+        heuristic.apply
+        heuristic.record_outcome(success: true)
+      end
+      expect(heuristic.effective?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      expect(heuristic.to_h).to include(
+        :id, :name, :heuristic_type, :domain,
+        :uses, :successes, :success_rate, :effective
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/intuition/helpers/intuition_engine_spec.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Intuition::Helpers::IntuitionEngine do
+  subject(:eng) { described_class.new }
+
+  let(:cue) { { color: :red, shape: :circle } }
+
+  describe '#learn_pattern' do
+    it 'creates a pattern' do
+      pattern = eng.learn_pattern(cue: cue, response: :stop)
+      expect(pattern).to be_a(Legion::Extensions::Agentic::Inference::Intuition::Helpers::Pattern)
+      expect(eng.patterns.size).to eq(1)
+    end
+
+    it 'enforces MAX_PATTERNS' do
+      200.times { |i| eng.learn_pattern(cue: { n: i }, response: :x) }
+      expect(eng.learn_pattern(cue: { n: :overflow }, response: :x)).to be_nil
+    end
+
+    it 'records event' do
+      eng.learn_pattern(cue: cue, response: :stop)
+      expect(eng.history.size).to eq(1)
+    end
+  end
+
+  describe '#recognize' do
+    it 'finds matching patterns' do
+      eng.learn_pattern(cue: cue, response: :stop, domain: :traffic)
+      matches = eng.recognize(input_cue: { color: :red, shape: :circle })
+      expect(matches.size).to eq(1)
+    end
+
+    it 'filters by domain' do
+      eng.learn_pattern(cue: cue, response: :stop, domain: :traffic)
+      eng.learn_pattern(cue: cue, response: :danger, domain: :safety)
+      matches = eng.recognize(input_cue: cue, domain: :traffic)
+      expect(matches.size).to eq(1)
+    end
+
+    it 'returns empty for no match' do
+      eng.learn_pattern(cue: { x: 1 }, response: :y)
+      matches = eng.recognize(input_cue: { a: 2, b: 3 })
+      expect(matches).to be_empty
+    end
+
+    it 'sorts by match score descending' do
+      eng.learn_pattern(cue: { color: :red }, response: :partial)
+      eng.learn_pattern(cue: { color: :red, shape: :circle }, response: :exact)
+      matches = eng.recognize(input_cue: cue)
+      expect(matches.first[:score]).to be >= matches.last[:score]
+    end
+  end
+
+  describe '#intuit' do
+    it 'returns best matching response' do
+      eng.learn_pattern(cue: cue, response: :stop, strength: 0.8)
+      result = eng.intuit(input_cue: cue)
+      expect(result[:response]).to eq(:stop)
+      expect(result[:confidence]).to eq(0.8)
+      expect(result).to have_key(:mode)
+    end
+
+    it 'returns nil when no match' do
+      result = eng.intuit(input_cue: { unknown: :thing })
+      expect(result).to be_nil
+    end
+
+    it 'returns :compiled_expertise mode for expert patterns' do
+      p = eng.learn_pattern(cue: cue, response: :stop, strength: 0.85)
+      10.times { p.reinforce(success: true) }
+      result = eng.intuit(input_cue: cue)
+      expect(result[:mode]).to eq(:compiled_expertise)
+    end
+  end
+
+  describe '#reinforce_pattern' do
+    it 'reinforces on success' do
+      pattern = eng.learn_pattern(cue: cue, response: :stop)
+      original = pattern.strength
+      eng.reinforce_pattern(pattern_id: pattern.id, success: true)
+      expect(pattern.strength).to be > original
+    end
+
+    it 'returns nil for unknown pattern' do
+      expect(eng.reinforce_pattern(pattern_id: :bogus, success: true)).to be_nil
+    end
+  end
+
+  describe '#add_heuristic' do
+    it 'creates a heuristic' do
+      h = eng.add_heuristic(name: 'recognition', heuristic_type: :recognition)
+      expect(h).to be_a(Legion::Extensions::Agentic::Inference::Intuition::Helpers::Heuristic)
+    end
+
+    it 'enforces MAX_HEURISTICS' do
+      50.times { |i| eng.add_heuristic(name: "h_#{i}", heuristic_type: :recognition) }
+      expect(eng.add_heuristic(name: 'overflow', heuristic_type: :recognition)).to be_nil
+    end
+  end
+
+  describe '#apply_heuristic' do
+    it 'applies and returns hash' do
+      h = eng.add_heuristic(name: 'test', heuristic_type: :satisficing)
+      result = eng.apply_heuristic(heuristic_id: h.id)
+      expect(result[:uses]).to eq(1)
+    end
+
+    it 'returns nil for unknown heuristic' do
+      expect(eng.apply_heuristic(heuristic_id: :bogus)).to be_nil
+    end
+  end
+
+  describe '#reliable_patterns and #expert_patterns' do
+    it 'returns reliable patterns' do
+      p = eng.learn_pattern(cue: cue, response: :stop, strength: 0.7)
+      3.times { p.reinforce(success: true) }
+      expect(eng.reliable_patterns.size).to eq(1)
+    end
+
+    it 'returns expert patterns' do
+      p = eng.learn_pattern(cue: cue, response: :stop, strength: 0.85)
+      10.times { p.reinforce(success: true) }
+      expect(eng.expert_patterns.size).to eq(1)
+    end
+  end
+
+  describe '#effective_heuristics' do
+    it 'returns effective heuristics' do
+      h = eng.add_heuristic(name: 'test', heuristic_type: :recognition)
+      4.times do
+        h.apply
+        h.record_outcome(success: true)
+      end
+      expect(eng.effective_heuristics.size).to eq(1)
+    end
+  end
+
+  describe '#patterns_in' do
+    it 'filters by domain' do
+      eng.learn_pattern(cue: { x: 1 }, response: :a, domain: :traffic)
+      eng.learn_pattern(cue: { y: 2 }, response: :b, domain: :safety)
+      expect(eng.patterns_in(domain: :traffic).size).to eq(1)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all patterns' do
+      p = eng.learn_pattern(cue: cue, response: :stop, strength: 0.8)
+      original = p.strength
+      eng.decay_all
+      expect(p.strength).to be < original
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      expect(eng.to_h).to include(
+        :pattern_count, :heuristic_count, :reliable_pattern_count,
+        :expert_pattern_count, :effective_heuristic_count, :history_size
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/intuition/helpers/pattern_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Intuition::Helpers::Pattern do
+  subject(:pattern) do
+    described_class.new(
+      id:       :pat_one,
+      cue:      { color: :red, shape: :circle },
+      response: :stop,
+      domain:   :traffic
+    )
+  end
+
+  describe '#initialize' do
+    it 'sets attributes' do
+      expect(pattern.cue).to eq({ color: :red, shape: :circle })
+      expect(pattern.response).to eq(:stop)
+      expect(pattern.domain).to eq(:traffic)
+      expect(pattern.encounters).to eq(0)
+      expect(pattern.state).to eq(:developing)
+    end
+
+    it 'clamps strength' do
+      p = described_class.new(id: :x, cue: {}, response: :y, strength: 2.0)
+      expect(p.strength).to eq(0.95)
+    end
+  end
+
+  describe '#match_score' do
+    it 'returns 1.0 for exact match' do
+      score = pattern.match_score({ color: :red, shape: :circle })
+      expect(score).to eq(1.0)
+    end
+
+    it 'returns partial score for partial match' do
+      score = pattern.match_score({ color: :red, shape: :square })
+      expect(score).to eq(0.5)
+    end
+
+    it 'returns 0.0 for no match' do
+      score = pattern.match_score({ color: :blue, shape: :square })
+      expect(score).to eq(0.0)
+    end
+
+    it 'returns 0.0 for non-hash input' do
+      expect(pattern.match_score('not a hash')).to eq(0.0)
+    end
+
+    it 'handles disjoint keys' do
+      score = pattern.match_score({ size: :large, weight: :heavy })
+      expect(score).to eq(0.0)
+    end
+  end
+
+  describe '#recognized?' do
+    it 'returns true for high match' do
+      expect(pattern.recognized?({ color: :red, shape: :circle })).to be true
+    end
+
+    it 'returns false for low match' do
+      expect(pattern.recognized?({ color: :blue, shape: :square })).to be false
+    end
+  end
+
+  describe '#reinforce' do
+    it 'increases strength on success' do
+      original = pattern.strength
+      pattern.reinforce(success: true)
+      expect(pattern.strength).to be > original
+      expect(pattern.encounters).to eq(1)
+      expect(pattern.successes).to eq(1)
+    end
+
+    it 'decreases strength on failure' do
+      original = pattern.strength
+      pattern.reinforce(success: false)
+      expect(pattern.strength).to be < original
+      expect(pattern.encounters).to eq(1)
+      expect(pattern.successes).to eq(0)
+    end
+
+    it 'clamps to ceiling' do
+      p = described_class.new(id: :x, cue: {}, response: :y, strength: 0.92)
+      p.reinforce(success: true)
+      expect(p.strength).to be <= 0.95
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces strength' do
+      original = pattern.strength
+      pattern.decay
+      expect(pattern.strength).to be < original
+    end
+
+    it 'does not go below floor' do
+      p = described_class.new(id: :x, cue: {}, response: :y, strength: 0.06)
+      p.decay
+      expect(p.strength).to be >= 0.05
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0.0 with no encounters' do
+      expect(pattern.success_rate).to eq(0.0)
+    end
+
+    it 'calculates correctly' do
+      pattern.reinforce(success: true)
+      pattern.reinforce(success: false)
+      expect(pattern.success_rate).to eq(0.5)
+    end
+  end
+
+  describe '#reliable? and #expert?' do
+    it 'starts as not reliable' do
+      expect(pattern.reliable?).to be false
+    end
+
+    it 'becomes reliable with enough encounters and strength' do
+      p = described_class.new(id: :x, cue: {}, response: :y, strength: 0.7)
+      3.times { p.reinforce(success: true) }
+      expect(p.reliable?).to be true
+    end
+
+    it 'becomes expert with many encounters and high strength' do
+      p = described_class.new(id: :x, cue: {}, response: :y, strength: 0.85)
+      10.times { p.reinforce(success: true) }
+      expect(p.expert?).to be true
+    end
+  end
+
+  describe '#state transitions' do
+    it 'starts as developing at default strength' do
+      expect(pattern.state).to eq(:developing)
+    end
+
+    it 'transitions through states with reinforcement' do
+      p = described_class.new(id: :x, cue: {}, response: :y, strength: 0.3)
+      expect(p.state).to eq(:nascent)
+      4.times { p.reinforce(success: true) }
+      expect(%i[developing reliable]).to include(p.state)
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns a symbol' do
+      expect(pattern.confidence_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      expect(pattern.to_h).to include(
+        :id, :cue, :response, :domain, :strength,
+        :encounters, :successes, :success_rate, :state,
+        :confidence_label, :reliable, :expert
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/intuition/runners/intuition_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Intuition::Runners::Intuition do
+  let(:host) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  let(:cue) { { color: :red, shape: :circle } }
+
+  describe '#learn_intuitive_pattern' do
+    it 'creates a pattern' do
+      result = host.learn_intuitive_pattern(cue: cue, response: :stop)
+      expect(result[:success]).to be true
+      expect(result[:pattern_id]).to be_a(Symbol)
+    end
+  end
+
+  describe '#intuitive_recognize' do
+    it 'recognizes patterns' do
+      host.learn_intuitive_pattern(cue: cue, response: :stop)
+      result = host.intuitive_recognize(input_cue: cue)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#intuit_response' do
+    it 'returns the intuited response' do
+      host.learn_intuitive_pattern(cue: cue, response: :stop, strength: 0.8)
+      result = host.intuit_response(input_cue: cue)
+      expect(result[:success]).to be true
+      expect(result[:response]).to eq(:stop)
+    end
+
+    it 'returns failure for no match' do
+      result = host.intuit_response(input_cue: { unknown: :thing })
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#reinforce_intuition' do
+    it 'reinforces a pattern' do
+      created = host.learn_intuitive_pattern(cue: cue, response: :stop)
+      result = host.reinforce_intuition(pattern_id: created[:pattern_id], success: true)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown pattern' do
+      result = host.reinforce_intuition(pattern_id: :bogus, success: true)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#add_intuitive_heuristic' do
+    it 'creates a heuristic' do
+      result = host.add_intuitive_heuristic(name: 'test', heuristic_type: :recognition)
+      expect(result[:success]).to be true
+      expect(result[:heuristic_id]).to be_a(Symbol)
+    end
+  end
+
+  describe '#apply_intuitive_heuristic' do
+    it 'applies a heuristic' do
+      created = host.add_intuitive_heuristic(name: 'test', heuristic_type: :satisficing)
+      result = host.apply_intuitive_heuristic(heuristic_id: created[:heuristic_id])
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown heuristic' do
+      result = host.apply_intuitive_heuristic(heuristic_id: :bogus)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#reliable_intuitions' do
+    it 'returns reliable patterns' do
+      result = host.reliable_intuitions
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#expert_intuitions' do
+    it 'returns expert patterns' do
+      result = host.expert_intuitions
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#update_intuition' do
+    it 'decays and returns stats' do
+      result = host.update_intuition
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#intuition_stats' do
+    it 'returns stats' do
+      result = host.intuition_stats
+      expect(result[:success]).to be true
+      expect(result).to have_key(:pattern_count)
+      expect(result).to have_key(:heuristic_count)
+    end
+  end
+end