lex-agentic-inference 0.1.0

data/lib/legion/extensions/agentic/inference/horizon/runners/cognitive_horizon.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Horizon
+          module Runners
+            module CognitiveHorizon
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def get_horizon(**)
+                report = horizon_engine.horizon_report
+                Legion::Logging.debug "[cognitive_horizon] get_horizon: effective=#{report[:effective_horizon].round(2)} construal=#{report[:construal_label]}"
+                { found: true, horizon: report }
+              end
+
+              def expand_horizon(amount: nil, **)
+                amt    = amount || Helpers::Constants::HORIZON_EXPAND
+                before = horizon_engine.current_horizon
+                after  = horizon_engine.expand_horizon!(amount: amt)
+                Legion::Logging.info "[cognitive_horizon] expand: #{before.round(2)} -> #{after.round(2)} (amount=#{amt})"
+                { expanded: true, before: before.round(10), after: after.round(10), amount: amt }
+              end
+
+              def contract_horizon(amount: nil, **)
+                amt    = amount || Helpers::Constants::HORIZON_CONTRACT
+                before = horizon_engine.current_horizon
+                after  = horizon_engine.contract_horizon!(amount: amt)
+                Legion::Logging.info "[cognitive_horizon] contract: #{before.round(2)} -> #{after.round(2)} (amount=#{amt})"
+                { contracted: true, before: before.round(10), after: after.round(10), amount: amt }
+              end
+
+              def apply_stress(level:, **)
+                before = horizon_engine.current_horizon
+                after  = horizon_engine.apply_stress!(level)
+                Legion::Logging.info "[cognitive_horizon] stress applied: level=#{level} horizon #{before.round(2)} -> #{after.round(2)}"
+                {
+                  stress_applied: true,
+                  stress_level:   level,
+                  before:         before.round(10),
+                  after:          after.round(10)
+                }
+              end
+
+              def relieve_stress(amount: nil, **)
+                amt    = amount || 0.1
+                before = horizon_engine.stress_level
+                horizon_engine.relieve_stress!(amount: amt)
+                after = horizon_engine.stress_level
+                Legion::Logging.debug "[cognitive_horizon] relieve_stress: #{before.round(2)} -> #{after.round(2)}"
+                { relieved: true, before: before.round(10), after: after.round(10), amount: amt }
+              end
+
+              def add_projection(description:, domain: :general, horizon_distance: nil, confidence: 1.0, **)
+                proj = horizon_engine.add_projection(
+                  description:      description,
+                  domain:           domain,
+                  horizon_distance: horizon_distance,
+                  confidence:       confidence
+                )
+                msg = "[cognitive_horizon] add_projection: id=#{proj.id} distance=#{proj.horizon_distance.round(2)} construal=#{proj.construal_level}"
+                Legion::Logging.debug msg
+                proj.to_h
+              end
+
+              def projections_within_horizon(**)
+                within = horizon_engine.projections_within_horizon
+                Legion::Logging.debug "[cognitive_horizon] within_horizon: count=#{within.size} effective=#{horizon_engine.effective_horizon.round(2)}"
+                { count: within.size, projections: within.map(&:to_h), effective_horizon: horizon_engine.effective_horizon.round(10) }
+              end
+
+              def beyond_horizon_projections(**)
+                beyond = horizon_engine.beyond_horizon_projections
+                Legion::Logging.debug "[cognitive_horizon] beyond_horizon: count=#{beyond.size}"
+                { count: beyond.size, projections: beyond.map(&:to_h), effective_horizon: horizon_engine.effective_horizon.round(10) }
+              end
+
+              def nearest_projections(count: 5, **)
+                projs = horizon_engine.nearest_projections(num: count)
+                Legion::Logging.debug "[cognitive_horizon] nearest_projections: count=#{count} returned=#{projs.size}"
+                { count: projs.size, projections: projs.map(&:to_h) }
+              end
+
+              def farthest_projections(count: 5, **)
+                projs = horizon_engine.farthest_projections(num: count)
+                Legion::Logging.debug "[cognitive_horizon] farthest_projections: count=#{count} returned=#{projs.size}"
+                { count: projs.size, projections: projs.map(&:to_h) }
+              end
+
+              def horizon_status(**)
+                { total_projections: horizon_engine.projections.size, report: horizon_engine.horizon_report }
+              end
+
+              private
+
+              def horizon_engine
+                @horizon_engine ||= Helpers::HorizonEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/horizon/version'
+require 'legion/extensions/agentic/inference/horizon/helpers/constants'
+require 'legion/extensions/agentic/inference/horizon/helpers/projection'
+require 'legion/extensions/agentic/inference/horizon/helpers/horizon_engine'
+require 'legion/extensions/agentic/inference/horizon/runners/cognitive_horizon'
+require 'legion/extensions/agentic/inference/horizon/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Horizon
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/constants'
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis'
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis_engine'
+require 'legion/extensions/agentic/inference/hypothesis_testing/runners/hypothesis_testing'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module HypothesisTesting
+          class Client
+            include Runners::HypothesisTesting
+
+            def initialize(**)
+              @hypothesis_engine = Helpers::HypothesisEngine.new
+            end
+
+            private
+
+            attr_reader :hypothesis_engine
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module HypothesisTesting
+          module Helpers
+            module Constants
+              MAX_HYPOTHESES             = 300
+              CONFIRMATION_THRESHOLD     = 0.8
+              DISCONFIRMATION_THRESHOLD  = 0.2
+              EVIDENCE_WEIGHT            = 0.1
+              PRIOR_DEFAULT              = 0.5
+
+              STATUS_LABELS = {
+                proposed:     'Proposed',
+                testing:      'Testing',
+                confirmed:    'Confirmed',
+                disconfirmed: 'Disconfirmed',
+                inconclusive: 'Inconclusive'
+              }.freeze
+
+              CONFIDENCE_LABELS = [
+                [0.9..1.0,  'certain'],
+                [0.7...0.9, 'confident'],
+                [0.5...0.7, 'leaning'],
+                [0.3...0.5, 'uncertain'],
+                [0.0...0.3, 'agnostic']
+              ].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module HypothesisTesting
+          module Helpers
+            class Hypothesis
+              include Constants
+
+              attr_reader :id, :description, :domain, :prior, :posterior,
+                          :evidence_count, :status, :created_at
+
+              def initialize(description:, domain: 'general', prior: Constants::PRIOR_DEFAULT)
+                @id             = SecureRandom.uuid
+                @description    = description
+                @domain         = domain
+                @prior          = prior.clamp(0.0, 1.0)
+                @posterior      = @prior
+                @evidence_count = 0
+                @status         = :proposed
+                @created_at     = Time.now.utc
+              end
+
+              def update_posterior!(evidence_strength:, supporting: true)
+                return self if @status == :confirmed || @status == :disconfirmed
+
+                @status = :testing
+                weight  = Constants::EVIDENCE_WEIGHT * evidence_strength.clamp(0.0, 1.0)
+
+                @posterior = if supporting
+                               @posterior + (weight * (1.0 - @posterior))
+                             else
+                               @posterior - (weight * @posterior)
+                             end
+
+                @posterior = @posterior.clamp(0.0, 1.0).round(10)
+                @evidence_count += 1
+                self
+              end
+
+              def confirm!
+                @status    = :confirmed
+                @posterior = [@posterior, Constants::CONFIRMATION_THRESHOLD].max.round(10)
+                self
+              end
+
+              def disconfirm!
+                @status    = :disconfirmed
+                @posterior = [@posterior, Constants::DISCONFIRMATION_THRESHOLD].min.round(10)
+                self
+              end
+
+              def confidence_label
+                Constants::CONFIDENCE_LABELS.each do |range, label|
+                  return label if range.cover?(@posterior)
+                end
+                'agnostic'
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  description:      @description,
+                  domain:           @domain,
+                  prior:            @prior,
+                  posterior:        @posterior,
+                  evidence_count:   @evidence_count,
+                  status:           @status,
+                  confidence_label: confidence_label,
+                  created_at:       @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis_engine.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module HypothesisTesting
+          module Helpers
+            class HypothesisEngine
+              include Constants
+
+              attr_reader :hypotheses
+
+              def initialize
+                @hypotheses = {}
+              end
+
+              def propose(description:, domain: 'general', prior: Constants::PRIOR_DEFAULT)
+                evict_oldest! if @hypotheses.size >= Constants::MAX_HYPOTHESES
+
+                h = Hypothesis.new(description: description, domain: domain, prior: prior)
+                @hypotheses[h.id] = h
+                h
+              end
+
+              def test_hypothesis(hypothesis_id:, evidence_strength:, supporting: true)
+                h = @hypotheses[hypothesis_id]
+                return nil unless h
+
+                h.update_posterior!(evidence_strength: evidence_strength, supporting: supporting)
+                evaluate(hypothesis_id)
+                h
+              end
+
+              def evaluate(hypothesis_id)
+                h = @hypotheses[hypothesis_id]
+                return nil unless h
+                return h if %i[confirmed disconfirmed].include?(h.status)
+
+                if h.posterior >= Constants::CONFIRMATION_THRESHOLD
+                  h.confirm!
+                elsif h.posterior <= Constants::DISCONFIRMATION_THRESHOLD
+                  h.disconfirm!
+                else
+                  h
+                end
+              end
+
+              def competing_hypotheses(domain:)
+                @hypotheses.values.select { |h| h.domain == domain }
+              end
+
+              def most_confident(limit: 5)
+                @hypotheses.values
+                           .sort_by { |h| -h.posterior }
+                           .first(limit)
+              end
+
+              def confirmation_rate
+                total = @hypotheses.values.count { |h| %i[confirmed disconfirmed].include?(h.status) }
+                return 0.0 if total.zero?
+
+                confirmed = @hypotheses.values.count { |h| h.status == :confirmed }
+                (confirmed.to_f / total).round(10)
+              end
+
+              def hypothesis_report
+                by_status = @hypotheses.values.group_by(&:status).transform_values(&:count)
+                {
+                  total:             @hypotheses.size,
+                  by_status:         by_status,
+                  confirmation_rate: confirmation_rate,
+                  most_confident:    most_confident(limit: 3).map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  hypotheses:        @hypotheses.values.map(&:to_h),
+                  confirmation_rate: confirmation_rate,
+                  total:             @hypotheses.size
+                }
+              end
+
+              private
+
+              def evict_oldest!
+                oldest_key = @hypotheses.min_by { |_, h| h.created_at }&.first
+                @hypotheses.delete(oldest_key) if oldest_key
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module HypothesisTesting
+          module Runners
+            module HypothesisTesting
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def propose_hypothesis(description:, domain: 'general', prior: Helpers::Constants::PRIOR_DEFAULT, **)
+                h = hypothesis_engine.propose(description: description, domain: domain, prior: prior)
+                Legion::Logging.debug "[hypothesis_testing] proposed id=#{h.id[0..7]} domain=#{domain} prior=#{prior}"
+                {
+                  hypothesis_id:    h.id,
+                  description:      h.description,
+                  domain:           h.domain,
+                  prior:            h.prior,
+                  posterior:        h.posterior,
+                  status:           h.status,
+                  confidence_label: h.confidence_label
+                }
+              end
+
+              def test_hypothesis(hypothesis_id:, evidence_strength:, supporting: true, **)
+                h = hypothesis_engine.test_hypothesis(
+                  hypothesis_id:     hypothesis_id,
+                  evidence_strength: evidence_strength,
+                  supporting:        supporting
+                )
+                unless h
+                  Legion::Logging.debug "[hypothesis_testing] test failed: #{hypothesis_id[0..7]} not found"
+                  return { tested: false, reason: :not_found }
+                end
+
+                Legion::Logging.info "[hypothesis_testing] tested #{hypothesis_id[0..7]} " \
+                                     "supporting=#{supporting} strength=#{evidence_strength} " \
+                                     "posterior=#{h.posterior.round(4)} status=#{h.status}"
+                {
+                  tested:           true,
+                  hypothesis_id:    h.id,
+                  posterior:        h.posterior,
+                  evidence_count:   h.evidence_count,
+                  status:           h.status,
+                  confidence_label: h.confidence_label
+                }
+              end
+
+              def evaluate_hypothesis(hypothesis_id:, **)
+                h = hypothesis_engine.evaluate(hypothesis_id)
+                unless h
+                  Legion::Logging.debug "[hypothesis_testing] evaluate failed: #{hypothesis_id[0..7]} not found"
+                  return { found: false }
+                end
+
+                Legion::Logging.debug "[hypothesis_testing] evaluated #{hypothesis_id[0..7]} status=#{h.status}"
+                {
+                  found:            true,
+                  hypothesis_id:    h.id,
+                  status:           h.status,
+                  posterior:        h.posterior,
+                  confidence_label: h.confidence_label,
+                  evidence_count:   h.evidence_count
+                }
+              end
+
+              def competing_hypotheses(domain:, **)
+                hypotheses = hypothesis_engine.competing_hypotheses(domain: domain)
+                Legion::Logging.debug "[hypothesis_testing] competing count=#{hypotheses.size} domain=#{domain}"
+                {
+                  domain:     domain,
+                  count:      hypotheses.size,
+                  hypotheses: hypotheses.map(&:to_h)
+                }
+              end
+
+              def most_confident_hypotheses(limit: 5, **)
+                hypotheses = hypothesis_engine.most_confident(limit: limit)
+                Legion::Logging.debug "[hypothesis_testing] most_confident count=#{hypotheses.size}"
+                {
+                  count:      hypotheses.size,
+                  hypotheses: hypotheses.map(&:to_h)
+                }
+              end
+
+              def hypothesis_report(**)
+                report = hypothesis_engine.hypothesis_report
+                Legion::Logging.debug "[hypothesis_testing] report total=#{report[:total]} " \
+                                      "confirmation_rate=#{report[:confirmation_rate].round(4)}"
+                report
+              end
+
+              def get_hypothesis(hypothesis_id:, **)
+                h = hypothesis_engine.hypotheses[hypothesis_id]
+                return { found: false } unless h
+
+                { found: true, hypothesis: h.to_h }
+              end
+
+              private
+
+              def hypothesis_engine
+                @hypothesis_engine ||= Helpers::HypothesisEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/hypothesis_testing/version'
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/constants'
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis'
+require 'legion/extensions/agentic/inference/hypothesis_testing/helpers/hypothesis_engine'
+require 'legion/extensions/agentic/inference/hypothesis_testing/runners/hypothesis_testing'
+require 'legion/extensions/agentic/inference/hypothesis_testing/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module HypothesisTesting
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Intuition
+          class Client
+            include Runners::Intuition
+
+            def initialize(engine: nil)
+              @engine = engine || Helpers::IntuitionEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Intuition
+          module Helpers
+            module Constants
+              MAX_PATTERNS = 200
+              MAX_HEURISTICS = 50
+              MAX_HISTORY = 300
+
+              # Recognition threshold: pattern match score needed to trigger recognition
+              RECOGNITION_THRESHOLD = 0.6
+
+              # Confidence: how much the agent trusts its intuitions
+              DEFAULT_CONFIDENCE = 0.5
+              CONFIDENCE_FLOOR = 0.05
+              CONFIDENCE_CEILING = 0.95
+
+              # Reinforcement: how fast patterns strengthen/weaken
+              REINFORCEMENT_RATE = 0.1
+              DECAY_RATE = 0.01
+
+              # Speed advantage: intuition is N times faster than deliberation
+              SPEED_MULTIPLIER = 5
+
+              PATTERN_STATES = %i[nascent developing reliable expert].freeze
+
+              HEURISTIC_TYPES = %i[
+                recognition take_the_best satisficing
+                fast_and_frugal anchored gaze
+              ].freeze
+
+              INTUITION_MODES = %i[
+                gut_feeling pattern_match heuristic_shortcut
+                recognition_primed compiled_expertise
+              ].freeze
+
+              CONFIDENCE_LABELS = {
+                (0.8..)     => :strong_hunch,
+                (0.6...0.8) => :leaning,
+                (0.4...0.6) => :uncertain,
+                (0.2...0.4) => :weak_signal,
+                (..0.2)     => :noise
+              }.freeze
+
+              STATE_THRESHOLDS = {
+                expert:     0.85,
+                reliable:   0.65,
+                developing: 0.35
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/intuition/helpers/heuristic.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Intuition
+          module Helpers
+            class Heuristic
+              include Constants
+
+              attr_reader :id, :name, :heuristic_type, :domain, :uses, :successes
+
+              def initialize(id:, name:, heuristic_type:, domain: :general)
+                @id             = id
+                @name           = name
+                @heuristic_type = resolve_type(heuristic_type)
+                @domain         = domain
+                @uses           = 0
+                @successes      = 0
+              end
+
+              def apply
+                @uses += 1
+              end
+
+              def record_outcome(success:)
+                @successes += 1 if success
+              end
+
+              def success_rate
+                return 0.0 if @uses.zero?
+
+                @successes.to_f / @uses
+              end
+
+              def effective?
+                @uses >= 3 && success_rate >= 0.6
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  name:           @name,
+                  heuristic_type: @heuristic_type,
+                  domain:         @domain,
+                  uses:           @uses,
+                  successes:      @successes,
+                  success_rate:   success_rate.round(4),
+                  effective:      effective?
+                }
+              end
+
+              private
+
+              def resolve_type(type)
+                sym = type.to_sym
+                HEURISTIC_TYPES.include?(sym) ? sym : :fast_and_frugal
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end