lex-uncertainty-tolerance 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0bc9fe92cf711e73709939e618754f17efa80d32a5fd4945a0b024f0ba259496
+  data.tar.gz: 36f215e7ed043e6f364390ecf291ddaed0801d5af06caf497b3a809d07645617
+SHA512:
+  metadata.gz: c562e3a07d513017f0c14cb8886cce7803c63d4350919bdedc5a009a966a320daa9dabba091051deae5772bd66361ab79d61abb05f569198351a9ad9e2a6511f
+  data.tar.gz: b53e6eb9b8369d65b38927736f1a59ef26cf77f78274494be4243e857ea4e6761debf6e6fe961421d89222d7960618f8755a48ae591a40277bb4a7c77be6a11c

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'rspec', '~> 3.13'
+  gem 'rubocop', '~> 1.75', require: false
+  gem 'rubocop-rspec', require: false
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/lex-uncertainty-tolerance.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/uncertainty_tolerance/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-uncertainty-tolerance'
+  spec.version       = Legion::Extensions::UncertaintyTolerance::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Uncertainty Tolerance'
+  spec.description   = 'Models individual differences in tolerance for ambiguity and uncertainty for brain-modeled agentic AI'
+  spec.homepage      = 'https://github.com/LegionIO/lex-uncertainty-tolerance'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']        = spec.homepage
+  spec.metadata['source_code_uri']     = 'https://github.com/LegionIO/lex-uncertainty-tolerance'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-uncertainty-tolerance'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-uncertainty-tolerance'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-uncertainty-tolerance/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib,spec}/**/*') + %w[lex-uncertainty-tolerance.gemspec Gemfile]
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

data/lib/legion/extensions/uncertainty_tolerance/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/uncertainty_tolerance/helpers/constants'
+require 'legion/extensions/uncertainty_tolerance/helpers/decision'
+require 'legion/extensions/uncertainty_tolerance/helpers/tolerance_engine'
+require 'legion/extensions/uncertainty_tolerance/runners/uncertainty_tolerance'
+
+module Legion
+  module Extensions
+    module UncertaintyTolerance
+      class Client
+        include Runners::UncertaintyTolerance
+
+        def initialize(**)
+          @engine = Helpers::ToleranceEngine.new
+        end
+
+        private
+
+        attr_reader :engine
+      end
+    end
+  end
+end

data/lib/legion/extensions/uncertainty_tolerance/helpers/constants.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module UncertaintyTolerance
+      module Helpers
+        module Constants
+          TOLERANCE_LABELS = {
+            (0.8..)     => :highly_tolerant,
+            (0.6...0.8) => :tolerant,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :intolerant,
+            (..0.2)     => :highly_intolerant
+          }.freeze
+
+          DECISION_TYPES = %i[certain probable uncertain ambiguous unknown].freeze
+
+          CERTAINTY_THRESHOLDS = {
+            certain:   0.9,
+            probable:  0.7,
+            uncertain: 0.5,
+            ambiguous: 0.3,
+            unknown:   0.0
+          }.freeze
+
+          MAX_DECISIONS        = 300
+          MAX_HISTORY          = 500
+          DEFAULT_TOLERANCE    = 0.5
+          TOLERANCE_FLOOR      = 0.0
+          TOLERANCE_CEILING    = 1.0
+          ADAPTATION_RATE      = 0.05
+          POSITIVE_OUTCOME_BOOST   = 0.03
+          NEGATIVE_OUTCOME_PENALTY = 0.05
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/uncertainty_tolerance/helpers/decision.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module UncertaintyTolerance
+      module Helpers
+        class Decision
+          attr_reader :id, :description, :domain, :certainty_level,
+                      :tolerance_at_time, :acted_despite_uncertainty, :created_at
+          attr_accessor :actual_outcome
+
+          def initialize(description:, domain:, certainty_level:, tolerance_at_time:)
+            @id                      = SecureRandom.uuid
+            @description             = description
+            @domain                  = domain
+            @certainty_level         = certainty_level.clamp(0.0, 1.0)
+            @tolerance_at_time       = tolerance_at_time
+            @actual_outcome          = nil
+            @acted_despite_uncertainty = certainty_level < tolerance_at_time
+            @created_at = Time.now.utc
+          end
+
+          def resolve!(outcome:)
+            @actual_outcome = outcome
+            self
+          end
+
+          def successful?
+            @actual_outcome == :success
+          end
+
+          def risky?
+            @certainty_level < 0.4
+          end
+
+          def decision_type
+            Constants::CERTAINTY_THRESHOLDS.each do |type, threshold|
+              return type if @certainty_level >= threshold
+            end
+            :unknown
+          end
+
+          def to_h
+            {
+              id:                        @id,
+              description:               @description,
+              domain:                    @domain,
+              certainty_level:           @certainty_level,
+              actual_outcome:            @actual_outcome,
+              tolerance_at_time:         @tolerance_at_time,
+              decision_type:             decision_type,
+              acted_despite_uncertainty: @acted_despite_uncertainty,
+              created_at:                @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

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

data/lib/legion/extensions/uncertainty_tolerance.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/uncertainty_tolerance/version'
+require 'legion/extensions/uncertainty_tolerance/helpers/constants'
+require 'legion/extensions/uncertainty_tolerance/helpers/decision'
+require 'legion/extensions/uncertainty_tolerance/helpers/tolerance_engine'
+require 'legion/extensions/uncertainty_tolerance/runners/uncertainty_tolerance'
+
+module Legion
+  module Extensions
+    module UncertaintyTolerance
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

data/spec/legion/extensions/uncertainty_tolerance/client_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/uncertainty_tolerance/client'
+
+RSpec.describe Legion::Extensions::UncertaintyTolerance::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:record_uncertain_decision)
+    expect(client).to respond_to(:resolve_uncertain_decision)
+    expect(client).to respond_to(:should_act_assessment)
+    expect(client).to respond_to(:uncertainty_profile)
+    expect(client).to respond_to(:decisions_under_uncertainty_report)
+    expect(client).to respond_to(:domain_tolerance_report)
+    expect(client).to respond_to(:update_uncertainty_tolerance)
+    expect(client).to respond_to(:uncertainty_tolerance_stats)
+  end
+end

