lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/argument_mapping/runners/argument_mapping_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::ArgumentMapping::Runners::ArgumentMapping do
+  let(:client) { Legion::Extensions::Agentic::Inference::ArgumentMapping::Client.new }
+
+  describe '#create_argument' do
+    it 'creates an argument and returns success' do
+      result = client.create_argument(claim: 'We should reduce emissions')
+      expect(result[:success]).to be true
+      expect(result[:argument][:claim]).to eq('We should reduce emissions')
+    end
+
+    it 'accepts a warrant' do
+      result = client.create_argument(claim: 'Test', warrant: 'Evidence shows it')
+      expect(result[:argument][:warrant]).to eq('Evidence shows it')
+    end
+
+    it 'accepts a qualifier' do
+      result = client.create_argument(claim: 'Test', qualifier: :certainly)
+      expect(result[:argument][:qualifier]).to eq(:certainly)
+    end
+  end
+
+  describe '#add_argument_ground' do
+    let(:argument_id) { client.create_argument(claim: 'Test claim')[:argument][:id] }
+
+    it 'adds a ground successfully' do
+      result = client.add_argument_ground(argument_id: argument_id, ground: 'Strong evidence')
+      expect(result[:success]).to be true
+      expect(result[:argument][:grounds]).to include('Strong evidence')
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.add_argument_ground(argument_id: 'bad', ground: 'Evidence')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#add_argument_backing' do
+    let(:argument_id) { client.create_argument(claim: 'Test claim')[:argument][:id] }
+
+    it 'adds backing successfully' do
+      result = client.add_argument_backing(argument_id: argument_id, backing: 'Academic study')
+      expect(result[:success]).to be true
+      expect(result[:argument][:backing]).to include('Academic study')
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.add_argument_backing(argument_id: 'bad', backing: 'Source')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#add_argument_rebuttal' do
+    let(:argument_id) { client.create_argument(claim: 'Test claim')[:argument][:id] }
+
+    it 'adds a rebuttal successfully' do
+      result = client.add_argument_rebuttal(argument_id: argument_id, content: 'Counter', impact: 0.7)
+      expect(result[:success]).to be true
+      expect(result[:argument][:rebuttals].first[:impact]).to eq(0.7)
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.add_argument_rebuttal(argument_id: 'bad', content: 'Counter')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#assess_argument_strength' do
+    let(:argument_id) do
+      id = client.create_argument(claim: 'Test', warrant: 'Because')[:argument][:id]
+      3.times { |i| client.add_argument_ground(argument_id: id, ground: "G#{i}") }
+      id
+    end
+
+    it 'returns a strength assessment' do
+      result = client.assess_argument_strength(argument_id: argument_id)
+      expect(result[:success]).to be true
+      expect(result[:strength]).to be_a(Float)
+      expect(result[:strength_label]).to be_a(Symbol)
+    end
+
+    it 'includes sound and rebutted flags' do
+      result = client.assess_argument_strength(argument_id: argument_id)
+      expect(result).to include(:sound, :rebutted)
+    end
+
+    it 'returns failure for unknown id' do
+      result = client.assess_argument_strength(argument_id: 'nope')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#sound_arguments_report' do
+    it 'returns success with count and arguments list' do
+      result = client.sound_arguments_report
+      expect(result[:success]).to be true
+      expect(result[:count]).to be_a(Integer)
+      expect(result[:arguments]).to be_an(Array)
+    end
+
+    it 'includes sound arguments after creation' do
+      id = client.create_argument(claim: 'Sound arg', warrant: 'Valid reason')[:argument][:id]
+      3.times { |i| client.add_argument_ground(argument_id: id, ground: "G#{i}") }
+      2.times { |i| client.add_argument_backing(argument_id: id, backing: "B#{i}") }
+
+      result = client.sound_arguments_report
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#rebutted_arguments_report' do
+    it 'returns success with count and arguments list' do
+      result = client.rebutted_arguments_report
+      expect(result[:success]).to be true
+      expect(result[:count]).to be_a(Integer)
+      expect(result[:arguments]).to be_an(Array)
+    end
+
+    it 'includes rebutted arguments after rebuttal added' do
+      id = client.create_argument(claim: 'Rebutted arg')[:argument][:id]
+      client.add_argument_rebuttal(argument_id: id, content: 'Devastating counter', impact: 0.9)
+
+      result = client.rebutted_arguments_report
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#strongest_arguments_report' do
+    before do
+      2.times do |i|
+        id = client.create_argument(claim: "Claim #{i}", warrant: "Warrant #{i}")[:argument][:id]
+        i.times { |j| client.add_argument_ground(argument_id: id, ground: "G#{j}") }
+      end
+    end
+
+    it 'returns success with ordered arguments' do
+      result = client.strongest_arguments_report(limit: 2)
+      expect(result[:success]).to be true
+      expect(result[:arguments]).to be_an(Array)
+    end
+
+    it 'respects the limit' do
+      result = client.strongest_arguments_report(limit: 1)
+      expect(result[:count]).to be <= 1
+    end
+  end
+
+  describe '#update_argument_mapping' do
+    it 'runs decay and returns success' do
+      client.create_argument(claim: 'Test')
+      result = client.update_argument_mapping
+      expect(result[:success]).to be true
+      expect(result[:arguments_processed]).to be_a(Integer)
+    end
+  end
+
+  describe '#argument_mapping_stats' do
+    it 'returns success with counts' do
+      result = client.argument_mapping_stats
+      expect(result[:success]).to be true
+      expect(result).to include(:total_arguments, :sound_arguments, :rebutted_arguments)
+    end
+
+    it 'reflects created arguments' do
+      client.create_argument(claim: 'Stat test')
+      result = client.argument_mapping_stats
+      expect(result[:total_arguments]).to be >= 1
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/bayesian/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Bayesian::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:add_bayesian_belief)
+    expect(client).to respond_to(:update_bayesian_belief)
+    expect(client).to respond_to(:batch_bayesian_update)
+    expect(client).to respond_to(:most_probable_beliefs)
+    expect(client).to respond_to(:least_probable_beliefs)
+    expect(client).to respond_to(:posterior_distribution)
+    expect(client).to respond_to(:information_gain)
+    expect(client).to respond_to(:belief_entropy)
+    expect(client).to respond_to(:update_bayesian_beliefs)
+    expect(client).to respond_to(:bayesian_belief_stats)
+  end
+end

