lex-agentic-inference 0.1.0

data/lib/legion/extensions/agentic/inference/uncertainty_tolerance/helpers/tolerance_engine.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module UncertaintyTolerance
+          module Helpers
+            class ToleranceEngine
+              attr_reader :current_tolerance, :decisions, :history
+
+              def initialize(initial_tolerance: Constants::DEFAULT_TOLERANCE)
+                @current_tolerance = initial_tolerance.clamp(
+                  Constants::TOLERANCE_FLOOR,
+                  Constants::TOLERANCE_CEILING
+                )
+                @decisions = {}
+                @history   = []
+              end
+
+              def tolerance_label
+                Constants::TOLERANCE_LABELS.each do |range, label|
+                  return label if range.cover?(@current_tolerance)
+                end
+                :unknown
+              end
+
+              def record_decision(description:, certainty_level:, domain: :general)
+                decision = Decision.new(
+                  description:       description,
+                  domain:            domain,
+                  certainty_level:   certainty_level,
+                  tolerance_at_time: @current_tolerance
+                )
+                @decisions[decision.id] = decision
+                prune_decisions
+                decision
+              end
+
+              def resolve_decision(decision_id:, outcome:)
+                decision = @decisions[decision_id]
+                return nil unless decision
+
+                decision.resolve!(outcome: outcome)
+                record_history(decision)
+                adapt_tolerance(decision)
+                decision
+              end
+
+              def decisions_under_uncertainty(threshold: nil)
+                cutoff = threshold || @current_tolerance
+                @decisions.values.select { |d| d.certainty_level < cutoff }
+              end
+
+              def successful_uncertain_decisions
+                @decisions.values.select do |d|
+                  d.acted_despite_uncertainty && d.successful?
+                end
+              end
+
+              def risk_profile
+                breakdown = Constants::DECISION_TYPES.to_h { |t| [t, 0] }
+                @decisions.each_value { |d| breakdown[d.decision_type] += 1 }
+                breakdown
+              end
+
+              def domain_tolerance(domain:)
+                resolved = @decisions.values.select do |d|
+                  d.domain == domain && d.successful? && !d.actual_outcome.nil?
+                end
+                return nil if resolved.empty?
+
+                resolved.sum(&:certainty_level) / resolved.size
+              end
+
+              def should_act?(certainty:)
+                certainty >= @current_tolerance
+              end
+
+              def comfort_zone_expansion_rate
+                return 0.0 if @history.size < 2
+
+                tolerances = @history.last(10).map { |h| h[:tolerance_snapshot] }
+                return 0.0 if tolerances.size < 2
+
+                (tolerances.last - tolerances.first) / (tolerances.size - 1).to_f
+              end
+
+              def to_h
+                {
+                  current_tolerance: @current_tolerance,
+                  tolerance_label:   tolerance_label,
+                  total_decisions:   @decisions.size,
+                  risk_profile:      risk_profile,
+                  history_count:     @history.size
+                }
+              end
+
+              private
+
+              def adapt_tolerance(decision)
+                return unless decision.acted_despite_uncertainty
+
+                delta = if decision.successful?
+                          Constants::POSITIVE_OUTCOME_BOOST
+                        else
+                          -Constants::NEGATIVE_OUTCOME_PENALTY
+                        end
+
+                @current_tolerance = (@current_tolerance + delta).clamp(
+                  Constants::TOLERANCE_FLOOR,
+                  Constants::TOLERANCE_CEILING
+                )
+              end
+
+              def record_history(decision)
+                @history << {
+                  decision_id:        decision.id,
+                  outcome:            decision.actual_outcome,
+                  certainty_level:    decision.certainty_level,
+                  tolerance_snapshot: @current_tolerance,
+                  recorded_at:        Time.now.utc
+                }
+                @history.shift while @history.size > Constants::MAX_HISTORY
+              end
+
+              def prune_decisions
+                return unless @decisions.size > Constants::MAX_DECISIONS
+
+                oldest_keys = @decisions.keys.first(@decisions.size - Constants::MAX_DECISIONS)
+                oldest_keys.each { |k| @decisions.delete(k) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module UncertaintyTolerance
+          module Runners
+            module UncertaintyTolerance
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def record_uncertain_decision(description:, certainty_level:, domain: :general, **)
+                decision = engine.record_decision(
+                  description:     description,
+                  domain:          domain,
+                  certainty_level: certainty_level
+                )
+                Legion::Logging.debug "[uncertainty_tolerance] recorded decision: id=#{decision.id[0..7]} " \
+                                      "domain=#{domain} certainty=#{certainty_level.round(2)} " \
+                                      "type=#{decision.decision_type}"
+                {
+                  decision_id:               decision.id,
+                  domain:                    domain,
+                  certainty_level:           certainty_level,
+                  decision_type:             decision.decision_type,
+                  acted_despite_uncertainty: decision.acted_despite_uncertainty,
+                  current_tolerance:         engine.current_tolerance
+                }
+              end
+
+              def resolve_uncertain_decision(decision_id:, outcome:, **)
+                decision = engine.resolve_decision(decision_id: decision_id, outcome: outcome)
+                unless decision
+                  Legion::Logging.debug "[uncertainty_tolerance] resolve failed: #{decision_id[0..7]} not found"
+                  return { resolved: false, reason: :not_found }
+                end
+
+                Legion::Logging.info "[uncertainty_tolerance] resolved: id=#{decision_id[0..7]} " \
+                                     "outcome=#{outcome} tolerance=#{engine.current_tolerance.round(3)}"
+                {
+                  resolved:          true,
+                  decision_id:       decision_id,
+                  outcome:           outcome,
+                  current_tolerance: engine.current_tolerance,
+                  tolerance_label:   engine.tolerance_label
+                }
+              end
+
+              def should_act_assessment(certainty:, **)
+                act = engine.should_act?(certainty: certainty)
+                gap = (certainty - engine.current_tolerance).round(3)
+                Legion::Logging.debug "[uncertainty_tolerance] should_act? certainty=#{certainty.round(2)} " \
+                                      "tolerance=#{engine.current_tolerance.round(2)} act=#{act}"
+                {
+                  should_act:        act,
+                  certainty:         certainty,
+                  current_tolerance: engine.current_tolerance,
+                  tolerance_label:   engine.tolerance_label,
+                  gap:               gap
+                }
+              end
+
+              def uncertainty_profile(**)
+                profile = engine.to_h
+                Legion::Logging.debug "[uncertainty_tolerance] profile: tolerance=#{profile[:current_tolerance].round(3)} " \
+                                      "label=#{profile[:tolerance_label]} decisions=#{profile[:total_decisions]}"
+                profile
+              end
+
+              def decisions_under_uncertainty_report(threshold: nil, **)
+                decisions = engine.decisions_under_uncertainty(threshold: threshold)
+                Legion::Logging.debug "[uncertainty_tolerance] under_uncertainty: count=#{decisions.size}"
+                {
+                  decisions: decisions.map(&:to_h),
+                  count:     decisions.size,
+                  threshold: threshold || engine.current_tolerance
+                }
+              end
+
+              def domain_tolerance_report(domain:, **)
+                avg = engine.domain_tolerance(domain: domain)
+                Legion::Logging.debug "[uncertainty_tolerance] domain_tolerance: domain=#{domain} avg=#{avg&.round(3)}"
+                {
+                  domain:            domain,
+                  average_certainty: avg,
+                  found:             !avg.nil?
+                }
+              end
+
+              def update_uncertainty_tolerance(tolerance:, **)
+                clamped = tolerance.clamp(
+                  Helpers::Constants::TOLERANCE_FLOOR,
+                  Helpers::Constants::TOLERANCE_CEILING
+                )
+                engine.instance_variable_set(:@current_tolerance, clamped)
+                Legion::Logging.info "[uncertainty_tolerance] tolerance updated: #{clamped.round(3)} " \
+                                     "label=#{engine.tolerance_label}"
+                {
+                  updated:           true,
+                  current_tolerance: clamped,
+                  tolerance_label:   engine.tolerance_label
+                }
+              end
+
+              def uncertainty_tolerance_stats(**)
+                {
+                  current_tolerance:           engine.current_tolerance,
+                  tolerance_label:             engine.tolerance_label,
+                  total_decisions:             engine.decisions.size,
+                  successful_uncertain_count:  engine.successful_uncertain_decisions.size,
+                  risk_profile:                engine.risk_profile,
+                  comfort_zone_expansion_rate: engine.comfort_zone_expansion_rate,
+                  history_count:               engine.history.size
+                }
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::ToleranceEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/version'
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/helpers/constants'
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/helpers/decision'
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/helpers/tolerance_engine'
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/runners/uncertainty_tolerance'
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module UncertaintyTolerance
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'inference/version'
+require_relative 'inference/coherence'
+require_relative 'inference/debugging'
+require_relative 'inference/horizon'
+require_relative 'inference/gravity'
+require_relative 'inference/momentum'
+require_relative 'inference/abductive'
+require_relative 'inference/analogical'
+require_relative 'inference/argument_mapping'
+require_relative 'inference/bayesian'
+require_relative 'inference/belief_revision'
+require_relative 'inference/causal_attribution'
+require_relative 'inference/causal_reasoning'
+require_relative 'inference/counterfactual'
+require_relative 'inference/hypothesis_testing'
+require_relative 'inference/prediction'
+require_relative 'inference/predictive_coding'
+require_relative 'inference/predictive_processing'
+require_relative 'inference/free_energy'
+require_relative 'inference/intuition'
+require_relative 'inference/schema'
+require_relative 'inference/expectation_violation'
+require_relative 'inference/uncertainty_tolerance'
+require_relative 'inference/reality_testing'
+require_relative 'inference/affordance'
+require_relative 'inference/enactive_cognition'
+require_relative 'inference/perceptual_inference'
+require_relative 'inference/magnet'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+
+        def remote_invocable?
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/abductive/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Abductive::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:record_observation)
+    expect(client).to respond_to(:generate_hypothesis)
+    expect(client).to respond_to(:evaluate_hypothesis)
+    expect(client).to respond_to(:add_hypothesis_evidence)
+    expect(client).to respond_to(:best_explanation)
+    expect(client).to respond_to(:competing_hypotheses)
+    expect(client).to respond_to(:refute_hypothesis)
+    expect(client).to respond_to(:unexplained_observations)
+    expect(client).to respond_to(:update_abductive_reasoning)
+    expect(client).to respond_to(:abductive_reasoning_stats)
+  end
+
+  it 'accepts a custom engine' do
+    custom_engine = Legion::Extensions::Agentic::Inference::Abductive::Helpers::AbductionEngine.new
+    client = described_class.new(engine: custom_engine)
+    expect(client).to be_a(described_class)
+  end
+end