lex-agentic-inference 0.1.0

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::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::Agentic::Inference::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::Agentic::Inference::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::Agentic::Inference::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/agentic/inference/uncertainty_tolerance/runners/uncertainty_tolerance_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::UncertaintyTolerance::Runners::UncertaintyTolerance do
+  let(:client) { Legion::Extensions::Agentic::Inference::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,46 @@
+# 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
+    def self.fatal(_msg); end
+  end
+
+  module Extensions
+    module Core
+      def self.extended(_base); end
+    end
+
+    module Helpers
+      module Lex
+        def self.included(_base); end
+      end
+    end
+  end
+end
+
+# rubocop:disable Lint/EmptyClass, Style/OneClassPerFile
+module Legion
+  module Extensions
+    module Actors
+      class Every; end
+      class Once; end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+$LOADED_FEATURES << 'legion/extensions/actors/once'
+# rubocop:enable Lint/EmptyClass, Style/OneClassPerFile
+
+require 'legion/extensions/agentic/inference'
+
+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