lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/horizon/runners/cognitive_horizon_spec.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/horizon/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Horizon::Runners::CognitiveHorizon do
+  let(:client) { Legion::Extensions::Agentic::Inference::Horizon::Client.new }
+
+  describe '#get_horizon' do
+    it 'returns found: true' do
+      result = client.get_horizon
+      expect(result[:found]).to be true
+    end
+
+    it 'includes a horizon report' do
+      result = client.get_horizon
+      expect(result[:horizon]).to be_a(Hash)
+    end
+
+    it 'horizon report includes current_horizon' do
+      result = client.get_horizon
+      expect(result[:horizon]).to have_key(:current_horizon)
+    end
+
+    it 'horizon report includes construal_label' do
+      result = client.get_horizon
+      expect(result[:horizon]).to have_key(:construal_label)
+    end
+
+    it 'horizon report includes effective_horizon' do
+      result = client.get_horizon
+      expect(result[:horizon]).to have_key(:effective_horizon)
+    end
+  end
+
+  describe '#expand_horizon' do
+    it 'returns expanded: true' do
+      result = client.expand_horizon
+      expect(result[:expanded]).to be true
+    end
+
+    it 'after is greater than before' do
+      result = client.expand_horizon
+      expect(result[:after]).to be > result[:before]
+    end
+
+    it 'returns the default amount' do
+      result = client.expand_horizon
+      expect(result[:amount]).to eq(Legion::Extensions::Agentic::Inference::Horizon::Helpers::Constants::HORIZON_EXPAND)
+    end
+
+    it 'accepts custom amount' do
+      result = client.expand_horizon(amount: 0.2)
+      expect(result[:amount]).to eq(0.2)
+    end
+
+    it 'does not exceed 1.0' do
+      10.times { client.expand_horizon(amount: 0.2) }
+      result = client.get_horizon
+      expect(result[:horizon][:current_horizon]).to be <= 1.0
+    end
+  end
+
+  describe '#contract_horizon' do
+    it 'returns contracted: true' do
+      result = client.contract_horizon
+      expect(result[:contracted]).to be true
+    end
+
+    it 'after is less than before' do
+      result = client.contract_horizon
+      expect(result[:after]).to be < result[:before]
+    end
+
+    it 'returns the default amount' do
+      result = client.contract_horizon
+      expect(result[:amount]).to eq(Legion::Extensions::Agentic::Inference::Horizon::Helpers::Constants::HORIZON_CONTRACT)
+    end
+
+    it 'does not go below MIN_HORIZON' do
+      10.times { client.contract_horizon(amount: 0.2) }
+      result = client.get_horizon
+      expect(result[:horizon][:current_horizon]).to be >= Legion::Extensions::Agentic::Inference::Horizon::Helpers::Constants::MIN_HORIZON
+    end
+  end
+
+  describe '#apply_stress' do
+    it 'returns stress_applied: true' do
+      result = client.apply_stress(level: 0.5)
+      expect(result[:stress_applied]).to be true
+    end
+
+    it 'records the stress level' do
+      result = client.apply_stress(level: 0.6)
+      expect(result[:stress_level]).to eq(0.6)
+    end
+
+    it 'decreases the horizon' do
+      result = client.apply_stress(level: 0.8)
+      expect(result[:after]).to be <= result[:before]
+    end
+
+    it 'contracts horizon with high stress' do
+      initial = client.get_horizon[:horizon][:current_horizon]
+      client.apply_stress(level: 1.0)
+      final = client.get_horizon[:horizon][:current_horizon]
+      expect(final).to be < initial
+    end
+  end
+
+  describe '#relieve_stress' do
+    before { client.apply_stress(level: 0.8) }
+
+    it 'returns relieved: true' do
+      result = client.relieve_stress
+      expect(result[:relieved]).to be true
+    end
+
+    it 'reduces stress level' do
+      result = client.relieve_stress
+      expect(result[:after]).to be < result[:before]
+    end
+
+    it 'accepts custom amount' do
+      result = client.relieve_stress(amount: 0.3)
+      expect(result[:amount]).to eq(0.3)
+    end
+  end
+
+  describe '#add_projection' do
+    it 'returns a hash with an id' do
+      result = client.add_projection(description: 'Future state')
+      expect(result[:id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'includes description' do
+      result = client.add_projection(description: 'Future state')
+      expect(result[:description]).to eq('Future state')
+    end
+
+    it 'uses default domain :general' do
+      result = client.add_projection(description: 'x')
+      expect(result[:domain]).to eq(:general)
+    end
+
+    it 'accepts custom domain' do
+      result = client.add_projection(description: 'x', domain: :ops)
+      expect(result[:domain]).to eq(:ops)
+    end
+
+    it 'returns horizon_distance' do
+      result = client.add_projection(description: 'x', horizon_distance: 0.7)
+      expect(result[:horizon_distance]).to eq(0.7)
+    end
+
+    it 'returns construal_level' do
+      result = client.add_projection(description: 'x')
+      expect(result[:construal_level]).to be_a(Symbol)
+    end
+  end
+
+  describe '#projections_within_horizon' do
+    before do
+      client.add_projection(description: 'near', horizon_distance: 0.1)
+      client.add_projection(description: 'far', horizon_distance: 0.99)
+    end
+
+    it 'returns count' do
+      result = client.projections_within_horizon
+      expect(result[:count]).to be_a(Integer)
+    end
+
+    it 'returns projections array' do
+      result = client.projections_within_horizon
+      expect(result[:projections]).to be_an(Array)
+    end
+
+    it 'includes effective_horizon' do
+      result = client.projections_within_horizon
+      expect(result[:effective_horizon]).to be_a(Float)
+    end
+
+    it 'all returned projections are within effective_horizon' do
+      result = client.projections_within_horizon
+      result[:projections].each do |p|
+        expect(p[:horizon_distance]).to be <= result[:effective_horizon]
+      end
+    end
+  end
+
+  describe '#beyond_horizon_projections' do
+    before do
+      client.add_projection(description: 'near', horizon_distance: 0.1)
+      client.add_projection(description: 'far', horizon_distance: 0.99)
+    end
+
+    it 'returns count' do
+      result = client.beyond_horizon_projections
+      expect(result[:count]).to be_a(Integer)
+    end
+
+    it 'all returned projections are beyond effective_horizon' do
+      result = client.beyond_horizon_projections
+      eff = result[:effective_horizon]
+      result[:projections].each do |p|
+        expect(p[:horizon_distance]).to be > eff
+      end
+    end
+
+    it 'within + beyond == total' do
+      within_count = client.projections_within_horizon[:count]
+      beyond_count = client.beyond_horizon_projections[:count]
+      total = client.horizon_status[:total_projections]
+      expect(within_count + beyond_count).to eq(total)
+    end
+  end
+
+  describe '#nearest_projections' do
+    before do
+      [0.9, 0.1, 0.5].each { |d| client.add_projection(description: "p#{d}", horizon_distance: d) }
+    end
+
+    it 'returns count' do
+      result = client.nearest_projections(count: 2)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'returns projections sorted nearest first' do
+      result = client.nearest_projections(count: 2)
+      distances = result[:projections].map { |p| p[:horizon_distance] }
+      expect(distances).to eq(distances.sort)
+    end
+
+    it 'defaults to count=5' do
+      5.times { |i| client.add_projection(description: "extra #{i}", horizon_distance: 0.3) }
+      result = client.nearest_projections
+      expect(result[:count]).to be <= 5
+    end
+  end
+
+  describe '#farthest_projections' do
+    before do
+      [0.9, 0.1, 0.5].each { |d| client.add_projection(description: "p#{d}", horizon_distance: d) }
+    end
+
+    it 'returns projections sorted farthest first' do
+      result = client.farthest_projections(count: 2)
+      distances = result[:projections].map { |p| p[:horizon_distance] }
+      expect(distances).to eq(distances.sort.reverse)
+    end
+
+    it 'returns correct count' do
+      result = client.farthest_projections(count: 2)
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#horizon_status' do
+    it 'returns total_projections' do
+      client.add_projection(description: 'test')
+      result = client.horizon_status
+      expect(result[:total_projections]).to eq(1)
+    end
+
+    it 'includes a report hash' do
+      result = client.horizon_status
+      expect(result[:report]).to be_a(Hash)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/constants'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::HypothesisTesting::Helpers::Constants do
+  it 'defines MAX_HYPOTHESES as 300' do
+    expect(described_class::MAX_HYPOTHESES).to eq(300)
+  end
+
+  it 'defines CONFIRMATION_THRESHOLD as 0.8' do
+    expect(described_class::CONFIRMATION_THRESHOLD).to eq(0.8)
+  end
+
+  it 'defines DISCONFIRMATION_THRESHOLD as 0.2' do
+    expect(described_class::DISCONFIRMATION_THRESHOLD).to eq(0.2)
+  end
+
+  it 'defines EVIDENCE_WEIGHT as 0.1' do
+    expect(described_class::EVIDENCE_WEIGHT).to eq(0.1)
+  end
+
+  it 'defines PRIOR_DEFAULT as 0.5' do
+    expect(described_class::PRIOR_DEFAULT).to eq(0.5)
+  end
+
+  it 'defines all five STATUS_LABELS keys' do
+    expect(described_class::STATUS_LABELS.keys).to match_array(%i[proposed testing confirmed disconfirmed inconclusive])
+  end
+
+  it 'defines five CONFIDENCE_LABELS entries' do
+    expect(described_class::CONFIDENCE_LABELS.size).to eq(5)
+  end
+
+  it 'includes certain, confident, leaning, uncertain, agnostic labels' do
+    labels = described_class::CONFIDENCE_LABELS.map { |_, label| label }
+    expect(labels).to match_array(%w[certain confident leaning uncertain agnostic])
+  end
+end

data/spec/legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis_engine_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/constants'
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis'
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis_engine'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::HypothesisTesting::Helpers::HypothesisEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#propose' do
+    it 'returns a Hypothesis object' do
+      h = engine.propose(description: 'test', domain: 'logic')
+      expect(h).to be_a(Legion::Extensions::Agentic::Inference::HypothesisTesting::Helpers::Hypothesis)
+    end
+
+    it 'stores the hypothesis' do
+      h = engine.propose(description: 'stored')
+      expect(engine.hypotheses[h.id]).to eq(h)
+    end
+
+    it 'assigns the given domain' do
+      h = engine.propose(description: 'domain test', domain: 'physics')
+      expect(h.domain).to eq('physics')
+    end
+
+    it 'uses default domain general when not specified' do
+      h = engine.propose(description: 'default domain')
+      expect(h.domain).to eq('general')
+    end
+
+    it 'assigns the given prior' do
+      h = engine.propose(description: 'prior test', prior: 0.3)
+      expect(h.prior).to eq(0.3)
+    end
+
+    it 'evicts oldest when MAX_HYPOTHESES is reached' do
+      max = Legion::Extensions::Agentic::Inference::HypothesisTesting::Helpers::Constants::MAX_HYPOTHESES
+      max.times { |i| engine.propose(description: "h#{i}") }
+      expect(engine.hypotheses.size).to eq(max)
+      oldest_id = engine.hypotheses.values.min_by(&:created_at).id
+      engine.propose(description: 'overflow')
+      expect(engine.hypotheses.key?(oldest_id)).to be false
+    end
+  end
+
+  describe '#test_hypothesis' do
+    it 'updates posterior when hypothesis exists' do
+      h     = engine.propose(description: 'testable', prior: 0.5)
+      prior = h.posterior
+      engine.test_hypothesis(hypothesis_id: h.id, evidence_strength: 1.0, supporting: true)
+      expect(h.posterior).to be > prior
+    end
+
+    it 'returns nil for unknown hypothesis_id' do
+      result = engine.test_hypothesis(hypothesis_id: 'nonexistent', evidence_strength: 0.5, supporting: true)
+      expect(result).to be_nil
+    end
+
+    it 'auto-confirms when posterior crosses CONFIRMATION_THRESHOLD' do
+      h = engine.propose(description: 'high prior', prior: 0.79)
+      engine.test_hypothesis(hypothesis_id: h.id, evidence_strength: 1.0, supporting: true)
+      expect(h.status).to eq(:confirmed)
+    end
+
+    it 'auto-disconfirms when posterior falls below DISCONFIRMATION_THRESHOLD' do
+      h = engine.propose(description: 'low prior', prior: 0.21)
+      engine.test_hypothesis(hypothesis_id: h.id, evidence_strength: 1.0, supporting: false)
+      expect(h.status).to eq(:disconfirmed)
+    end
+  end
+
+  describe '#evaluate' do
+    it 'returns nil for unknown hypothesis_id' do
+      expect(engine.evaluate('nonexistent')).to be_nil
+    end
+
+    it 'confirms when posterior >= CONFIRMATION_THRESHOLD' do
+      h = engine.propose(description: 'evaluate confirm', prior: 0.9)
+      engine.evaluate(h.id)
+      expect(h.status).to eq(:confirmed)
+    end
+
+    it 'disconfirms when posterior <= DISCONFIRMATION_THRESHOLD' do
+      h = engine.propose(description: 'evaluate disconfirm', prior: 0.1)
+      engine.evaluate(h.id)
+      expect(h.status).to eq(:disconfirmed)
+    end
+
+    it 'does not re-evaluate an already confirmed hypothesis' do
+      h = engine.propose(description: 'already confirmed', prior: 0.5)
+      h.confirm!
+      engine.evaluate(h.id)
+      expect(h.status).to eq(:confirmed)
+    end
+  end
+
+  describe '#competing_hypotheses' do
+    it 'returns all hypotheses in the given domain' do
+      engine.propose(description: 'h1', domain: 'physics')
+      engine.propose(description: 'h2', domain: 'physics')
+      engine.propose(description: 'h3', domain: 'chemistry')
+      result = engine.competing_hypotheses(domain: 'physics')
+      expect(result.size).to eq(2)
+    end
+
+    it 'returns an empty array when no hypotheses match the domain' do
+      engine.propose(description: 'other', domain: 'biology')
+      expect(engine.competing_hypotheses(domain: 'astronomy')).to be_empty
+    end
+  end
+
+  describe '#most_confident' do
+    it 'returns hypotheses sorted by descending posterior' do
+      h1 = engine.propose(description: 'low',  prior: 0.2)
+      h2 = engine.propose(description: 'high', prior: 0.9)
+      h3 = engine.propose(description: 'mid',  prior: 0.5)
+      result = engine.most_confident(limit: 3)
+      expect(result.map(&:id)).to eq([h2.id, h3.id, h1.id])
+    end
+
+    it 'respects the limit parameter' do
+      5.times { |i| engine.propose(description: "h#{i}", prior: i * 0.1) }
+      expect(engine.most_confident(limit: 3).size).to eq(3)
+    end
+  end
+
+  describe '#confirmation_rate' do
+    it 'returns 0.0 when no hypotheses have been resolved' do
+      engine.propose(description: 'unresolved')
+      expect(engine.confirmation_rate).to eq(0.0)
+    end
+
+    it 'computes rate correctly with mixed outcomes' do
+      h1 = engine.propose(description: 'h1', prior: 0.9)
+      h1.confirm!
+      h2 = engine.propose(description: 'h2', prior: 0.1)
+      h2.disconfirm!
+      expect(engine.confirmation_rate).to eq(0.5)
+    end
+
+    it 'returns 1.0 when all resolved hypotheses are confirmed' do
+      h = engine.propose(description: 'confirmed', prior: 0.9)
+      h.confirm!
+      expect(engine.confirmation_rate).to eq(1.0)
+    end
+  end
+
+  describe '#hypothesis_report' do
+    it 'includes total, by_status, confirmation_rate, most_confident' do
+      engine.propose(description: 'a')
+      engine.propose(description: 'b')
+      report = engine.hypothesis_report
+      expect(report.keys).to include(:total, :by_status, :confirmation_rate, :most_confident)
+    end
+
+    it 'reports correct total count' do
+      3.times { |i| engine.propose(description: "h#{i}") }
+      expect(engine.hypothesis_report[:total]).to eq(3)
+    end
+
+    it 'limits most_confident to 3 entries' do
+      5.times { |i| engine.propose(description: "h#{i}") }
+      expect(engine.hypothesis_report[:most_confident].size).to be <= 3
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes hypotheses array, confirmation_rate, and total' do
+      engine.propose(description: 'serialized')
+      result = engine.to_h
+      expect(result.keys).to include(:hypotheses, :confirmation_rate, :total)
+    end
+
+    it 'returns each hypothesis as a hash' do
+      engine.propose(description: 'one')
+      engine.to_h[:hypotheses].each do |h|
+        expect(h).to be_a(Hash)
+        expect(h.keys).to include(:id, :description, :status)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis_spec.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/constants'
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::HypothesisTesting::Helpers::Hypothesis do
+  subject(:hypothesis) { described_class.new(description: 'test hypothesis', domain: 'logic') }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(hypothesis.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets description' do
+      expect(hypothesis.description).to eq('test hypothesis')
+    end
+
+    it 'sets domain' do
+      expect(hypothesis.domain).to eq('logic')
+    end
+
+    it 'defaults prior to PRIOR_DEFAULT' do
+      h = described_class.new(description: 'default prior')
+      expect(h.prior).to eq(Legion::Extensions::Agentic::Inference::HypothesisTesting::Helpers::Constants::PRIOR_DEFAULT)
+    end
+
+    it 'sets posterior to prior at creation' do
+      h = described_class.new(description: 'check posterior', prior: 0.3)
+      expect(h.posterior).to eq(0.3)
+    end
+
+    it 'starts with evidence_count of 0' do
+      expect(hypothesis.evidence_count).to eq(0)
+    end
+
+    it 'starts with status :proposed' do
+      expect(hypothesis.status).to eq(:proposed)
+    end
+
+    it 'clamps prior above 1.0 to 1.0' do
+      h = described_class.new(description: 'high', prior: 1.5)
+      expect(h.prior).to eq(1.0)
+    end
+
+    it 'clamps prior below 0.0 to 0.0' do
+      h = described_class.new(description: 'low', prior: -0.1)
+      expect(h.prior).to eq(0.0)
+    end
+  end
+
+  describe '#update_posterior!' do
+    it 'increases posterior with supporting evidence' do
+      before = hypothesis.posterior
+      hypothesis.update_posterior!(evidence_strength: 1.0, supporting: true)
+      expect(hypothesis.posterior).to be > before
+    end
+
+    it 'decreases posterior with contradicting evidence' do
+      h = described_class.new(description: 'contra', prior: 0.8)
+      h.update_posterior!(evidence_strength: 1.0, supporting: false)
+      expect(h.posterior).to be < 0.8
+    end
+
+    it 'transitions status to :testing' do
+      hypothesis.update_posterior!(evidence_strength: 0.5, supporting: true)
+      expect(hypothesis.status).to eq(:testing)
+    end
+
+    it 'increments evidence_count' do
+      hypothesis.update_posterior!(evidence_strength: 0.5, supporting: true)
+      expect(hypothesis.evidence_count).to eq(1)
+    end
+
+    it 'keeps posterior within [0.0, 1.0]' do
+      10.times { hypothesis.update_posterior!(evidence_strength: 1.0, supporting: true) }
+      expect(hypothesis.posterior).to be <= 1.0
+    end
+
+    it 'does not update a confirmed hypothesis' do
+      hypothesis.confirm!
+      prior_posterior = hypothesis.posterior
+      hypothesis.update_posterior!(evidence_strength: 1.0, supporting: false)
+      expect(hypothesis.posterior).to eq(prior_posterior)
+    end
+
+    it 'does not update a disconfirmed hypothesis' do
+      hypothesis.disconfirm!
+      prior_posterior = hypothesis.posterior
+      hypothesis.update_posterior!(evidence_strength: 1.0, supporting: true)
+      expect(hypothesis.posterior).to eq(prior_posterior)
+    end
+
+    it 'clamps evidence_strength above 1.0' do
+      hypothesis.update_posterior!(evidence_strength: 5.0, supporting: true)
+      expect(hypothesis.posterior).to be <= 1.0
+    end
+
+    it 'rounds posterior to 10 decimal places' do
+      hypothesis.update_posterior!(evidence_strength: 0.7, supporting: true)
+      expect(hypothesis.posterior.to_s.split('.').last.length).to be <= 10
+    end
+  end
+
+  describe '#confirm!' do
+    it 'sets status to :confirmed' do
+      hypothesis.confirm!
+      expect(hypothesis.status).to eq(:confirmed)
+    end
+
+    it 'raises posterior to at least CONFIRMATION_THRESHOLD' do
+      h = described_class.new(description: 'near confirm', prior: 0.75)
+      h.confirm!
+      expect(h.posterior).to be >= Legion::Extensions::Agentic::Inference::HypothesisTesting::Helpers::Constants::CONFIRMATION_THRESHOLD
+    end
+  end
+
+  describe '#disconfirm!' do
+    it 'sets status to :disconfirmed' do
+      hypothesis.disconfirm!
+      expect(hypothesis.status).to eq(:disconfirmed)
+    end
+
+    it 'lowers posterior to at most DISCONFIRMATION_THRESHOLD' do
+      h = described_class.new(description: 'near disconfirm', prior: 0.25)
+      h.disconfirm!
+      expect(h.posterior).to be <= Legion::Extensions::Agentic::Inference::HypothesisTesting::Helpers::Constants::DISCONFIRMATION_THRESHOLD
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns certain for posterior >= 0.9' do
+      h = described_class.new(description: 'certain', prior: 0.95)
+      expect(h.confidence_label).to eq('certain')
+    end
+
+    it 'returns confident for posterior in [0.7, 0.9)' do
+      h = described_class.new(description: 'confident', prior: 0.8)
+      expect(h.confidence_label).to eq('confident')
+    end
+
+    it 'returns leaning for posterior in [0.5, 0.7)' do
+      h = described_class.new(description: 'leaning', prior: 0.6)
+      expect(h.confidence_label).to eq('leaning')
+    end
+
+    it 'returns uncertain for posterior in [0.3, 0.5)' do
+      h = described_class.new(description: 'uncertain', prior: 0.4)
+      expect(h.confidence_label).to eq('uncertain')
+    end
+
+    it 'returns agnostic for posterior in [0.0, 0.3)' do
+      h = described_class.new(description: 'agnostic', prior: 0.1)
+      expect(h.confidence_label).to eq('agnostic')
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all required keys' do
+      result = hypothesis.to_h
+      expect(result.keys).to include(:id, :description, :domain, :prior, :posterior,
+                                     :evidence_count, :status, :confidence_label, :created_at)
+    end
+
+    it 'returns correct id' do
+      expect(hypothesis.to_h[:id]).to eq(hypothesis.id)
+    end
+
+    it 'returns correct status' do
+      expect(hypothesis.to_h[:status]).to eq(:proposed)
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/hypothesis_testing/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::HypothesisTesting::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:propose_hypothesis)
+    expect(client).to respond_to(:test_hypothesis)
+    expect(client).to respond_to(:evaluate_hypothesis)
+    expect(client).to respond_to(:competing_hypotheses)
+    expect(client).to respond_to(:most_confident_hypotheses)
+    expect(client).to respond_to(:hypothesis_report)
+    expect(client).to respond_to(:get_hypothesis)
+  end
+end