data/spec/legion/extensions/uncertainty_tolerance/helpers/constants_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::UncertaintyTolerance::Helpers::Constants do
+  describe 'TOLERANCE_LABELS' do
+    subject(:labels) { described_class::TOLERANCE_LABELS }
+
+    it 'maps 0.9 to :highly_tolerant' do
+      match = labels.find { |range, _| range.cover?(0.9) }
+      expect(match.last).to eq(:highly_tolerant)
+    end
+
+    it 'maps 0.7 to :tolerant' do
+      match = labels.find { |range, _| range.cover?(0.7) }
+      expect(match.last).to eq(:tolerant)
+    end
+
+    it 'maps 0.5 to :moderate' do
+      match = labels.find { |range, _| range.cover?(0.5) }
+      expect(match.last).to eq(:moderate)
+    end
+
+    it 'maps 0.3 to :intolerant' do
+      match = labels.find { |range, _| range.cover?(0.3) }
+      expect(match.last).to eq(:intolerant)
+    end
+
+    it 'maps 0.1 to :highly_intolerant' do
+      match = labels.find { |range, _| range.cover?(0.1) }
+      expect(match.last).to eq(:highly_intolerant)
+    end
+  end
+
+  describe 'DECISION_TYPES' do
+    it 'contains exactly 5 types' do
+      expect(described_class::DECISION_TYPES.size).to eq(5)
+    end
+
+    it 'includes :unknown' do
+      expect(described_class::DECISION_TYPES).to include(:unknown)
+    end
+  end
+
+  describe 'CERTAINTY_THRESHOLDS' do
+    it 'has :certain at 0.9' do
+      expect(described_class::CERTAINTY_THRESHOLDS[:certain]).to eq(0.9)
+    end
+
+    it 'has :unknown at 0.0' do
+      expect(described_class::CERTAINTY_THRESHOLDS[:unknown]).to eq(0.0)
+    end
+  end
+
+  describe 'numeric constants' do
+    it 'DEFAULT_TOLERANCE is 0.5' do
+      expect(described_class::DEFAULT_TOLERANCE).to eq(0.5)
+    end
+
+    it 'POSITIVE_OUTCOME_BOOST is less than NEGATIVE_OUTCOME_PENALTY' do
+      expect(described_class::POSITIVE_OUTCOME_BOOST).to be < described_class::NEGATIVE_OUTCOME_PENALTY
+    end
+  end
+end

