lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/prediction/helpers/prediction_store_spec.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Prediction::Helpers::PredictionStore do
+  subject(:store) { described_class.new }
+
+  let(:basic_prediction) do
+    {
+      mode:        :fault_localization,
+      confidence:  0.75,
+      description: 'disk latency spike incoming',
+      status:      :pending
+    }
+  end
+
+  describe '#initialize' do
+    it 'starts with empty predictions hash' do
+      expect(store.predictions).to eq({})
+    end
+
+    it 'starts with empty outcomes array' do
+      expect(store.outcomes).to eq([])
+    end
+  end
+
+  describe '#store' do
+    it 'returns a UUID string' do
+      id = store.store(basic_prediction.dup)
+      expect(id).to match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
+    end
+
+    it 'stores the prediction under the returned id' do
+      id = store.store(basic_prediction.dup)
+      expect(store.predictions[id]).not_to be_nil
+    end
+
+    it 'sets prediction_id on the prediction hash' do
+      prediction = basic_prediction.dup
+      id = store.store(prediction)
+      expect(prediction[:prediction_id]).to eq(id)
+    end
+
+    it 'preserves a caller-supplied prediction_id' do
+      prediction = basic_prediction.merge(prediction_id: 'my-custom-id')
+      returned_id = store.store(prediction)
+      expect(returned_id).to eq('my-custom-id')
+      expect(store.predictions['my-custom-id']).not_to be_nil
+    end
+
+    it 'sets created_at when not supplied' do
+      prediction = basic_prediction.dup
+      before = Time.now.utc
+      store.store(prediction)
+      expect(prediction[:created_at]).to be >= before
+    end
+
+    it 'preserves a caller-supplied created_at' do
+      custom_time = Time.now.utc - 3600
+      prediction  = basic_prediction.merge(created_at: custom_time)
+      store.store(prediction)
+      expect(prediction[:created_at]).to eq(custom_time)
+    end
+
+    it 'sets default status to :pending' do
+      prediction = { mode: :counterfactual, confidence: 0.5 }
+      store.store(prediction)
+      expect(prediction[:status]).to eq(:pending)
+    end
+
+    it 'preserves a caller-supplied status' do
+      prediction = basic_prediction.merge(status: :expired)
+      store.store(prediction)
+      expect(prediction[:status]).to eq(:expired)
+    end
+
+    it 'increments count with each stored prediction' do
+      3.times { store.store(basic_prediction.dup) }
+      expect(store.count).to eq(3)
+    end
+  end
+
+  describe '#get' do
+    it 'retrieves a stored prediction by id' do
+      id = store.store(basic_prediction.dup)
+      result = store.get(id)
+      expect(result[:mode]).to eq(:fault_localization)
+    end
+
+    it 'returns nil for an unknown id' do
+      expect(store.get('no-such-id')).to be_nil
+    end
+  end
+
+  describe '#resolve' do
+    let!(:prediction_id) { store.store(basic_prediction.dup) }
+
+    it 'returns the updated prediction' do
+      result = store.resolve(prediction_id, outcome: :correct)
+      expect(result).to be_a(Hash)
+      expect(result[:prediction_id]).to eq(prediction_id)
+    end
+
+    it 'sets status to the given outcome' do
+      store.resolve(prediction_id, outcome: :incorrect)
+      expect(store.get(prediction_id)[:status]).to eq(:incorrect)
+    end
+
+    it 'sets resolved_at timestamp' do
+      before = Time.now.utc
+      store.resolve(prediction_id, outcome: :correct)
+      expect(store.get(prediction_id)[:resolved_at]).to be >= before
+    end
+
+    it 'stores actual value when provided' do
+      store.resolve(prediction_id, outcome: :partial, actual: 'disk io at 80%')
+      expect(store.get(prediction_id)[:actual]).to eq('disk io at 80%')
+    end
+
+    it 'stores nil actual when not provided' do
+      store.resolve(prediction_id, outcome: :correct)
+      expect(store.get(prediction_id)[:actual]).to be_nil
+    end
+
+    it 'appends to outcomes array' do
+      store.resolve(prediction_id, outcome: :correct)
+      expect(store.outcomes.size).to eq(1)
+    end
+
+    it 'records prediction_id in the outcome entry' do
+      store.resolve(prediction_id, outcome: :correct)
+      expect(store.outcomes.last[:prediction_id]).to eq(prediction_id)
+    end
+
+    it 'records outcome in the outcome entry' do
+      store.resolve(prediction_id, outcome: :incorrect)
+      expect(store.outcomes.last[:outcome]).to eq(:incorrect)
+    end
+
+    it 'returns nil for a non-existent prediction_id' do
+      result = store.resolve('ghost-id', outcome: :correct)
+      expect(result).to be_nil
+    end
+
+    it 'caps outcomes array at 500 entries' do
+      501.times do
+        id = store.store(basic_prediction.dup)
+        store.resolve(id, outcome: :correct)
+      end
+      expect(store.outcomes.size).to eq(500)
+    end
+  end
+
+  describe '#pending' do
+    it 'returns only predictions with status :pending' do
+      id1 = store.store(basic_prediction.dup)
+      id2 = store.store(basic_prediction.dup)
+      store.resolve(id1, outcome: :correct)
+
+      result = store.pending
+      expect(result.size).to eq(1)
+      expect(result.first[:prediction_id]).to eq(id2)
+    end
+
+    it 'returns empty array when no pending predictions' do
+      id = store.store(basic_prediction.dup)
+      store.resolve(id, outcome: :correct)
+      expect(store.pending).to be_empty
+    end
+
+    it 'returns all stored predictions when none are resolved' do
+      3.times { store.store(basic_prediction.dup) }
+      expect(store.pending.size).to eq(3)
+    end
+  end
+
+  describe '#accuracy' do
+    it 'returns 0.0 when no outcomes exist' do
+      expect(store.accuracy).to eq(0.0)
+    end
+
+    it 'returns 1.0 when all outcomes are :correct' do
+      3.times do
+        id = store.store(basic_prediction.dup)
+        store.resolve(id, outcome: :correct)
+      end
+      expect(store.accuracy).to eq(1.0)
+    end
+
+    it 'returns 0.0 when all outcomes are :incorrect' do
+      3.times do
+        id = store.store(basic_prediction.dup)
+        store.resolve(id, outcome: :incorrect)
+      end
+      expect(store.accuracy).to eq(0.0)
+    end
+
+    it 'computes fractional accuracy correctly' do
+      3.times do
+        id = store.store(basic_prediction.dup)
+        store.resolve(id, outcome: :correct)
+      end
+      id = store.store(basic_prediction.dup)
+      store.resolve(id, outcome: :incorrect)
+      expect(store.accuracy).to eq(0.75)
+    end
+
+    it 'defaults window to 100' do
+      102.times do
+        id = store.store(basic_prediction.dup)
+        store.resolve(id, outcome: :incorrect)
+      end
+      2.times do
+        id = store.store(basic_prediction.dup)
+        store.resolve(id, outcome: :correct)
+      end
+      # window=100: last 100 contain 2 correct out of 100 = 0.02
+      expect(store.accuracy(window: 100)).to eq(0.02)
+    end
+
+    it 'accepts a custom window parameter' do
+      5.times do
+        id = store.store(basic_prediction.dup)
+        store.resolve(id, outcome: :incorrect)
+      end
+      5.times do
+        id = store.store(basic_prediction.dup)
+        store.resolve(id, outcome: :correct)
+      end
+      # window=5: last 5 are all :correct
+      expect(store.accuracy(window: 5)).to eq(1.0)
+    end
+
+    it 'ignores non-:correct outcomes in numerator' do
+      id = store.store(basic_prediction.dup)
+      store.resolve(id, outcome: :partial)
+      id = store.store(basic_prediction.dup)
+      store.resolve(id, outcome: :expired)
+      id = store.store(basic_prediction.dup)
+      store.resolve(id, outcome: :correct)
+      expect(store.accuracy).to be_within(0.001).of(1.0 / 3.0)
+    end
+  end
+
+  describe '#count' do
+    it 'returns 0 for a new store' do
+      expect(store.count).to eq(0)
+    end
+
+    it 'returns the total number of stored predictions' do
+      5.times { store.store(basic_prediction.dup) }
+      expect(store.count).to eq(5)
+    end
+
+    it 'counts resolved predictions as well as pending ones' do
+      id = store.store(basic_prediction.dup)
+      store.resolve(id, outcome: :correct)
+      store.store(basic_prediction.dup)
+      expect(store.count).to eq(2)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/prediction/runners/prediction_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/prediction/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Prediction::Runners::Prediction do
+  let(:client) { Legion::Extensions::Agentic::Inference::Prediction::Client.new }
+
+  describe '#predict' do
+    it 'creates a prediction with valid mode' do
+      result = client.predict(mode: :fault_localization, description: 'test')
+      expect(result[:prediction_id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:mode]).to eq(:fault_localization)
+    end
+
+    it 'rejects invalid mode' do
+      result = client.predict(mode: :invalid)
+      expect(result[:error]).to eq(:invalid_mode)
+    end
+
+    it 'marks actionable predictions above confidence threshold' do
+      result = client.predict(mode: :fault_localization, confidence: 0.9)
+      expect(result[:actionable]).to be true
+    end
+
+    it 'marks non-actionable predictions below threshold' do
+      result = client.predict(mode: :counterfactual, confidence: 0.3)
+      expect(result[:actionable]).to be false
+    end
+
+    it 'estimates confidence based on mode' do
+      fault = client.predict(mode: :fault_localization)
+      counterfactual = client.predict(mode: :counterfactual)
+      expect(fault[:confidence]).to be > counterfactual[:confidence]
+    end
+  end
+
+  describe '#resolve_prediction' do
+    it 'resolves a pending prediction' do
+      pred = client.predict(mode: :functional_mapping)
+      result = client.resolve_prediction(prediction_id: pred[:prediction_id], outcome: :correct)
+      expect(result[:resolved]).to be true
+    end
+
+    it 'returns not_found for missing prediction' do
+      result = client.resolve_prediction(prediction_id: 'nonexistent', outcome: :correct)
+      expect(result[:resolved]).to be false
+    end
+  end
+
+  describe '#pending_predictions' do
+    it 'lists pending predictions' do
+      client.predict(mode: :fault_localization)
+      client.predict(mode: :boundary_testing)
+      result = client.pending_predictions
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#expire_stale_predictions' do
+    it 'returns zero expired when no pending predictions' do
+      result = client.expire_stale_predictions
+      expect(result[:expired_count]).to eq(0)
+      expect(result[:remaining_pending]).to eq(0)
+    end
+
+    it 'expires predictions older than their horizon' do
+      client.predict(mode: :fault_localization)
+      client.predict(mode: :boundary_testing)
+
+      # Simulate staleness by back-dating created_at beyond the horizon
+      store = client.send(:prediction_store)
+      store.predictions.each_value do |pred|
+        pred[:created_at] = Time.now.utc - pred[:horizon] - 1
+      end
+
+      result = client.expire_stale_predictions
+      expect(result[:expired_count]).to eq(2)
+      expect(result[:remaining_pending]).to eq(0)
+    end
+
+    it 'preserves predictions that have not exceeded their horizon' do
+      client.predict(mode: :fault_localization)
+      # created_at is just now, horizon is 3600s — not stale
+      result = client.expire_stale_predictions
+      expect(result[:expired_count]).to eq(0)
+      expect(result[:remaining_pending]).to eq(1)
+    end
+
+    it 'only expires stale predictions when mixed with fresh ones' do
+      client.predict(mode: :fault_localization)
+      stale = client.predict(mode: :boundary_testing)
+
+      store = client.send(:prediction_store)
+      stale_pred = store.predictions[stale[:prediction_id]]
+      stale_pred[:created_at] = Time.now.utc - stale_pred[:horizon] - 1
+
+      result = client.expire_stale_predictions
+      expect(result[:expired_count]).to eq(1)
+      expect(result[:remaining_pending]).to eq(1)
+    end
+  end
+
+  describe '#prediction_accuracy' do
+    it 'computes accuracy' do
+      3.times do
+        pred = client.predict(mode: :fault_localization)
+        client.resolve_prediction(prediction_id: pred[:prediction_id], outcome: :correct)
+      end
+      pred = client.predict(mode: :fault_localization)
+      client.resolve_prediction(prediction_id: pred[:prediction_id], outcome: :incorrect)
+
+      result = client.prediction_accuracy
+      expect(result[:accuracy]).to eq(0.75)
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/predictive_coding/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::PredictiveCoding::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:generate_prediction)
+    expect(client).to respond_to(:report_outcome)
+    expect(client).to respond_to(:precision_for)
+    expect(client).to respond_to(:surprising_errors)
+    expect(client).to respond_to(:free_energy_status)
+    expect(client).to respond_to(:active_inference_candidates)
+    expect(client).to respond_to(:register_active_inference)
+    expect(client).to respond_to(:resolve_active_inference)
+    expect(client).to respond_to(:update_predictive_coding)
+    expect(client).to respond_to(:predictive_coding_stats)
+  end
+
+  it 'accepts an injected generative_model' do
+    model = Legion::Extensions::Agentic::Inference::PredictiveCoding::Helpers::GenerativeModel.new
+    custom_client = described_class.new(generative_model: model)
+    expect(custom_client).to respond_to(:generate_prediction)
+  end
+
+  it 'isolates state between separate client instances' do
+    client_a = described_class.new
+    client_b = described_class.new
+
+    client_a.report_outcome(domain: :x, predicted: 0.0, actual: 1.0)
+    result_b = client_b.surprising_errors
+
+    expect(result_b[:count]).to eq(0)
+  end
+
+  describe 'full predictive coding lifecycle' do
+    it 'predicts, reports outcome, then updates stats correctly' do
+      prediction = client.generate_prediction(domain: :proprioception, context: { expected: 0.6 })
+      expect(prediction[:success]).to be true
+
+      outcome = client.report_outcome(domain: :proprioception, predicted: prediction[:predicted], actual: 0.65)
+      expect(outcome[:success]).to be true
+
+      status = client.free_energy_status
+      expect(status[:free_energy]).to be_a(Float)
+
+      stats = client.predictive_coding_stats
+      expect(stats[:model][:domain_count]).to eq(1)
+    end
+
+    it 'runs a full active inference cycle' do
+      reg = client.register_active_inference(
+        domain:           :motor_cortex,
+        action:           :amplify_signal,
+        expected_outcome: 0.75
+      )
+
+      expect(reg[:status]).to eq(:pending)
+
+      resolved = client.resolve_active_inference(
+        domain:         :motor_cortex,
+        action:         :amplify_signal,
+        actual_outcome: 0.78,
+        inference_id:   reg[:inference_id]
+      )
+
+      expect(resolved[:success]).to be true
+
+      after_update = client.update_predictive_coding
+      expect(after_update[:pruned_inferences]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/predictive_coding/helpers/generative_model_spec.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::PredictiveCoding::Helpers::GenerativeModel do
+  let(:model) { described_class.new }
+  let(:constants) { Legion::Extensions::Agentic::Inference::PredictiveCoding::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'assigns a model_id' do
+      expect(model.model_id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts with zero domain models' do
+      expect(model.domain_count).to eq(0)
+    end
+
+    it 'starts with zero errors' do
+      expect(model.error_count).to eq(0)
+    end
+
+    it 'accepts an explicit model_id' do
+      m = described_class.new(model_id: 'custom-id')
+      expect(m.model_id).to eq('custom-id')
+    end
+  end
+
+  describe '#predict' do
+    it 'returns a prediction hash with domain and confidence' do
+      result = model.predict(domain: :vision)
+      expect(result[:domain]).to eq(:vision)
+      expect(result[:predicted]).to be_a(Numeric)
+      expect(result[:confidence]).to be_a(Float)
+    end
+
+    it 'uses DEFAULT_PRECISION for an unknown domain' do
+      result = model.predict(domain: :new_domain)
+      expect(result[:confidence]).to eq(constants::DEFAULT_PRECISION)
+    end
+
+    it 'uses context[:expected] as initial value for unknown domain' do
+      result = model.predict(domain: :touch, context: { expected: 0.9 })
+      expect(result[:predicted]).to be_within(0.001).of(0.9)
+    end
+
+    it 'improves prediction after learning from updates' do
+      5.times { model.update(domain: :sensor, predicted: 0.5, actual: 0.8) }
+      result = model.predict(domain: :sensor)
+      expect(result[:predicted]).to be > 0.5
+    end
+  end
+
+  describe '#update' do
+    it 'returns a PredictionError object' do
+      error = model.update(domain: :vision, predicted: 0.5, actual: 0.9)
+      expect(error).to be_a(Legion::Extensions::Agentic::Inference::PredictiveCoding::Helpers::PredictionError)
+    end
+
+    it 'increments error count' do
+      model.update(domain: :vision, predicted: 0.5, actual: 0.9)
+      expect(model.error_count).to eq(1)
+    end
+
+    it 'creates a domain model entry' do
+      model.update(domain: :vision, predicted: 0.5, actual: 0.9)
+      expect(model.domain_count).to eq(1)
+    end
+
+    it 'adjusts precision downward on high error' do
+      initial = model.precision_for(domain: :vision)
+      model.update(domain: :vision, predicted: 0.0, actual: 1.0)
+      expect(model.precision_for(domain: :vision)).to be < initial
+    end
+
+    it 'adjusts precision upward on zero error' do
+      # First update to initialize the domain
+      model.update(domain: :vision, predicted: 0.5, actual: 0.5)
+      # Second perfect prediction should raise precision
+      after_init = model.precision_for(domain: :vision)
+      model.update(domain: :vision, predicted: 0.5, actual: 0.5)
+      expect(model.precision_for(domain: :vision)).to be >= after_init
+    end
+  end
+
+  describe '#precision_for' do
+    it 'returns DEFAULT_PRECISION for unknown domain' do
+      expect(model.precision_for(domain: :unknown)).to eq(constants::DEFAULT_PRECISION)
+    end
+
+    it 'returns updated precision after updates' do
+      model.update(domain: :motor, predicted: 0.5, actual: 0.5)
+      expect(model.precision_for(domain: :motor)).to be_a(Float)
+    end
+  end
+
+  describe '#free_energy' do
+    it 'returns a float' do
+      expect(model.free_energy).to be_a(Float)
+    end
+
+    it 'increases after surprising errors' do
+      initial = model.free_energy
+      5.times { model.update(domain: :x, predicted: 0.0, actual: 1.0) }
+      expect(model.free_energy).to be > initial
+    end
+  end
+
+  describe '#free_energy_level' do
+    it 'returns a symbol' do
+      expect(model.free_energy_level).to be_a(Symbol)
+    end
+
+    it 'returns :minimal for a fresh model' do
+      expect(model.free_energy_level).to eq(:minimal)
+    end
+  end
+
+  describe '#active_inference_candidates' do
+    it 'returns an empty array for a fresh model' do
+      expect(model.active_inference_candidates).to eq([])
+    end
+
+    it 'returns domains with high error and low precision' do
+      10.times { model.update(domain: :faulty, predicted: 0.0, actual: 1.0) }
+      candidates = model.active_inference_candidates
+      expect(candidates).to include(:faulty)
+    end
+  end
+
+  describe '#surprising_errors' do
+    it 'returns an empty array when no surprising errors' do
+      model.update(domain: :x, predicted: 0.5, actual: 0.5)
+      expect(model.surprising_errors).to be_empty
+    end
+
+    it 'returns errors above the surprise threshold' do
+      model.update(domain: :x, predicted: 0.0, actual: 1.0)
+      expect(model.surprising_errors).not_to be_empty
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decreases precision for all known domains' do
+      model.update(domain: :vision, predicted: 0.8, actual: 0.9)
+      before = model.precision_for(domain: :vision)
+      model.decay_all
+      expect(model.precision_for(domain: :vision)).to be <= before
+    end
+
+    it 'does not drop precision below PRECISION_FLOOR' do
+      50.times { model.decay_all }
+      model.update(domain: :x, predicted: 0.5, actual: 0.5)
+      50.times { model.decay_all }
+      expect(model.precision_for(domain: :x)).to be >= constants::PRECISION_FLOOR
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a summary hash' do
+      h = model.to_h
+      expect(h[:model_id]).to eq(model.model_id)
+      expect(h[:domain_count]).to be_a(Integer)
+      expect(h[:error_count]).to be_a(Integer)
+      expect(h[:free_energy]).to be_a(Float)
+      expect(h[:free_energy_level]).to be_a(Symbol)
+      expect(h[:domains]).to be_an(Array)
+    end
+
+    it 'includes domain stats after updates' do
+      model.update(domain: :vision, predicted: 0.5, actual: 0.7)
+      h = model.to_h
+      expect(h[:domain_count]).to eq(1)
+      vision_stat = h[:domains].find { |d| d[:domain] == :vision }
+      expect(vision_stat).not_to be_nil
+      expect(vision_stat[:mean]).to be_a(Float)
+    end
+  end
+
+  describe 'MAX_MODELS eviction' do
+    it 'does not exceed MAX_MODELS domains' do
+      (constants::MAX_MODELS + 5).times do |i|
+        model.update(domain: :"domain_#{i}", predicted: 0.5, actual: 0.5)
+      end
+      expect(model.domain_count).to be <= constants::MAX_MODELS
+    end
+  end
+
+  describe 'MAX_ERROR_HISTORY cap' do
+    it 'caps error history at MAX_ERROR_HISTORY' do
+      (constants::MAX_ERROR_HISTORY + 10).times do
+        model.update(domain: :x, predicted: 0.5, actual: 0.5)
+      end
+      expect(model.error_count).to be <= constants::MAX_ERROR_HISTORY
+    end
+  end
+end