lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/schema/helpers/world_model_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Schema::Helpers::WorldModel do
+  subject(:model) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty relations' do
+      expect(model.relations).to be_empty
+    end
+  end
+
+  describe '#add_relation' do
+    it 'creates a new causal relation' do
+      result = model.add_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      expect(result).to be_a(Legion::Extensions::Agentic::Inference::Schema::Helpers::CausalRelation)
+    end
+
+    it 'reinforces existing relation on repeat add' do
+      model.add_relation(cause: :rain, effect: :wet, relation_type: :causes, confidence: 0.5)
+      result = model.add_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      expect(result.evidence_count).to eq(2)
+      expect(result.confidence).to be > 0.5
+    end
+
+    it 'returns nil for invalid relation type' do
+      expect(model.add_relation(cause: :a, effect: :b, relation_type: :invalid)).to be_nil
+    end
+
+    it 'increments relation count' do
+      model.add_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      model.add_relation(cause: :sun, effect: :warm, relation_type: :causes)
+      expect(model.relation_count).to eq(2)
+    end
+  end
+
+  describe '#weaken_relation' do
+    before { model.add_relation(cause: :rain, effect: :wet, relation_type: :causes, confidence: 0.6) }
+
+    it 'reduces confidence' do
+      result = model.weaken_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      expect(result.confidence).to be < 0.6
+    end
+
+    it 'returns nil for unknown relation' do
+      expect(model.weaken_relation(cause: :x, effect: :y, relation_type: :causes)).to be_nil
+    end
+
+    it 'prunes relation if it falls below threshold' do
+      model.weaken_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      model.weaken_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      model.weaken_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      model.weaken_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      expect(model.relation_count).to eq(0)
+    end
+  end
+
+  describe '#find_effects' do
+    before do
+      model.add_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      model.add_relation(cause: :rain, effect: :flood, relation_type: :causes)
+      model.add_relation(cause: :sun, effect: :warm, relation_type: :causes)
+    end
+
+    it 'returns effects for a given cause' do
+      effects = model.find_effects(:rain)
+      expect(effects.size).to eq(2)
+      expect(effects.map(&:effect)).to contain_exactly(:wet, :flood)
+    end
+
+    it 'returns empty array for unknown cause' do
+      expect(model.find_effects(:snow)).to be_empty
+    end
+  end
+
+  describe '#find_causes' do
+    before do
+      model.add_relation(cause: :rain, effect: :flood, relation_type: :causes)
+      model.add_relation(cause: :snowmelt, effect: :flood, relation_type: :causes)
+    end
+
+    it 'returns causes for a given effect' do
+      causes = model.find_causes(:flood)
+      expect(causes.size).to eq(2)
+      expect(causes.map(&:cause)).to contain_exactly(:rain, :snowmelt)
+    end
+  end
+
+  describe '#explain' do
+    before do
+      model.add_relation(cause: :rain, effect: :wet_ground, relation_type: :causes, confidence: 0.8)
+      model.add_relation(cause: :wet_ground, effect: :slip, relation_type: :causes, confidence: 0.7)
+      model.add_relation(cause: :slip, effect: :injury, relation_type: :causes, confidence: 0.6)
+    end
+
+    it 'builds an explanation chain' do
+      chain = model.explain(:injury)
+      expect(chain.size).to be >= 1
+      expect(chain.first[:effect]).to eq(:injury)
+    end
+
+    it 'traces back to root cause' do
+      chain = model.explain(:injury)
+      causes_in_chain = chain.map { |c| c[:cause] }
+      expect(causes_in_chain).to include(:slip)
+    end
+
+    it 'returns empty chain for unknown outcome' do
+      expect(model.explain(:unknown)).to be_empty
+    end
+  end
+
+  describe '#counterfactual' do
+    before do
+      model.add_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      model.add_relation(cause: :wet, effect: :slip, relation_type: :causes)
+    end
+
+    it 'traces downstream effects' do
+      affected = model.counterfactual(:rain)
+      effects = affected.map { |a| a[:effect] }
+      expect(effects).to include(:wet)
+      expect(effects).to include(:slip)
+    end
+
+    it 'returns empty for unknown cause' do
+      expect(model.counterfactual(:unknown)).to be_empty
+    end
+  end
+
+  describe '#contradictions' do
+    it 'detects cause/prevent contradictions' do
+      model.add_relation(cause: :exercise, effect: :health, relation_type: :causes, confidence: 0.8)
+      model.add_relation(cause: :exercise, effect: :health, relation_type: :prevents, confidence: 0.3)
+      result = model.contradictions
+      expect(result.size).to eq(1)
+      expect(result.first[:cause]).to eq(:exercise)
+    end
+
+    it 'returns empty when no contradictions' do
+      model.add_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      expect(model.contradictions).to be_empty
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all relations' do
+      model.add_relation(cause: :a, effect: :b, relation_type: :causes, confidence: 0.5)
+      model.decay_all
+      rel = model.relations.values.first
+      expect(rel.confidence).to be < 0.5
+    end
+
+    it 'prunes weak relations' do
+      model.add_relation(cause: :a, effect: :b, relation_type: :causes, confidence: 0.05)
+      model.decay_all
+      expect(model.relation_count).to eq(0)
+    end
+  end
+
+  describe '#domain_count' do
+    it 'counts unique entities' do
+      model.add_relation(cause: :a, effect: :b, relation_type: :causes)
+      model.add_relation(cause: :b, effect: :c, relation_type: :causes)
+      expect(model.domain_count).to eq(3)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      result = model.to_h
+      expect(result).to have_key(:relation_count)
+      expect(result).to have_key(:domain_count)
+      expect(result).to have_key(:established_count)
+      expect(result).to have_key(:contradiction_count)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/schema/runners/schema_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Schema::Runners::Schema do
+  let(:wmodel) { Legion::Extensions::Agentic::Inference::Schema::Helpers::WorldModel.new }
+
+  let(:host) do
+    Object.new.tap do |obj|
+      obj.extend(described_class)
+      obj.instance_variable_set(:@world_model, wmodel)
+    end
+  end
+
+  describe '#learn_relation' do
+    it 'returns success for valid relation' do
+      result = host.learn_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      expect(result[:success]).to be true
+      expect(result[:relation][:cause]).to eq(:rain)
+    end
+
+    it 'returns failure for invalid type' do
+      result = host.learn_relation(cause: :a, effect: :b, relation_type: :invalid)
+      expect(result[:success]).to be false
+    end
+
+    it 'accepts string relation types' do
+      result = host.learn_relation(cause: :rain, effect: :wet, relation_type: 'causes')
+      expect(result[:success]).to be true
+    end
+
+    it 'reinforces on duplicate learn' do
+      host.learn_relation(cause: :rain, effect: :wet, relation_type: :causes, confidence: 0.5)
+      result = host.learn_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      expect(result[:relation][:evidence_count]).to eq(2)
+    end
+  end
+
+  describe '#weaken_relation' do
+    before { host.learn_relation(cause: :rain, effect: :wet, relation_type: :causes, confidence: 0.6) }
+
+    it 'returns success' do
+      result = host.weaken_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure for unknown relation' do
+      result = host.weaken_relation(cause: :x, effect: :y, relation_type: :causes)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#explain' do
+    before do
+      host.learn_relation(cause: :rain, effect: :flood, relation_type: :causes, confidence: 0.8)
+      host.learn_relation(cause: :flood, effect: :damage, relation_type: :causes, confidence: 0.7)
+    end
+
+    it 'returns an explanation chain' do
+      result = host.explain(outcome: :damage)
+      expect(result[:outcome]).to eq(:damage)
+      expect(result[:chain]).not_to be_empty
+    end
+
+    it 'returns empty chain for unknown outcome' do
+      result = host.explain(outcome: :unknown)
+      expect(result[:chain]).to be_empty
+    end
+  end
+
+  describe '#counterfactual' do
+    before do
+      host.learn_relation(cause: :rain, effect: :wet, relation_type: :causes)
+      host.learn_relation(cause: :wet, effect: :slip, relation_type: :causes)
+    end
+
+    it 'traces downstream impact' do
+      result = host.counterfactual(cause: :rain)
+      expect(result[:cause]).to eq(:rain)
+      expect(result[:affected].size).to be >= 2
+    end
+  end
+
+  describe '#find_effects' do
+    before { host.learn_relation(cause: :rain, effect: :wet, relation_type: :causes) }
+
+    it 'returns effects for a cause' do
+      result = host.find_effects(cause: :rain)
+      expect(result[:count]).to eq(1)
+      expect(result[:effects].first[:effect]).to eq(:wet)
+    end
+  end
+
+  describe '#find_causes' do
+    before { host.learn_relation(cause: :rain, effect: :flood, relation_type: :causes) }
+
+    it 'returns causes for an effect' do
+      result = host.find_causes(effect: :flood)
+      expect(result[:count]).to eq(1)
+      expect(result[:causes].first[:cause]).to eq(:rain)
+    end
+  end
+
+  describe '#contradictions' do
+    it 'detects contradictions' do
+      host.learn_relation(cause: :a, effect: :b, relation_type: :causes, confidence: 0.8)
+      host.learn_relation(cause: :a, effect: :b, relation_type: :prevents, confidence: 0.3)
+      result = host.contradictions
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#schema_stats' do
+    it 'returns stats with top relations' do
+      host.learn_relation(cause: :a, effect: :b, relation_type: :causes, confidence: 0.95)
+      result = host.schema_stats
+      expect(result).to have_key(:relation_count)
+      expect(result).to have_key(:top_relations)
+    end
+  end
+
+  describe '#update_schema' do
+    it 'returns world model summary' do
+      result = host.update_schema(tick_results: {})
+      expect(result).to have_key(:relation_count)
+    end
+
+    it 'extracts prediction outcomes' do
+      tick = {
+        prediction_engine: {
+          resolved: [
+            { domain: :weather, outcome_domain: :mood, accurate: true },
+            { domain: :sleep, outcome_domain: :energy, accurate: false }
+          ]
+        }
+      }
+      host.update_schema(tick_results: tick)
+      expect(wmodel.relation_count).to be >= 1
+    end
+
+    it 'handles empty tick results' do
+      result = host.update_schema(tick_results: {})
+      expect(result[:relation_count]).to eq(0)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/uncertainty_tolerance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::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/agentic/inference/uncertainty_tolerance/helpers/constants_spec.rb

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::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