data/spec/legion/extensions/uncertainty_tolerance/helpers/decision_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::UncertaintyTolerance::Helpers::Decision do
+  let(:decision) do
+    described_class.new(
+      description:       'deploy to production',
+      domain:            :ops,
+      certainty_level:   0.6,
+      tolerance_at_time: 0.5
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(decision.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'clamps certainty_level to [0, 1]' do
+      d = described_class.new(
+        description: 'test', domain: :test, certainty_level: 1.5, tolerance_at_time: 0.5
+      )
+      expect(d.certainty_level).to eq(1.0)
+    end
+
+    it 'sets acted_despite_uncertainty true when certainty < tolerance' do
+      d = described_class.new(
+        description: 'risky', domain: :test, certainty_level: 0.3, tolerance_at_time: 0.5
+      )
+      expect(d.acted_despite_uncertainty).to be true
+    end
+
+    it 'sets acted_despite_uncertainty false when certainty >= tolerance' do
+      expect(decision.acted_despite_uncertainty).to be false
+    end
+
+    it 'starts with nil actual_outcome' do
+      expect(decision.actual_outcome).to be_nil
+    end
+  end
+
+  describe '#resolve!' do
+    it 'sets actual_outcome and returns self' do
+      result = decision.resolve!(outcome: :success)
+      expect(decision.actual_outcome).to eq(:success)
+      expect(result).to be(decision)
+    end
+  end
+
+  describe '#successful?' do
+    it 'returns true after :success outcome' do
+      decision.resolve!(outcome: :success)
+      expect(decision.successful?).to be true
+    end
+
+    it 'returns false after :failure outcome' do
+      decision.resolve!(outcome: :failure)
+      expect(decision.successful?).to be false
+    end
+
+    it 'returns false when unresolved' do
+      expect(decision.successful?).to be false
+    end
+  end
+
+  describe '#risky?' do
+    it 'returns true when certainty < 0.4' do
+      d = described_class.new(
+        description: 'risky', domain: :test, certainty_level: 0.3, tolerance_at_time: 0.5
+      )
+      expect(d.risky?).to be true
+    end
+
+    it 'returns false when certainty >= 0.4' do
+      expect(decision.risky?).to be false
+    end
+  end
+
+  describe '#decision_type' do
+    it 'returns :certain for certainty 0.95' do
+      d = described_class.new(
+        description: 'test', domain: :test, certainty_level: 0.95, tolerance_at_time: 0.5
+      )
+      expect(d.decision_type).to eq(:certain)
+    end
+
+    it 'returns :probable for certainty 0.75' do
+      d = described_class.new(
+        description: 'test', domain: :test, certainty_level: 0.75, tolerance_at_time: 0.5
+      )
+      expect(d.decision_type).to eq(:probable)
+    end
+
+    it 'returns :uncertain for certainty 0.55' do
+      d = described_class.new(
+        description: 'test', domain: :test, certainty_level: 0.55, tolerance_at_time: 0.5
+      )
+      expect(d.decision_type).to eq(:uncertain)
+    end
+
+    it 'returns :ambiguous for certainty 0.35' do
+      d = described_class.new(
+        description: 'test', domain: :test, certainty_level: 0.35, tolerance_at_time: 0.5
+      )
+      expect(d.decision_type).to eq(:ambiguous)
+    end
+
+    it 'returns :unknown for certainty 0.0' do
+      d = described_class.new(
+        description: 'test', domain: :test, certainty_level: 0.0, tolerance_at_time: 0.5
+      )
+      expect(d.decision_type).to eq(:unknown)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = decision.to_h
+      expect(h.keys).to include(
+        :id, :description, :domain, :certainty_level,
+        :actual_outcome, :tolerance_at_time, :decision_type,
+        :acted_despite_uncertainty, :created_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/uncertainty_tolerance/helpers/tolerance_engine_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::UncertaintyTolerance::Helpers::ToleranceEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts at DEFAULT_TOLERANCE' do
+      expect(engine.current_tolerance).to eq(
+        Legion::Extensions::UncertaintyTolerance::Helpers::Constants::DEFAULT_TOLERANCE
+      )
+    end
+
+    it 'accepts a custom initial_tolerance' do
+      e = described_class.new(initial_tolerance: 0.8)
+      expect(e.current_tolerance).to eq(0.8)
+    end
+
+    it 'clamps initial_tolerance to [0, 1]' do
+      e = described_class.new(initial_tolerance: 1.5)
+      expect(e.current_tolerance).to eq(1.0)
+    end
+  end
+
+  describe '#tolerance_label' do
+    it 'returns :moderate at 0.5' do
+      expect(engine.tolerance_label).to eq(:moderate)
+    end
+
+    it 'returns :highly_tolerant at 0.9' do
+      e = described_class.new(initial_tolerance: 0.9)
+      expect(e.tolerance_label).to eq(:highly_tolerant)
+    end
+  end
+
+  describe '#record_decision' do
+    it 'creates and stores a decision' do
+      decision = engine.record_decision(
+        description: 'test', domain: :ops, certainty_level: 0.4
+      )
+      expect(engine.decisions[decision.id]).to be(decision)
+    end
+
+    it 'returns a Decision object' do
+      result = engine.record_decision(description: 'test', certainty_level: 0.6)
+      expect(result).to be_a(Legion::Extensions::UncertaintyTolerance::Helpers::Decision)
+    end
+
+    it 'defaults domain to :general' do
+      decision = engine.record_decision(description: 'test', certainty_level: 0.6)
+      expect(decision.domain).to eq(:general)
+    end
+  end
+
+  describe '#resolve_decision' do
+    let(:decision) { engine.record_decision(description: 'test', certainty_level: 0.3) }
+
+    it 'returns nil for unknown decision_id' do
+      expect(engine.resolve_decision(decision_id: 'nonexistent', outcome: :success)).to be_nil
+    end
+
+    it 'resolves a known decision' do
+      result = engine.resolve_decision(decision_id: decision.id, outcome: :success)
+      expect(result.actual_outcome).to eq(:success)
+    end
+
+    it 'boosts tolerance on success under uncertainty' do
+      engine_low = described_class.new(initial_tolerance: 0.8)
+      d = engine_low.record_decision(description: 'uncertain act', certainty_level: 0.3)
+      before = engine_low.current_tolerance
+      engine_low.resolve_decision(decision_id: d.id, outcome: :success)
+      expect(engine_low.current_tolerance).to be > before
+    end
+
+    it 'penalizes tolerance on failure under uncertainty' do
+      engine_low = described_class.new(initial_tolerance: 0.8)
+      d = engine_low.record_decision(description: 'uncertain act', certainty_level: 0.3)
+      before = engine_low.current_tolerance
+      engine_low.resolve_decision(decision_id: d.id, outcome: :failure)
+      expect(engine_low.current_tolerance).to be < before
+    end
+
+    it 'does not adapt tolerance when certainty >= tolerance (no uncertainty)' do
+      d = engine.record_decision(description: 'certain act', certainty_level: 0.9)
+      before = engine.current_tolerance
+      engine.resolve_decision(decision_id: d.id, outcome: :success)
+      expect(engine.current_tolerance).to eq(before)
+    end
+  end
+
+  describe '#decisions_under_uncertainty' do
+    before do
+      engine.record_decision(description: 'low', certainty_level: 0.2)
+      engine.record_decision(description: 'high', certainty_level: 0.9)
+    end
+
+    it 'returns decisions below the current tolerance' do
+      result = engine.decisions_under_uncertainty
+      expect(result.map(&:description)).to include('low')
+      expect(result.map(&:description)).not_to include('high')
+    end
+
+    it 'accepts a custom threshold' do
+      result = engine.decisions_under_uncertainty(threshold: 0.3)
+      expect(result.all? { |d| d.certainty_level < 0.3 }).to be true
+    end
+  end
+
+  describe '#successful_uncertain_decisions' do
+    it 'returns only resolved successes where agent acted despite uncertainty' do
+      e = described_class.new(initial_tolerance: 0.8)
+      d = e.record_decision(description: 'risky success', certainty_level: 0.3)
+      e.resolve_decision(decision_id: d.id, outcome: :success)
+      expect(e.successful_uncertain_decisions.size).to eq(1)
+    end
+
+    it 'excludes failures' do
+      e = described_class.new(initial_tolerance: 0.8)
+      d = e.record_decision(description: 'risky fail', certainty_level: 0.3)
+      e.resolve_decision(decision_id: d.id, outcome: :failure)
+      expect(e.successful_uncertain_decisions).to be_empty
+    end
+  end
+
+  describe '#risk_profile' do
+    it 'returns a hash keyed by decision types' do
+      engine.record_decision(description: 'c', certainty_level: 0.95)
+      profile = engine.risk_profile
+      expect(profile.keys).to match_array(
+        Legion::Extensions::UncertaintyTolerance::Helpers::Constants::DECISION_TYPES
+      )
+    end
+
+    it 'counts decisions correctly' do
+      2.times { engine.record_decision(description: 'x', certainty_level: 0.95) }
+      expect(engine.risk_profile[:certain]).to eq(2)
+    end
+  end
+
+  describe '#domain_tolerance' do
+    it 'returns nil when no resolved decisions for domain' do
+      expect(engine.domain_tolerance(domain: :missing)).to be_nil
+    end
+
+    it 'returns average certainty of successful decisions in domain' do
+      d = engine.record_decision(description: 'x', domain: :code, certainty_level: 0.8)
+      engine.resolve_decision(decision_id: d.id, outcome: :success)
+      expect(engine.domain_tolerance(domain: :code)).to be_within(0.001).of(0.8)
+    end
+  end
+
+  describe '#should_act?' do
+    it 'returns true when certainty >= current_tolerance' do
+      expect(engine.should_act?(certainty: 0.5)).to be true
+    end
+
+    it 'returns false when certainty < current_tolerance' do
+      expect(engine.should_act?(certainty: 0.3)).to be false
+    end
+  end
+
+  describe '#comfort_zone_expansion_rate' do
+    it 'returns 0.0 with fewer than 2 history entries' do
+      expect(engine.comfort_zone_expansion_rate).to eq(0.0)
+    end
+
+    it 'returns positive rate after multiple successful uncertain decisions' do
+      e = described_class.new(initial_tolerance: 0.6)
+      5.times do
+        d = e.record_decision(description: 'test', certainty_level: 0.2)
+        e.resolve_decision(decision_id: d.id, outcome: :success)
+      end
+      expect(e.comfort_zone_expansion_rate).to be >= 0.0
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes required keys' do
+      h = engine.to_h
+      expect(h.keys).to include(
+        :current_tolerance, :tolerance_label, :total_decisions, :risk_profile, :history_count
+      )
+    end
+  end
+end

data/spec/legion/extensions/uncertainty_tolerance/runners/uncertainty_tolerance_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/uncertainty_tolerance/client'
+
+RSpec.describe Legion::Extensions::UncertaintyTolerance::Runners::UncertaintyTolerance do
+  let(:client) { Legion::Extensions::UncertaintyTolerance::Client.new }
+
+  describe '#record_uncertain_decision' do
+    it 'records a decision and returns structured response' do
+      result = client.record_uncertain_decision(
+        description:     'deploy service',
+        certainty_level: 0.4,
+        domain:          :ops
+      )
+      expect(result[:decision_id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:certainty_level]).to eq(0.4)
+      expect(result[:domain]).to eq(:ops)
+      expect(result[:current_tolerance]).to be_a(Float)
+    end
+
+    it 'computes acted_despite_uncertainty flag' do
+      result = client.record_uncertain_decision(
+        description:     'risky action',
+        certainty_level: 0.2
+      )
+      expect(result[:acted_despite_uncertainty]).to be true
+    end
+
+    it 'includes decision_type in response' do
+      result = client.record_uncertain_decision(
+        description:     'probable action',
+        certainty_level: 0.75
+      )
+      expect(result[:decision_type]).to eq(:probable)
+    end
+  end
+
+  describe '#resolve_uncertain_decision' do
+    let(:decision_id) do
+      client.record_uncertain_decision(
+        description: 'test', certainty_level: 0.3
+      )[:decision_id]
+    end
+
+    it 'resolves a known decision' do
+      result = client.resolve_uncertain_decision(decision_id: decision_id, outcome: :success)
+      expect(result[:resolved]).to be true
+      expect(result[:outcome]).to eq(:success)
+    end
+
+    it 'returns resolved: false for unknown id' do
+      result = client.resolve_uncertain_decision(decision_id: 'bad-id', outcome: :success)
+      expect(result[:resolved]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'includes updated tolerance in response' do
+      result = client.resolve_uncertain_decision(decision_id: decision_id, outcome: :success)
+      expect(result[:current_tolerance]).to be_a(Float)
+      expect(result[:tolerance_label]).to be_a(Symbol)
+    end
+  end
+
+  describe '#should_act_assessment' do
+    it 'returns should_act: true when certainty meets tolerance' do
+      result = client.should_act_assessment(certainty: 0.9)
+      expect(result[:should_act]).to be true
+    end
+
+    it 'returns should_act: false when certainty is below tolerance' do
+      result = client.should_act_assessment(certainty: 0.1)
+      expect(result[:should_act]).to be false
+    end
+
+    it 'includes gap in response' do
+      result = client.should_act_assessment(certainty: 0.7)
+      expect(result[:gap]).to be_a(Float)
+    end
+  end
+
+  describe '#uncertainty_profile' do
+    it 'returns profile hash with expected keys' do
+      result = client.uncertainty_profile
+      expect(result.keys).to include(
+        :current_tolerance, :tolerance_label, :total_decisions, :risk_profile
+      )
+    end
+  end
+
+  describe '#decisions_under_uncertainty_report' do
+    before do
+      client.record_uncertain_decision(description: 'low certainty', certainty_level: 0.1)
+      client.record_uncertain_decision(description: 'high certainty', certainty_level: 0.9)
+    end
+
+    it 'returns decisions below threshold' do
+      result = client.decisions_under_uncertainty_report
+      expect(result[:count]).to be >= 1
+      expect(result[:decisions]).to all(include(:certainty_level))
+    end
+
+    it 'accepts a custom threshold' do
+      result = client.decisions_under_uncertainty_report(threshold: 0.2)
+      expect(result[:threshold]).to eq(0.2)
+    end
+  end
+
+  describe '#domain_tolerance_report' do
+    it 'returns found: false when domain has no data' do
+      result = client.domain_tolerance_report(domain: :unknown_domain)
+      expect(result[:found]).to be false
+    end
+
+    it 'returns average certainty when successful decisions exist' do
+      id = client.record_uncertain_decision(
+        description: 'code review', domain: :code, certainty_level: 0.85
+      )[:decision_id]
+      client.resolve_uncertain_decision(decision_id: id, outcome: :success)
+      result = client.domain_tolerance_report(domain: :code)
+      expect(result[:found]).to be true
+      expect(result[:average_certainty]).to be_within(0.01).of(0.85)
+    end
+  end
+
+  describe '#update_uncertainty_tolerance' do
+    it 'updates tolerance to clamped value' do
+      result = client.update_uncertainty_tolerance(tolerance: 0.7)
+      expect(result[:updated]).to be true
+      expect(result[:current_tolerance]).to eq(0.7)
+    end
+
+    it 'clamps values above 1.0' do
+      result = client.update_uncertainty_tolerance(tolerance: 1.5)
+      expect(result[:current_tolerance]).to eq(1.0)
+    end
+
+    it 'clamps values below 0.0' do
+      result = client.update_uncertainty_tolerance(tolerance: -0.5)
+      expect(result[:current_tolerance]).to eq(0.0)
+    end
+  end
+
+  describe '#uncertainty_tolerance_stats' do
+    it 'returns comprehensive stats' do
+      result = client.uncertainty_tolerance_stats
+      expect(result.keys).to include(
+        :current_tolerance,
+        :tolerance_label,
+        :total_decisions,
+        :successful_uncertain_count,
+        :risk_profile,
+        :comfort_zone_expansion_rate,
+        :history_count
+      )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+module Legion
+  module Logging
+    def self.debug(_msg); end
+    def self.info(_msg); end
+    def self.warn(_msg); end
+    def self.error(_msg); end
+  end
+end
+
+require 'legion/extensions/uncertainty_tolerance'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: lex-uncertainty-tolerance
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Models individual differences in tolerance for ambiguity and uncertainty
+  for brain-modeled agentic AI
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- lex-uncertainty-tolerance.gemspec
+- lib/legion/extensions/uncertainty_tolerance.rb
+- lib/legion/extensions/uncertainty_tolerance/client.rb
+- lib/legion/extensions/uncertainty_tolerance/helpers/constants.rb
+- lib/legion/extensions/uncertainty_tolerance/helpers/decision.rb
+- lib/legion/extensions/uncertainty_tolerance/helpers/tolerance_engine.rb
+- lib/legion/extensions/uncertainty_tolerance/runners/uncertainty_tolerance.rb
+- lib/legion/extensions/uncertainty_tolerance/version.rb
+- spec/legion/extensions/uncertainty_tolerance/client_spec.rb
+- spec/legion/extensions/uncertainty_tolerance/helpers/constants_spec.rb
+- spec/legion/extensions/uncertainty_tolerance/helpers/decision_spec.rb
+- spec/legion/extensions/uncertainty_tolerance/helpers/tolerance_engine_spec.rb
+- spec/legion/extensions/uncertainty_tolerance/runners/uncertainty_tolerance_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-uncertainty-tolerance
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-uncertainty-tolerance
+  source_code_uri: https://github.com/LegionIO/lex-uncertainty-tolerance
+  documentation_uri: https://github.com/LegionIO/lex-uncertainty-tolerance
+  changelog_uri: https://github.com/LegionIO/lex-uncertainty-tolerance
+  bug_tracker_uri: https://github.com/LegionIO/lex-uncertainty-tolerance/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Uncertainty Tolerance
+test_files: []