data/spec/legion/extensions/agentic/inference/bayesian/helpers/belief_network_spec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Bayesian::Helpers::BeliefNetwork do
+  let(:network) { described_class.new }
+  let(:consts)  { Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Constants }
+
+  def add(content: 'hypothesis', domain: :general, prior: 0.5)
+    network.add_belief(content: content, domain: domain, prior: prior)
+  end
+
+  describe '#add_belief' do
+    it 'adds a belief and returns it' do
+      belief = add
+      expect(belief).to be_a(Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Belief)
+      expect(network.count).to eq(1)
+    end
+
+    it 'uses provided prior' do
+      belief = add(prior: 0.7)
+      expect(belief.prior).to eq(0.7)
+    end
+  end
+
+  describe '#update_belief' do
+    it 'updates and returns the belief' do
+      belief = add
+      result = network.update_belief(belief_id: belief.id, evidence_id: 'ev-1', likelihood: 0.9)
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Belief)
+      expect(result.posterior).to be > 0.5
+    end
+
+    it 'returns nil for unknown belief_id' do
+      result = network.update_belief(belief_id: 'nonexistent', evidence_id: 'ev-1', likelihood: 0.8)
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#batch_update' do
+    it 'updates multiple beliefs with same evidence' do
+      b1 = add(content: 'h1', domain: :test)
+      b2 = add(content: 'h2', domain: :test)
+      likelihoods = { b1.id => 0.8, b2.id => 0.3 }
+
+      result = network.batch_update(evidence_id: 'ev-batch', likelihoods: likelihoods)
+      expect(result.size).to eq(2)
+    end
+
+    it 'returns empty hash for empty likelihoods' do
+      result = network.batch_update(evidence_id: 'ev-1', likelihoods: {})
+      expect(result).to be_empty
+    end
+  end
+
+  describe '#most_probable' do
+    it 'returns beliefs sorted by posterior descending' do
+      add(content: 'low',  domain: :test, prior: 0.2)
+      add(content: 'high', domain: :test, prior: 0.8)
+      add(content: 'mid',  domain: :test, prior: 0.5)
+
+      beliefs = network.most_probable
+      expect(beliefs.first.posterior).to be >= beliefs.last.posterior
+    end
+
+    it 'limits results' do
+      3.times { |idx| add(content: "h#{idx}", domain: :test) }
+      expect(network.most_probable(limit: 2).size).to eq(2)
+    end
+
+    it 'filters by domain' do
+      add(content: 'a', domain: :alpha)
+      add(content: 'b', domain: :beta)
+      results = network.most_probable(domain: :alpha)
+      expect(results.all? { |b| b.domain == :alpha }).to be true
+    end
+  end
+
+  describe '#least_probable' do
+    it 'returns beliefs sorted by posterior ascending' do
+      add(content: 'low',  domain: :test, prior: 0.1)
+      add(content: 'high', domain: :test, prior: 0.9)
+
+      beliefs = network.least_probable
+      expect(beliefs.first.posterior).to be <= beliefs.last.posterior
+    end
+  end
+
+  describe '#by_domain' do
+    it 'returns only beliefs in specified domain' do
+      add(content: 'a', domain: :alpha)
+      add(content: 'b', domain: :beta)
+      result = network.by_domain(domain: :alpha)
+      expect(result.size).to eq(1)
+      expect(result.first.domain).to eq(:alpha)
+    end
+  end
+
+  describe '#posterior_distribution' do
+    it 'returns normalized probabilities that sum to ~1' do
+      add(content: 'h1', domain: :test, prior: 0.3)
+      add(content: 'h2', domain: :test, prior: 0.7)
+
+      dist = network.posterior_distribution(domain: :test)
+      expect(dist.values.sum).to be_within(0.001).of(1.0)
+    end
+
+    it 'returns empty hash when no beliefs exist' do
+      expect(network.posterior_distribution).to eq({})
+    end
+  end
+
+  describe '#information_gain' do
+    it 'returns a non-negative float' do
+      belief = add
+      gain = network.information_gain(belief_id: belief.id, evidence_id: 'ev-1', likelihood: 0.9)
+      expect(gain).to be >= 0.0
+    end
+
+    it 'returns 0.0 for unknown belief' do
+      gain = network.information_gain(belief_id: 'nonexistent', evidence_id: 'ev-1', likelihood: 0.8)
+      expect(gain).to eq(0.0)
+    end
+
+    it 'does not mutate the belief posterior' do
+      belief = add
+      before = belief.posterior
+      network.information_gain(belief_id: belief.id, evidence_id: 'ev-1', likelihood: 0.9)
+      expect(belief.posterior).to eq(before)
+    end
+
+    it 'returns higher gain for more extreme likelihoods' do
+      b1 = add(content: 'h1')
+      b2 = add(content: 'h2')
+
+      gain_strong = network.information_gain(belief_id: b1.id, evidence_id: 'ev', likelihood: 0.95)
+      gain_weak   = network.information_gain(belief_id: b2.id, evidence_id: 'ev', likelihood: 0.55)
+      expect(gain_strong).to be > gain_weak
+    end
+  end
+
+  describe '#entropy' do
+    it 'returns 0.0 when no beliefs' do
+      expect(network.entropy).to eq(0.0)
+    end
+
+    it 'returns a positive float when beliefs exist' do
+      2.times { |idx| add(content: "h#{idx}") }
+      expect(network.entropy).to be > 0.0
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns count of beliefs updated' do
+      3.times { |idx| add(content: "h#{idx}") }
+      expect(network.decay_all).to eq(3)
+    end
+
+    it 'drifts posterior toward prior' do
+      belief = add(prior: 0.5)
+      belief.update(likelihood: 0.9, evidence_id: 'ev-1')
+      before = belief.posterior
+
+      network.decay_all
+
+      after = belief.posterior
+      expect(after).to be < before
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes belief_count and beliefs keys' do
+      add
+      hash = network.to_h
+      expect(hash).to have_key(:belief_count)
+      expect(hash).to have_key(:beliefs)
+      expect(hash[:belief_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/bayesian/helpers/belief_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Belief do
+  let(:belief) { described_class.new(content: 'test hypothesis', domain: :general) }
+
+  describe '#initialize' do
+    it 'sets prior and posterior to default' do
+      expect(belief.prior).to eq(Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Constants::DEFAULT_PRIOR)
+      expect(belief.posterior).to eq(belief.prior)
+    end
+
+    it 'generates a uuid id' do
+      expect(belief.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts with empty evidence_history' do
+      expect(belief.evidence_history).to be_empty
+    end
+
+    it 'clamps prior to floor/ceiling' do
+      high = described_class.new(content: 'test', domain: :x, prior: 1.5)
+      low  = described_class.new(content: 'test', domain: :x, prior: -0.1)
+      expect(high.prior).to eq(Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Constants::PRIOR_CEILING)
+      expect(low.prior).to eq(Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Constants::PRIOR_FLOOR)
+    end
+  end
+
+  describe '#update' do
+    it 'raises posterior when likelihood is high' do
+      before = belief.posterior
+      belief.update(likelihood: 0.9, evidence_id: 'ev-1')
+      expect(belief.posterior).to be > before
+    end
+
+    it 'lowers posterior when likelihood is low' do
+      before = belief.posterior
+      belief.update(likelihood: 0.1, evidence_id: 'ev-1')
+      expect(belief.posterior).to be < before
+    end
+
+    it 'records evidence in history' do
+      belief.update(likelihood: 0.8, evidence_id: 'ev-1')
+      expect(belief.evidence_history.size).to eq(1)
+      expect(belief.evidence_history.first[:evidence_id]).to eq('ev-1')
+    end
+
+    it 'increments update_count' do
+      belief.update(likelihood: 0.7, evidence_id: 'ev-1')
+      belief.update(likelihood: 0.6, evidence_id: 'ev-2')
+      expect(belief.update_count).to eq(2)
+    end
+
+    it 'clamps posterior within bounds' do
+      10.times { |idx| belief.update(likelihood: 0.999, evidence_id: "ev-#{idx}") }
+      expect(belief.posterior).to be <= Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Constants::PRIOR_CEILING
+      expect(belief.posterior).to be >= Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Constants::PRIOR_FLOOR
+    end
+  end
+
+  describe '#log_odds' do
+    it 'returns 0.0 at prior 0.5' do
+      expect(belief.log_odds).to be_within(0.001).of(0.0)
+    end
+
+    it 'returns positive value when posterior > 0.5' do
+      belief.update(likelihood: 0.9, evidence_id: 'ev-1')
+      expect(belief.log_odds).to be > 0.0
+    end
+
+    it 'returns negative value when posterior < 0.5' do
+      belief.update(likelihood: 0.1, evidence_id: 'ev-1')
+      expect(belief.log_odds).to be < 0.0
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns :leaning for default prior 0.5' do
+      expect(belief.confidence_label).to eq(:leaning)
+    end
+
+    it 'returns :certain for high posterior' do
+      high = described_class.new(content: 'test', domain: :x, prior: 0.95)
+      expect(high.confidence_label).to eq(:certain)
+    end
+
+    it 'returns :doubtful for low posterior' do
+      low = described_class.new(content: 'test', domain: :x, prior: 0.1)
+      expect(low.confidence_label).to eq(:doubtful)
+    end
+
+    it 'returns :confident for posterior in 0.7..0.9' do
+      conf = described_class.new(content: 'test', domain: :x, prior: 0.8)
+      expect(conf.confidence_label).to eq(:confident)
+    end
+
+    it 'returns :uncertain for posterior in 0.3..0.5' do
+      unc = described_class.new(content: 'test', domain: :x, prior: 0.4)
+      expect(unc.confidence_label).to eq(:uncertain)
+    end
+  end
+
+  describe '#surprise' do
+    it 'returns 0.0 for certain observation (likelihood 1.0)' do
+      expect(belief.surprise(observation_likelihood: 1.0)).to be_within(0.001).of(0.0)
+    end
+
+    it 'returns positive surprise for unlikely observation' do
+      expect(belief.surprise(observation_likelihood: 0.125)).to be_within(0.001).of(3.0)
+    end
+  end
+
+  describe '#reset_to_prior!' do
+    it 'resets posterior to original prior' do
+      belief.update(likelihood: 0.9, evidence_id: 'ev-1')
+      expect(belief.posterior).not_to eq(belief.prior)
+      belief.reset_to_prior!
+      expect(belief.posterior).to eq(belief.prior)
+    end
+
+    it 'clears evidence history and update count' do
+      belief.update(likelihood: 0.8, evidence_id: 'ev-1')
+      belief.reset_to_prior!
+      expect(belief.evidence_history).to be_empty
+      expect(belief.update_count).to eq(0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all required keys' do
+      hash = belief.to_h
+      %i[id content domain prior posterior confidence_label log_odds update_count
+         evidence_history created_at last_updated_at].each do |key|
+        expect(hash).to have_key(key)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/bayesian/runners/bayesian_belief_spec.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/bayesian/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Bayesian::Runners::BayesianBelief do
+  let(:client) { Legion::Extensions::Agentic::Inference::Bayesian::Client.new }
+
+  describe '#add_bayesian_belief' do
+    it 'adds a belief and returns success' do
+      result = client.add_bayesian_belief(content: 'test hypothesis', domain: :general)
+      expect(result[:success]).to be true
+      expect(result[:belief_id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:domain]).to eq(:general)
+    end
+
+    it 'uses default prior when none provided' do
+      result = client.add_bayesian_belief(content: 'test', domain: :test)
+      expect(result[:prior]).to eq(Legion::Extensions::Agentic::Inference::Bayesian::Helpers::Constants::DEFAULT_PRIOR)
+    end
+
+    it 'uses provided prior' do
+      result = client.add_bayesian_belief(content: 'test', domain: :test, prior: 0.7)
+      expect(result[:prior]).to be_within(0.001).of(0.7)
+    end
+  end
+
+  describe '#update_bayesian_belief' do
+    it 'updates an existing belief' do
+      added  = client.add_bayesian_belief(content: 'h1', domain: :test)
+      result = client.update_bayesian_belief(
+        belief_id:   added[:belief_id],
+        evidence_id: 'ev-1',
+        likelihood:  0.9
+      )
+      expect(result[:success]).to be true
+      expect(result[:posterior]).to be > 0.5
+      expect(result[:update_count]).to eq(1)
+    end
+
+    it 'returns not_found for unknown belief' do
+      result = client.update_bayesian_belief(belief_id: 'nonexistent', evidence_id: 'ev-1', likelihood: 0.8)
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'returns confidence_label' do
+      added  = client.add_bayesian_belief(content: 'h1', domain: :test, prior: 0.95)
+      result = client.update_bayesian_belief(
+        belief_id:   added[:belief_id],
+        evidence_id: 'ev-1',
+        likelihood:  0.9
+      )
+      expect(result[:confidence_label]).to eq(:certain)
+    end
+  end
+
+  describe '#batch_bayesian_update' do
+    it 'updates multiple beliefs' do
+      b1 = client.add_bayesian_belief(content: 'h1', domain: :test)
+      b2 = client.add_bayesian_belief(content: 'h2', domain: :test)
+      likelihoods = { b1[:belief_id] => 0.8, b2[:belief_id] => 0.3 }
+
+      result = client.batch_bayesian_update(evidence_id: 'ev-batch', likelihoods: likelihoods)
+      expect(result[:success]).to be true
+      expect(result[:updated]).to eq(2)
+    end
+
+    it 'handles empty likelihoods gracefully' do
+      result = client.batch_bayesian_update(evidence_id: 'ev-1', likelihoods: {})
+      expect(result[:success]).to be true
+      expect(result[:updated]).to eq(0)
+    end
+  end
+
+  describe '#most_probable_beliefs' do
+    it 'returns beliefs sorted by probability' do
+      client.add_bayesian_belief(content: 'low',  domain: :ranked, prior: 0.2)
+      client.add_bayesian_belief(content: 'high', domain: :ranked, prior: 0.8)
+
+      result = client.most_probable_beliefs(domain: :ranked)
+      expect(result[:success]).to be true
+      expect(result[:beliefs].first[:posterior]).to be >= result[:beliefs].last[:posterior]
+    end
+
+    it 'respects limit parameter' do
+      5.times { |idx| client.add_bayesian_belief(content: "h#{idx}", domain: :limit_test) }
+      result = client.most_probable_beliefs(domain: :limit_test, limit: 3)
+      expect(result[:count]).to eq(3)
+    end
+  end
+
+  describe '#least_probable_beliefs' do
+    it 'returns beliefs sorted by ascending probability' do
+      client.add_bayesian_belief(content: 'low',  domain: :sorted, prior: 0.1)
+      client.add_bayesian_belief(content: 'high', domain: :sorted, prior: 0.9)
+
+      result = client.least_probable_beliefs(domain: :sorted)
+      expect(result[:beliefs].first[:posterior]).to be <= result[:beliefs].last[:posterior]
+    end
+  end
+
+  describe '#posterior_distribution' do
+    it 'returns normalized distribution summing to 1' do
+      client.add_bayesian_belief(content: 'h1', domain: :dist, prior: 0.3)
+      client.add_bayesian_belief(content: 'h2', domain: :dist, prior: 0.7)
+
+      result = client.posterior_distribution(domain: :dist)
+      expect(result[:success]).to be true
+      expect(result[:distribution].values.sum).to be_within(0.001).of(1.0)
+    end
+
+    it 'returns empty distribution when no beliefs' do
+      result = client.posterior_distribution(domain: :empty_domain)
+      expect(result[:distribution]).to be_empty
+    end
+  end
+
+  describe '#information_gain' do
+    it 'computes gain without mutating the belief' do
+      added   = client.add_bayesian_belief(content: 'h1', domain: :ig)
+      before  = added[:posterior]
+      result  = client.information_gain(belief_id: added[:belief_id], evidence_id: 'ev-1', likelihood: 0.9)
+      expect(result[:success]).to be true
+      expect(result[:information_gain]).to be >= 0.0
+
+      check = client.most_probable_beliefs(domain: :ig)
+      expect(check[:beliefs].first[:posterior]).to be_within(0.001).of(before)
+    end
+  end
+
+  describe '#belief_entropy' do
+    it 'returns entropy for all beliefs' do
+      client.add_bayesian_belief(content: 'h1', domain: :ent)
+      client.add_bayesian_belief(content: 'h2', domain: :ent)
+
+      result = client.belief_entropy(domain: :ent)
+      expect(result[:success]).to be true
+      expect(result[:entropy]).to be >= 0.0
+    end
+
+    it 'returns 0.0 entropy when no beliefs exist' do
+      fresh = Legion::Extensions::Agentic::Inference::Bayesian::Client.new
+      result = fresh.belief_entropy
+      expect(result[:entropy]).to eq(0.0)
+    end
+  end
+
+  describe '#update_bayesian_beliefs (decay)' do
+    it 'returns success and decayed count' do
+      2.times { |idx| client.add_bayesian_belief(content: "h#{idx}", domain: :decay) }
+      result = client.update_bayesian_beliefs
+      expect(result[:success]).to be true
+      expect(result[:decayed]).to eq(2)
+    end
+  end
+
+  describe '#bayesian_belief_stats' do
+    it 'returns stats hash with expected keys' do
+      client.add_bayesian_belief(content: 'h1', domain: :stats)
+      result = client.bayesian_belief_stats
+      expect(result[:success]).to be true
+      expect(result).to have_key(:total_beliefs)
+      expect(result).to have_key(:entropy)
+      expect(result).to have_key(:most_probable)
+      expect(result).to have_key(:least_probable)
+      expect(result).to have_key(:capacity)
+    end
+
+    it 'returns nil for most/least probable when no beliefs' do
+      fresh  = Legion::Extensions::Agentic::Inference::Bayesian::Client.new
+      result = fresh.bayesian_belief_stats
+      expect(result[:most_probable]).to be_nil
+      expect(result[:least_probable]).to be_nil
+    end
+  end
+end