lex-agentic-inference 0.1.0

data/lib/legion/extensions/agentic/inference/perceptual_inference/runners/perceptual_inference.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PerceptualInference
+          module Runners
+            module PerceptualInference
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def register_percept_hypothesis(content:, modality:, domain: :general, prior: Helpers::DEFAULT_PRIOR, **)
+                hypothesis = field.register_hypothesis(content: content, modality: modality, domain: domain, prior: prior)
+                Legion::Logging.debug "[perceptual_inference] registered hypothesis modality=#{modality} id=#{hypothesis.id[0..7]}"
+                { success: true, hypothesis_id: hypothesis.id, modality: modality, prior: hypothesis.prior }
+              rescue ArgumentError => e
+                Legion::Logging.warn "[perceptual_inference] register failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def present_perceptual_evidence(modality:, content:, strength: 0.5, **)
+                count = field.present_evidence(modality: modality, content: content, strength: strength)
+                Legion::Logging.debug "[perceptual_inference] evidence presented modality=#{modality} strength=#{strength} updated=#{count}"
+                { success: true, modality: modality, hypotheses_updated: count, rivalry: field.rivalry?(modality: modality) }
+              rescue ArgumentError => e
+                Legion::Logging.warn "[perceptual_inference] evidence failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def select_percept(modality:, **)
+                winner = field.select_percept(modality: modality)
+                if winner
+                  Legion::Logging.info "[perceptual_inference] percept selected modality=#{modality} " \
+                                       "posterior=#{winner.posterior.round(3)} label=#{winner.percept_label}"
+                  { success: true, selected: true, hypothesis: winner.to_h }
+                else
+                  rivalry = field.rivalry?(modality: modality)
+                  Legion::Logging.debug "[perceptual_inference] no percept selected modality=#{modality} rivalry=#{rivalry}"
+                  { success: true, selected: false, rivalry: rivalry }
+                end
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def check_rivalry(modality:, **)
+                rival = field.rivalry?(modality: modality)
+                candidates = field.hypotheses_for(modality)
+                top_two    = candidates.select { |h| %i[active selected].include?(h.state) }.max_by(2, &:posterior)
+                Legion::Logging.debug "[perceptual_inference] rivalry check modality=#{modality} rival=#{rival}"
+                { success: true, rivalry: rival, modality: modality, top_hypotheses: top_two.map(&:to_h) }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def current_percept(modality:, **)
+                percept = field.current_percept(modality: modality)
+                if percept
+                  { success: true, found: true, modality: modality, percept: percept.to_h }
+                else
+                  { success: true, found: false, modality: modality }
+                end
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def adapt_perception(modality:, correct_hypothesis_id:, **)
+                field.adapt_priors(modality: modality, correct_hypothesis_id: correct_hypothesis_id)
+                Legion::Logging.info "[perceptual_inference] priors adapted modality=#{modality} correct=#{correct_hypothesis_id[0..7]}"
+                { success: true, modality: modality, correct_hypothesis_id: correct_hypothesis_id }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def suppress_percept(hypothesis_id:, **)
+                suppressed = field.suppress_hypothesis(hypothesis_id: hypothesis_id)
+                Legion::Logging.debug "[perceptual_inference] suppress hypothesis_id=#{hypothesis_id[0..7]} result=#{suppressed}"
+                { success: true, suppressed: suppressed, hypothesis_id: hypothesis_id }
+              end
+
+              def perceptual_ambiguity(**)
+                level = field.ambiguity_level
+                label = ambiguity_label(level)
+                Legion::Logging.debug "[perceptual_inference] ambiguity=#{level.round(3)} label=#{label}"
+                { success: true, ambiguity_level: level, label: label }
+              end
+
+              def update_perceptual_inference(**)
+                field.decay_all
+                Legion::Logging.debug "[perceptual_inference] decay cycle complete remaining=#{field.hypotheses.size}"
+                { success: true, remaining_hypotheses: field.hypotheses.size }
+              end
+
+              def perceptual_inference_stats(**)
+                { success: true, stats: field.to_h }
+              end
+
+              private
+
+              def field
+                @field ||= Helpers::PerceptualField.new
+              end
+
+              def ambiguity_label(level)
+                if level >= 0.75
+                  :high
+                elsif level >= 0.4
+                  :moderate
+                elsif level.positive?
+                  :low
+                else
+                  :none
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/perceptual_inference/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PerceptualInference
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/perceptual_inference.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/perceptual_inference/version'
+require 'legion/extensions/agentic/inference/perceptual_inference/helpers/constants'
+require 'legion/extensions/agentic/inference/perceptual_inference/helpers/perceptual_hypothesis'
+require 'legion/extensions/agentic/inference/perceptual_inference/helpers/perceptual_field'
+require 'legion/extensions/agentic/inference/perceptual_inference/runners/perceptual_inference'
+require 'legion/extensions/agentic/inference/perceptual_inference/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PerceptualInference
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/prediction/actors/expire_predictions.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Prediction
+          module Actor
+            class ExpirePredictions < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Inference::Prediction::Runners::Prediction
+              end
+
+              def runner_function
+                'expire_stale_predictions'
+              end
+
+              def time
+                300
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/prediction/client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/prediction/helpers/modes'
+require 'legion/extensions/agentic/inference/prediction/helpers/prediction_store'
+require 'legion/extensions/agentic/inference/prediction/runners/prediction'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Prediction
+          class Client
+            include Runners::Prediction
+
+            def initialize(**)
+              @prediction_store = Helpers::PredictionStore.new
+            end
+
+            private
+
+            attr_reader :prediction_store
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/prediction/helpers/modes.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Prediction
+          module Helpers
+            module Modes
+              # Four reasoning modes (spec: prediction-engine-spec.md)
+              REASONING_MODES = %i[fault_localization functional_mapping boundary_testing counterfactual].freeze
+
+              PREDICTION_CONFIDENCE_MIN = 0.65
+              MAX_PREDICTIONS_PER_TICK  = 5
+              PREDICTION_HORIZON        = 3600 # 1 hour default lookahead
+
+              module_function
+
+              def valid_mode?(mode)
+                REASONING_MODES.include?(mode)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/prediction/helpers/prediction_store.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Prediction
+          module Helpers
+            class PredictionStore
+              attr_reader :predictions, :outcomes
+
+              def initialize
+                @predictions = {}
+                @outcomes = []
+              end
+
+              def store(prediction)
+                id = prediction[:prediction_id] || SecureRandom.uuid
+                prediction[:prediction_id] = id
+                prediction[:created_at] ||= Time.now.utc
+                prediction[:status] ||= :pending
+                @predictions[id] = prediction
+                id
+              end
+
+              def get(prediction_id)
+                @predictions[prediction_id]
+              end
+
+              def resolve(prediction_id, outcome:, actual: nil)
+                pred = @predictions[prediction_id]
+                return nil unless pred
+
+                pred[:status] = outcome # :correct, :incorrect, :partial, :expired
+                pred[:resolved_at] = Time.now.utc
+                pred[:actual] = actual
+
+                @outcomes << { prediction_id: prediction_id, outcome: outcome, at: Time.now.utc }
+                @outcomes.shift while @outcomes.size > 500
+                pred
+              end
+
+              def pending
+                @predictions.values.select { |p| p[:status] == :pending }
+              end
+
+              def accuracy(window: 100)
+                recent = @outcomes.last(window)
+                return 0.0 if recent.empty?
+
+                correct = recent.count { |o| o[:outcome] == :correct }
+                correct.to_f / recent.size
+              end
+
+              def count
+                @predictions.size
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/prediction/runners/prediction.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Prediction
+          module Runners
+            module Prediction
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def predict(mode:, context: {}, confidence: nil, description: nil, **)
+                return { error: :invalid_mode, valid_modes: Helpers::Modes::REASONING_MODES } unless Helpers::Modes.valid_mode?(mode)
+
+                prediction = {
+                  prediction_id: SecureRandom.uuid,
+                  mode:          mode,
+                  context:       context,
+                  confidence:    confidence || estimate_confidence(mode, context),
+                  description:   description,
+                  status:        :pending,
+                  created_at:    Time.now.utc,
+                  horizon:       Helpers::Modes::PREDICTION_HORIZON
+                }
+
+                prediction_store.store(prediction)
+
+                actionable = prediction[:confidence] >= Helpers::Modes::PREDICTION_CONFIDENCE_MIN
+                Legion::Logging.debug "[prediction] new: mode=#{mode} confidence=#{prediction[:confidence].round(2)} " \
+                                      "actionable=#{actionable} id=#{prediction[:prediction_id][0..7]}"
+
+                {
+                  prediction_id: prediction[:prediction_id],
+                  mode:          mode,
+                  confidence:    prediction[:confidence],
+                  actionable:    actionable
+                }
+              end
+
+              def resolve_prediction(prediction_id:, outcome:, actual: nil, **)
+                pred = prediction_store.resolve(prediction_id, outcome: outcome, actual: actual)
+                if pred
+                  Legion::Logging.info "[prediction] resolved #{prediction_id[0..7]} outcome=#{outcome}"
+                  record_outcome_trace(pred, outcome)
+                  { resolved: true, prediction_id: prediction_id, outcome: outcome }
+                else
+                  Legion::Logging.debug "[prediction] resolve failed: #{prediction_id[0..7]} not found"
+                  { resolved: false, reason: :not_found }
+                end
+              end
+
+              def pending_predictions(**)
+                preds = prediction_store.pending
+                Legion::Logging.debug "[prediction] pending count=#{preds.size}"
+                { predictions: preds, count: preds.size }
+              end
+
+              def prediction_accuracy(window: 100, **)
+                acc = prediction_store.accuracy(window: window)
+                total = prediction_store.outcomes.size
+                Legion::Logging.debug "[prediction] accuracy=#{acc.round(2)} total_outcomes=#{total}"
+                { accuracy: acc, total_outcomes: total }
+              end
+
+              def expire_stale_predictions(**)
+                expired_count = 0
+
+                prediction_store.pending.each do |pred|
+                  age = Time.now.utc - pred[:created_at]
+                  next unless age > pred[:horizon]
+
+                  prediction_store.resolve(pred[:prediction_id], outcome: :expired, actual: nil)
+                  expired_count += 1
+                end
+
+                remaining = prediction_store.pending.size
+                Legion::Logging.debug "[prediction] expire sweep: expired=#{expired_count} remaining=#{remaining}"
+
+                { expired_count: expired_count, remaining_pending: remaining }
+              end
+
+              def get_prediction(prediction_id:, **)
+                pred = prediction_store.get(prediction_id)
+                pred ? { found: true, prediction: pred } : { found: false }
+              end
+
+              private
+
+              def prediction_store
+                @prediction_store ||= Helpers::PredictionStore.new
+              end
+
+              def estimate_confidence(mode, context)
+                base = case mode
+                       when :fault_localization then 0.7
+                       when :functional_mapping then 0.6
+                       when :counterfactual     then 0.4
+                       else                          0.5
+                       end
+                richness_bonus = [context.size * 0.02, 0.2].min
+                [base + richness_bonus, 1.0].min
+              end
+
+              def record_outcome_trace(prediction, outcome)
+                return unless defined?(Legion::Extensions::Memory::Runners::Traces)
+
+                trace_params = case outcome
+                               when :correct
+                                 { type: :semantic, valence: 0.3, intensity: 0.3, unresolved: false }
+                               when :incorrect
+                                 { type: :episodic, valence: -0.5, intensity: 0.6, unresolved: true }
+                               when :partial
+                                 { type: :episodic, valence: -0.2, intensity: 0.4, unresolved: true }
+                               else
+                                 return
+                               end
+
+                runner = Object.new.extend(Legion::Extensions::Memory::Runners::Traces)
+                runner.store_trace(
+                  type:                trace_params[:type],
+                  content_payload:     "prediction #{outcome}: mode=#{prediction[:mode]} confidence=#{prediction[:confidence]}",
+                  domain_tags:         ['prediction', prediction[:mode].to_s],
+                  origin:              :direct_experience,
+                  emotional_valence:   trace_params[:valence],
+                  emotional_intensity: trace_params[:intensity],
+                  unresolved:          trace_params[:unresolved],
+                  confidence:          prediction[:confidence]
+                )
+
+                store = runner.send(:default_store)
+                store.flush if store.respond_to?(:flush)
+
+                Legion::Logging.debug "[prediction] created #{trace_params[:type]} trace for #{outcome} prediction"
+              rescue StandardError => e
+                Legion::Logging.warn "[prediction] failed to create outcome trace: #{e.message}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/prediction/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Prediction
+          VERSION = '0.1.1'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/prediction.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/prediction/version'
+require 'legion/extensions/agentic/inference/prediction/helpers/modes'
+require 'legion/extensions/agentic/inference/prediction/helpers/prediction_store'
+require 'legion/extensions/agentic/inference/prediction/runners/prediction'
+require 'legion/extensions/agentic/inference/prediction/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Prediction
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/predictive_coding/actors/decay.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PredictiveCoding
+          module Actor
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Inference::PredictiveCoding::Runners::PredictiveCoding
+              end
+
+              def runner_function
+                'update_predictive_coding'
+              end
+
+              def time
+                60
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/predictive_coding/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/predictive_coding/helpers/constants'
+require 'legion/extensions/agentic/inference/predictive_coding/helpers/prediction_error'
+require 'legion/extensions/agentic/inference/predictive_coding/helpers/generative_model'
+require 'legion/extensions/agentic/inference/predictive_coding/runners/predictive_coding'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PredictiveCoding
+          class Client
+            include Runners::PredictiveCoding
+
+            def initialize(generative_model: nil, **)
+              @generative_model = generative_model || Helpers::GenerativeModel.new
+            end
+
+            private
+
+            attr_reader :generative_model
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/predictive_coding/helpers/constants.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module PredictiveCoding
+          module Helpers
+            module Constants
+              MAX_PREDICTIONS    = 200
+              MAX_ERROR_HISTORY  = 500
+              MAX_MODELS         = 20
+              DEFAULT_PRECISION  = 0.5
+              PRECISION_FLOOR    = 0.05
+              PRECISION_ALPHA    = 0.12  # EMA for precision updates
+              ERROR_ALPHA        = 0.15  # EMA for prediction error smoothing
+              MODEL_LEARNING_RATE = 0.1
+              FREE_ENERGY_ALPHA  = 0.1   # EMA for free energy tracking
+              COMPLEXITY_PENALTY = 0.05  # penalizes overly complex models
+              PREDICTION_DECAY   = 0.01
+              PRECISION_DECAY    = 0.005
+              MAX_ACTIVE_INFERENCES = 50
+              SURPRISE_THRESHOLD = 0.7   # above this, prediction error is "surprising"
+
+              PREDICTION_ERROR_LEVELS = {
+                negligible: 0.0..0.1,
+                low:        0.1..0.3,
+                moderate:   0.3..0.5,
+                high:       0.5..0.7,
+                surprising: 0.7..1.0
+              }.freeze
+
+              FREE_ENERGY_LEVELS = {
+                minimal:  0.0..0.2,
+                low:      0.2..0.4,
+                moderate: 0.4..0.6,
+                elevated: 0.6..0.8,
+                critical: 0.8..Float::INFINITY
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end