lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/predictive_processing/helpers/predictive_processor_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::PredictiveProcessing::Helpers::PredictiveProcessor do
+  subject(:processor) { described_class.new }
+
+  describe '#add_model' do
+    it 'adds a new model for a domain' do
+      result = processor.add_model(domain: :perception)
+      expect(result[:added]).to be true
+      expect(result[:domain]).to eq(:perception)
+    end
+
+    it 'returns model_id on success' do
+      result = processor.add_model(domain: :cognition)
+      expect(result[:model_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'rejects duplicate domains' do
+      processor.add_model(domain: :dup)
+      result = processor.add_model(domain: :dup)
+      expect(result[:added]).to be false
+      expect(result[:reason]).to eq(:already_exists)
+    end
+
+    it 'rejects when at model limit' do
+      20.times { |i| processor.add_model(domain: :"domain_#{i}") }
+      result = processor.add_model(domain: :overflow)
+      expect(result[:added]).to be false
+      expect(result[:reason]).to eq(:limit_reached)
+    end
+  end
+
+  describe '#predict' do
+    it 'returns a prediction hash for a known domain' do
+      processor.add_model(domain: :action)
+      result = processor.predict(domain: :action, context: { urgency: 0.8 })
+      expect(result[:expected_value]).to be_a(Float)
+    end
+
+    it 'auto-creates model for unknown domain (within limit)' do
+      result = processor.predict(domain: :new_domain, context: {})
+      expect(result[:expected_value]).to be_a(Float)
+    end
+
+    it 'includes domain in prediction' do
+      result = processor.predict(domain: :emotion, context: {})
+      expect(result[:domain]).to eq(:emotion)
+    end
+  end
+
+  describe '#observe' do
+    before { processor.add_model(domain: :vision) }
+
+    it 'returns observed: true for known domain' do
+      result = processor.observe(domain: :vision, actual: 0.7, predicted: 0.5)
+      expect(result[:observed]).to be true
+    end
+
+    it 'returns prediction_error' do
+      result = processor.observe(domain: :vision, actual: 0.8, predicted: 0.5)
+      expect(result[:prediction_error]).to be_a(Float)
+    end
+
+    it 'returns inference_mode' do
+      result = processor.observe(domain: :vision, actual: 0.8, predicted: 0.5)
+      expect(described_class::INFERENCE_MODES).to include(result[:inference_mode])
+    end
+
+    it 'returns observed: false for unknown domain' do
+      result = processor.observe(domain: :unknown, actual: 0.5, predicted: 0.5)
+      expect(result[:observed]).to be false
+      expect(result[:reason]).to eq(:domain_not_found)
+    end
+
+    it 'returns free_energy after observation' do
+      result = processor.observe(domain: :vision, actual: 1.0, predicted: 0.0)
+      expect(result[:free_energy]).to be_a(Float)
+    end
+  end
+
+  describe '#inference_mode' do
+    it 'returns :perceptual for unknown domain' do
+      expect(processor.inference_mode(:nonexistent)).to eq(:perceptual)
+    end
+
+    it 'returns a valid inference mode for known domain' do
+      processor.add_model(domain: :memory)
+      mode = processor.inference_mode(:memory)
+      expect(described_class::INFERENCE_MODES).to include(mode)
+    end
+
+    it 'returns :active or :hybrid when free energy is high' do
+      processor.add_model(domain: :surprise)
+      5.times { processor.observe(domain: :surprise, actual: 1.0, predicted: 0.0) }
+      mode = processor.inference_mode(:surprise)
+      expect(%i[active hybrid]).to include(mode)
+    end
+  end
+
+  describe '#free_energy_for' do
+    it 'returns nil for unknown domain' do
+      expect(processor.free_energy_for(:unknown)).to be_nil
+    end
+
+    it 'returns a float for known domain' do
+      processor.add_model(domain: :planning)
+      expect(processor.free_energy_for(:planning)).to be_a(Float)
+    end
+  end
+
+  describe '#global_free_energy' do
+    it 'returns 0.0 with no models' do
+      expect(processor.global_free_energy).to eq(0.0)
+    end
+
+    it 'returns average free energy across models' do
+      processor.add_model(domain: :d1)
+      processor.add_model(domain: :d2)
+      expect(processor.global_free_energy).to be_a(Float)
+    end
+  end
+
+  describe '#precision_weight' do
+    it 'returns DEFAULT_PRECISION for unknown domain' do
+      expect(processor.precision_weight(:unknown)).to eq(described_class::DEFAULT_PRECISION)
+    end
+
+    it 'returns model precision for known domain' do
+      processor.add_model(domain: :known)
+      expect(processor.precision_weight(:known)).to be_a(Float)
+    end
+  end
+
+  describe '#models_needing_update' do
+    it 'returns empty hash when all models are stable' do
+      expect(processor.models_needing_update).to be_empty
+    end
+
+    it 'returns domains with high free energy' do
+      processor.add_model(domain: :erratic)
+      5.times { processor.observe(domain: :erratic, actual: 1.0, predicted: 0.0) }
+      needing = processor.models_needing_update
+      expect(needing).to have_key(:erratic)
+    end
+  end
+
+  describe '#stable_models' do
+    it 'returns all models initially (all stable)' do
+      processor.add_model(domain: :calm)
+      expect(processor.stable_models).to have_key(:calm)
+    end
+
+    it 'excludes surprised models' do
+      processor.add_model(domain: :upset)
+      5.times { processor.observe(domain: :upset, actual: 1.0, predicted: 0.0) }
+      expect(processor.stable_models).not_to have_key(:upset)
+    end
+  end
+
+  describe '#active_inference_candidates' do
+    it 'returns empty array when all models have low free energy' do
+      expect(processor.active_inference_candidates).to be_empty
+    end
+
+    it 'returns domains exceeding active inference threshold' do
+      processor.add_model(domain: :high_fe)
+      5.times { processor.observe(domain: :high_fe, actual: 1.0, predicted: 0.0) }
+      expect(processor.active_inference_candidates).to include(:high_fe)
+    end
+  end
+
+  describe '#tick' do
+    it 'decays precision on all models' do
+      processor.add_model(domain: :tickable)
+      before = processor.models[:tickable].precision
+      processor.tick
+      expect(processor.models[:tickable].precision).to be < before
+    end
+
+    it 'does not raise with no models' do
+      expect { processor.tick }.not_to raise_error
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes model_count' do
+      processor.add_model(domain: :counted)
+      expect(processor.to_h[:model_count]).to eq(1)
+    end
+
+    it 'includes global_free_energy' do
+      expect(processor.to_h[:global_free_energy]).to be_a(Float)
+    end
+
+    it 'includes models hash' do
+      processor.add_model(domain: :listed)
+      expect(processor.to_h[:models]).to have_key(:listed)
+    end
+
+    it 'includes counts for needing update and stable' do
+      h = processor.to_h
+      expect(h).to have_key(:models_needing_update)
+      expect(h).to have_key(:stable_model_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/predictive_processing/runners/predictive_processing_spec.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::PredictiveProcessing::Runners::PredictiveProcessing do
+  let(:client) { Legion::Extensions::Agentic::Inference::PredictiveProcessing::Client.new }
+
+  describe '#add_generative_model' do
+    it 'adds a model for a valid domain' do
+      result = client.add_generative_model(domain: :perception)
+      expect(result[:added]).to be true
+      expect(result[:domain]).to eq(:perception)
+    end
+
+    it 'returns error for nil domain' do
+      result = client.add_generative_model(domain: nil)
+      expect(result[:added]).to be false
+      expect(result[:reason]).to eq(:missing_domain)
+    end
+
+    it 'returns error for empty string domain' do
+      result = client.add_generative_model(domain: '')
+      expect(result[:added]).to be false
+      expect(result[:reason]).to eq(:missing_domain)
+    end
+
+    it 'returns model_id on success' do
+      result = client.add_generative_model(domain: :with_id)
+      expect(result[:model_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'rejects duplicate domain' do
+      client.add_generative_model(domain: :dup)
+      result = client.add_generative_model(domain: :dup)
+      expect(result[:added]).to be false
+      expect(result[:reason]).to eq(:already_exists)
+    end
+  end
+
+  describe '#predict_from_model' do
+    before { client.add_generative_model(domain: :action) }
+
+    it 'returns a prediction for known domain' do
+      result = client.predict_from_model(domain: :action, context: {})
+      expect(result[:predicted]).to be true
+    end
+
+    it 'includes domain in result' do
+      result = client.predict_from_model(domain: :action)
+      expect(result[:domain]).to eq(:action)
+    end
+
+    it 'includes prediction hash' do
+      result = client.predict_from_model(domain: :action, context: { val: 1 })
+      expect(result[:prediction]).to be_a(Hash)
+      expect(result[:prediction][:expected_value]).to be_a(Float)
+    end
+
+    it 'returns error for nil domain' do
+      result = client.predict_from_model(domain: nil)
+      expect(result[:predicted]).to be false
+      expect(result[:reason]).to eq(:missing_domain)
+    end
+
+    it 'auto-creates model for unknown domain' do
+      result = client.predict_from_model(domain: :auto_created, context: {})
+      expect(result[:predicted]).to be true
+    end
+  end
+
+  describe '#observe_outcome' do
+    before { client.add_generative_model(domain: :vision) }
+
+    it 'returns observed: true for known domain' do
+      result = client.observe_outcome(domain: :vision, actual: 0.7, predicted: 0.5)
+      expect(result[:observed]).to be true
+    end
+
+    it 'includes inference_mode' do
+      result = client.observe_outcome(domain: :vision, actual: 0.6, predicted: 0.5)
+      expect(Legion::Extensions::Agentic::Inference::PredictiveProcessing::Helpers::Constants::INFERENCE_MODES)
+        .to include(result[:inference_mode])
+    end
+
+    it 'returns error for nil domain' do
+      result = client.observe_outcome(domain: nil, actual: 0.5, predicted: 0.5)
+      expect(result[:observed]).to be false
+      expect(result[:reason]).to eq(:missing_domain)
+    end
+
+    it 'returns false for unknown domain' do
+      result = client.observe_outcome(domain: :unknown_x, actual: 0.5, predicted: 0.5)
+      expect(result[:observed]).to be false
+    end
+
+    it 'includes free_energy in result' do
+      result = client.observe_outcome(domain: :vision, actual: 0.9, predicted: 0.1)
+      expect(result[:free_energy]).to be_a(Float)
+    end
+  end
+
+  describe '#inference_mode' do
+    it 'returns mode for known domain' do
+      client.add_generative_model(domain: :motor)
+      result = client.inference_mode(domain: :motor)
+      expect(result[:domain]).to eq(:motor)
+      expect(Legion::Extensions::Agentic::Inference::PredictiveProcessing::Helpers::Constants::INFERENCE_MODES)
+        .to include(result[:mode])
+    end
+
+    it 'returns error for nil domain' do
+      result = client.inference_mode(domain: nil)
+      expect(result[:mode]).to be_nil
+      expect(result[:reason]).to eq(:missing_domain)
+    end
+
+    it 'returns :perceptual for unknown domain' do
+      result = client.inference_mode(domain: :unregistered)
+      expect(result[:mode]).to eq(:perceptual)
+    end
+  end
+
+  describe '#free_energy' do
+    it 'returns global free energy when no domain given' do
+      result = client.free_energy
+      expect(result).to have_key(:global_free_energy)
+    end
+
+    it 'returns domain free energy when domain given' do
+      client.add_generative_model(domain: :fe_domain)
+      result = client.free_energy(domain: :fe_domain)
+      expect(result[:domain]).to eq(:fe_domain)
+      expect(result[:free_energy]).to be_a(Float)
+    end
+
+    it 'returns not_found for unknown domain' do
+      result = client.free_energy(domain: :no_such)
+      expect(result[:reason]).to eq(:domain_not_found)
+    end
+  end
+
+  describe '#models_needing_update' do
+    it 'returns count and models hash' do
+      result = client.models_needing_update
+      expect(result).to have_key(:count)
+      expect(result).to have_key(:models)
+    end
+
+    it 'returns 0 when no models exist' do
+      expect(client.models_needing_update[:count]).to eq(0)
+    end
+
+    it 'returns surprised models' do
+      client.add_generative_model(domain: :volatile)
+      5.times { client.observe_outcome(domain: :volatile, actual: 1.0, predicted: 0.0) }
+      result = client.models_needing_update
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#active_inference_candidates' do
+    it 'returns count and domains array' do
+      result = client.active_inference_candidates
+      expect(result).to have_key(:count)
+      expect(result).to have_key(:domains)
+    end
+
+    it 'returns 0 when no high-free-energy models' do
+      expect(client.active_inference_candidates[:count]).to eq(0)
+    end
+
+    it 'includes domains with high free energy' do
+      client.add_generative_model(domain: :erratic)
+      5.times { client.observe_outcome(domain: :erratic, actual: 1.0, predicted: 0.0) }
+      result = client.active_inference_candidates
+      expect(result[:domains]).to include(:erratic)
+    end
+  end
+
+  describe '#update_predictive_processing' do
+    it 'ticks the processor' do
+      result = client.update_predictive_processing
+      expect(result[:ticked]).to be true
+    end
+
+    it 'reports model count' do
+      client.add_generative_model(domain: :tracked)
+      result = client.update_predictive_processing
+      expect(result[:model_count]).to eq(1)
+    end
+  end
+
+  describe '#predictive_processing_stats' do
+    it 'returns success: true' do
+      result = client.predictive_processing_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'returns stats hash' do
+      result = client.predictive_processing_stats
+      expect(result[:stats]).to be_a(Hash)
+    end
+
+    it 'includes global_free_energy in stats' do
+      result = client.predictive_processing_stats
+      expect(result[:stats]).to have_key(:global_free_energy)
+    end
+
+    it 'reflects added models in stats' do
+      client.add_generative_model(domain: :counted)
+      result = client.predictive_processing_stats
+      expect(result[:stats][:model_count]).to eq(1)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/reality_testing/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::RealityTesting::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:create_belief)
+    expect(client).to respond_to(:test_belief)
+    expect(client).to respond_to(:get_belief)
+    expect(client).to respond_to(:beliefs_needing_testing)
+    expect(client).to respond_to(:strongest_beliefs)
+    expect(client).to respond_to(:weakest_beliefs)
+    expect(client).to respond_to(:beliefs_by_domain)
+    expect(client).to respond_to(:overall_coherence)
+    expect(client).to respond_to(:decay_beliefs)
+    expect(client).to respond_to(:prune_rejected_beliefs)
+    expect(client).to respond_to(:reality_report)
+    expect(client).to respond_to(:reality_status)
+  end
+
+  it 'maintains isolated state per instance' do
+    client_a = described_class.new
+    client_b = described_class.new
+    client_a.create_belief(claim: 'only in A')
+    expect(client_b.reality_status[:total_beliefs]).to eq(0)
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::RealityTesting::Helpers::Belief do
+  subject(:belief) { described_class.new(id: 'b1', claim: 'The sky is blue', domain: :perception) }
+
+  describe '#initialize' do
+    it 'sets id' do
+      expect(belief.id).to eq('b1')
+    end
+
+    it 'sets claim' do
+      expect(belief.claim).to eq('The sky is blue')
+    end
+
+    it 'sets domain' do
+      expect(belief.domain).to eq(:perception)
+    end
+
+    it 'sets default confidence' do
+      expect(belief.confidence).to eq(0.5)
+    end
+
+    it 'clamps confidence above 1.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 1.5)
+      expect(b.confidence).to eq(1.0)
+    end
+
+    it 'clamps confidence below 0.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: -0.5)
+      expect(b.confidence).to eq(0.0)
+    end
+
+    it 'initializes evidence counts to zero' do
+      expect(belief.evidence_count).to eq(0)
+      expect(belief.confirming_count).to eq(0)
+      expect(belief.disconfirming_count).to eq(0)
+    end
+  end
+
+  describe '#test_with_evidence!' do
+    it 'increments evidence_count for any type' do
+      belief.test_with_evidence!(evidence_type: :confirming)
+      expect(belief.evidence_count).to eq(1)
+    end
+
+    it 'increases confidence for confirming evidence' do
+      before = belief.confidence
+      belief.test_with_evidence!(evidence_type: :confirming)
+      expect(belief.confidence).to be > before
+    end
+
+    it 'decreases confidence for disconfirming evidence' do
+      before = belief.confidence
+      belief.test_with_evidence!(evidence_type: :disconfirming)
+      expect(belief.confidence).to be < before
+    end
+
+    it 'does not change confidence for neutral evidence' do
+      before = belief.confidence
+      belief.test_with_evidence!(evidence_type: :neutral)
+      expect(belief.confidence).to eq(before)
+    end
+
+    it 'nudges confidence toward 0.5 for ambiguous evidence when above' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.8)
+      before = b.confidence
+      b.test_with_evidence!(evidence_type: :ambiguous)
+      expect(b.confidence).to be < before
+    end
+
+    it 'nudges confidence toward 0.5 for ambiguous evidence when below' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.2)
+      before = b.confidence
+      b.test_with_evidence!(evidence_type: :ambiguous)
+      expect(b.confidence).to be > before
+    end
+
+    it 'tracks confirming_count' do
+      belief.test_with_evidence!(evidence_type: :confirming)
+      expect(belief.confirming_count).to eq(1)
+    end
+
+    it 'tracks disconfirming_count' do
+      belief.test_with_evidence!(evidence_type: :disconfirming)
+      expect(belief.disconfirming_count).to eq(1)
+    end
+
+    it 'raises for unknown evidence_type' do
+      expect { belief.test_with_evidence!(evidence_type: :unknown) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns self for chaining' do
+      result = belief.test_with_evidence!(evidence_type: :neutral)
+      expect(result).to be(belief)
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns :certain at 1.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 1.0)
+      expect(b.confidence_label).to eq(:certain)
+    end
+
+    it 'returns :tentative at 0.5' do
+      expect(belief.confidence_label).to eq(:tentative)
+    end
+
+    it 'returns :rejected near 0.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.05)
+      expect(b.confidence_label).to eq(:rejected)
+    end
+  end
+
+  describe '#validity' do
+    it 'returns 0.5 when no evidence' do
+      expect(belief.validity).to eq(0.5)
+    end
+
+    it 'returns 1.0 with only confirming evidence' do
+      3.times { belief.test_with_evidence!(evidence_type: :confirming) }
+      expect(belief.validity).to eq(1.0)
+    end
+
+    it 'returns 0.0 with only disconfirming evidence' do
+      3.times { belief.test_with_evidence!(evidence_type: :disconfirming) }
+      expect(belief.validity).to eq(0.0)
+    end
+
+    it 'returns 0.5 with equal confirming and disconfirming' do
+      belief.test_with_evidence!(evidence_type: :confirming)
+      belief.test_with_evidence!(evidence_type: :disconfirming)
+      expect(belief.validity).to eq(0.5)
+    end
+  end
+
+  describe '#validity_label' do
+    it 'returns :validated with all confirming' do
+      3.times { belief.test_with_evidence!(evidence_type: :confirming) }
+      expect(belief.validity_label).to eq(:validated)
+    end
+
+    it 'returns :refuted with all disconfirming' do
+      3.times { belief.test_with_evidence!(evidence_type: :disconfirming) }
+      expect(belief.validity_label).to eq(:refuted)
+    end
+  end
+
+  describe '#needs_testing?' do
+    it 'returns true at default confidence 0.5' do
+      expect(belief.needs_testing?).to be true
+    end
+
+    it 'returns false at high confidence' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.9)
+      expect(b.needs_testing?).to be false
+    end
+
+    it 'returns false at low confidence' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.1)
+      expect(b.needs_testing?).to be false
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces confidence by CONFIDENCE_DECAY' do
+      before = belief.confidence
+      belief.decay!
+      expect(belief.confidence).to be_within(0.001).of(before - 0.02)
+    end
+
+    it 'floors at 0.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.01)
+      b.decay!
+      expect(b.confidence).to eq(0.0)
+    end
+
+    it 'returns self' do
+      expect(belief.decay!).to be(belief)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = belief.to_h
+      expect(h).to include(
+        :id, :claim, :domain, :confidence, :confidence_label,
+        :evidence_count, :confirming_count, :disconfirming_count,
+        :validity, :validity_label, :needs_testing, :created_at, :last_tested_at
+      )
+    end
+
+    it 'sets last_tested_at after testing' do
+      belief.test_with_evidence!(evidence_type: :confirming)
+      expect(belief.to_h[:last_tested_at]).not_to be_nil
+    end
+  end
+end