lex-reality-testing 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c9a93d20a2e4a53f6396b812010686a6441cb0f12ed5ca532779115b61b66b00
+  data.tar.gz: e04d90a78cf5f1a6f8fb9f37ed5356873d7ca6fc6ee4bc7f680be0656bec0ed2
+SHA512:
+  metadata.gz: 7dd6321e7864703bdb3c72e9bd933f4f7cddd82468c35b7c1c964d32209dc78ad4ad6aff726c5259ebde4b6cb5c3ed9328cac8558ed2cfa588022c5bec1961aa
+  data.tar.gz: 0de4693b35dbb1ccfefce3a08433bb5d03aa145162d932e16d0679d3b674f8c1b45d141ffe57deac53a93e67370ca1315d87483428580b383bb045d93d65c44c

data/Gemfile

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

data/lex-reality-testing.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/reality_testing/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-reality-testing'
+  spec.version       = Legion::Extensions::RealityTesting::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Reality Testing'
+  spec.description   = 'Belief validation, evidence accumulation, and reality coherence for brain-modeled agentic AI'
+  spec.homepage      = 'https://github.com/LegionIO/lex-reality-testing'
+  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-reality-testing'
+  spec.metadata['documentation_uri']   = 'https://github.com/LegionIO/lex-reality-testing'
+  spec.metadata['changelog_uri']       = 'https://github.com/LegionIO/lex-reality-testing'
+  spec.metadata['bug_tracker_uri']     = 'https://github.com/LegionIO/lex-reality-testing/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib,spec}/**/*') + %w[lex-reality-testing.gemspec Gemfile]
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/reality_testing/helpers/constants'
+require 'legion/extensions/reality_testing/helpers/belief'
+require 'legion/extensions/reality_testing/helpers/reality_engine'
+require 'legion/extensions/reality_testing/runners/reality_testing'
+
+module Legion
+  module Extensions
+    module RealityTesting
+      class Client
+        include Runners::RealityTesting
+
+        def initialize(**)
+          @reality_engine = Helpers::RealityEngine.new
+        end
+
+        private
+
+        attr_reader :reality_engine
+      end
+    end
+  end
+end

data/lib/legion/extensions/reality_testing/helpers/belief.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module RealityTesting
+      module Helpers
+        class Belief
+          include Constants
+
+          attr_reader :id, :claim, :domain, :confidence, :evidence_count,
+                      :confirming_count, :disconfirming_count, :created_at, :last_tested_at
+
+          def initialize(id:, claim:, domain: :general, confidence: Constants::DEFAULT_CONFIDENCE)
+            @id                  = id
+            @claim               = claim
+            @domain              = domain
+            @confidence          = confidence.clamp(0.0, 1.0)
+            @evidence_count      = 0
+            @confirming_count    = 0
+            @disconfirming_count = 0
+            @created_at          = Time.now.utc
+            @last_tested_at      = nil
+          end
+
+          def test_with_evidence!(evidence_type:, weight: 0.1)
+            raise ArgumentError, "unknown evidence_type: #{evidence_type}" unless Constants::EVIDENCE_TYPES.include?(evidence_type)
+
+            @evidence_count   += 1
+            @last_tested_at    = Time.now.utc
+
+            case evidence_type
+            when :confirming
+              @confirming_count += 1
+              @confidence = (@confidence + (Constants::CONFIDENCE_BOOST * weight * 10)).clamp(0.0, 1.0)
+            when :disconfirming
+              @disconfirming_count += 1
+              @confidence = (@confidence - (Constants::CONFIDENCE_PENALTY * weight * 10)).clamp(0.0, 1.0)
+            when :neutral
+              # no confidence change
+            when :ambiguous
+              delta = @confidence - 0.5
+              @confidence = (@confidence - (delta * 0.1)).clamp(0.0, 1.0)
+            end
+
+            self
+          end
+
+          def confidence_label
+            Constants::CONFIDENCE_LABELS.find { |entry| entry[:range].cover?(@confidence) }&.fetch(:label) || :rejected
+          end
+
+          def validity
+            total = @confirming_count + @disconfirming_count
+            return 0.5 if total.zero?
+
+            @confirming_count.to_f / total
+          end
+
+          def validity_label
+            v = validity
+            Constants::VALIDITY_LABELS.find { |entry| entry[:range].cover?(v) }&.fetch(:label) || :refuted
+          end
+
+          def needs_testing?
+            @confidence.between?(0.3, 0.7)
+          end
+
+          def decay!
+            @confidence = (@confidence - Constants::CONFIDENCE_DECAY).clamp(0.0, 1.0)
+            self
+          end
+
+          def to_h
+            {
+              id:                  @id,
+              claim:               @claim,
+              domain:              @domain,
+              confidence:          @confidence,
+              confidence_label:    confidence_label,
+              evidence_count:      @evidence_count,
+              confirming_count:    @confirming_count,
+              disconfirming_count: @disconfirming_count,
+              validity:            validity.round(3),
+              validity_label:      validity_label,
+              needs_testing:       needs_testing?,
+              created_at:          @created_at,
+              last_tested_at:      @last_tested_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module RealityTesting
+      module Helpers
+        module Constants
+          MAX_BELIEFS   = 300
+          MAX_EVIDENCE  = 500
+
+          DEFAULT_CONFIDENCE  = 0.5
+          CONFIDENCE_BOOST    = 0.1
+          CONFIDENCE_PENALTY  = 0.15
+          CONFIDENCE_DECAY    = 0.02
+
+          CONFIDENCE_LABELS = [
+            { range: (0.85..1.0), label: :certain },
+            { range: (0.65...0.85), label: :confident  },
+            { range: (0.35...0.65), label: :tentative  },
+            { range: (0.15...0.35), label: :doubtful   },
+            { range: (0.0...0.15),  label: :rejected   }
+          ].freeze
+
+          EVIDENCE_TYPES = %i[confirming disconfirming neutral ambiguous].freeze
+
+          VALIDITY_LABELS = [
+            { range: (0.75..1.0),   label: :validated    },
+            { range: (0.55...0.75), label: :supported    },
+            { range: (0.35...0.55), label: :uncertain    },
+            { range: (0.15...0.35), label: :questionable },
+            { range: (0.0...0.15),  label: :refuted      }
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/reality_testing/helpers/reality_engine.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module RealityTesting
+      module Helpers
+        class RealityEngine
+          def initialize
+            @beliefs     = {}
+            @next_id     = 1
+          end
+
+          def create_belief(claim:, domain: :general, confidence: Constants::DEFAULT_CONFIDENCE)
+            return { created: false, reason: :at_capacity } if @beliefs.size >= Constants::MAX_BELIEFS
+
+            id = "belief_#{@next_id}"
+            @next_id += 1
+            belief = Belief.new(id: id, claim: claim, domain: domain, confidence: confidence)
+            @beliefs[id] = belief
+            Legion::Logging.debug "[reality_testing] create_belief id=#{id} domain=#{domain} confidence=#{confidence.round(2)}"
+            { created: true, belief: belief.to_h }
+          end
+
+          def test_belief(belief_id:, evidence_type:, weight: 0.1)
+            belief = @beliefs[belief_id]
+            return { tested: false, reason: :not_found } unless belief
+
+            belief.test_with_evidence!(evidence_type: evidence_type, weight: weight)
+            Legion::Logging.debug "[reality_testing] test_belief id=#{belief_id} evidence=#{evidence_type} confidence=#{belief.confidence.round(2)}"
+            { tested: true, belief: belief.to_h }
+          end
+
+          def beliefs_needing_testing
+            @beliefs.values.select(&:needs_testing?)
+          end
+
+          def strongest_beliefs(limit: 10)
+            @beliefs.values
+                    .sort_by { |b| -b.confidence }
+                    .first(limit)
+          end
+
+          def weakest_beliefs(limit: 10)
+            @beliefs.values
+                    .sort_by(&:confidence)
+                    .first(limit)
+          end
+
+          def beliefs_by_domain(domain:)
+            @beliefs.values.select { |b| b.domain == domain }
+          end
+
+          def overall_reality_coherence
+            return 0.0 if @beliefs.empty?
+
+            total = @beliefs.values.sum(&:validity)
+            total / @beliefs.size
+          end
+
+          def decay_all
+            @beliefs.each_value(&:decay!)
+            @beliefs.size
+          end
+
+          def prune_rejected
+            before = @beliefs.size
+            @beliefs.delete_if { |_id, b| b.confidence < 0.1 }
+            pruned = before - @beliefs.size
+            Legion::Logging.debug "[reality_testing] prune_rejected pruned=#{pruned} remaining=#{@beliefs.size}"
+            pruned
+          end
+
+          def reality_report
+            domains = @beliefs.values.group_by(&:domain)
+            {
+              total_beliefs:   @beliefs.size,
+              coherence:       overall_reality_coherence.round(3),
+              needing_testing: beliefs_needing_testing.size,
+              domains:         domains.transform_values(&:size),
+              strongest_claim: @beliefs.values.max_by(&:confidence)&.claim,
+              weakest_claim:   @beliefs.values.min_by(&:confidence)&.claim
+            }
+          end
+
+          def to_h
+            {
+              belief_count: @beliefs.size,
+              coherence:    overall_reality_coherence.round(3),
+              beliefs:      @beliefs.values.map(&:to_h)
+            }
+          end
+
+          def size
+            @beliefs.size
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module RealityTesting
+      module Runners
+        module RealityTesting
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          def create_belief(claim:, domain: :general, confidence: nil, **)
+            conf   = confidence || Helpers::Constants::DEFAULT_CONFIDENCE
+            result = reality_engine.create_belief(claim: claim, domain: domain, confidence: conf)
+            Legion::Logging.info "[reality_testing] create_belief claim=#{claim[0, 60]} domain=#{domain}"
+            result
+          end
+
+          def test_belief(belief_id:, evidence_type:, weight: 0.1, **)
+            etype = evidence_type.to_sym
+            reality_engine.test_belief(belief_id: belief_id, evidence_type: etype, weight: weight)
+          end
+
+          def get_belief(belief_id:, **)
+            engine = reality_engine
+            belief = engine.instance_variable_get(:@beliefs)[belief_id]
+            return { found: false, belief_id: belief_id } unless belief
+
+            { found: true, belief: belief.to_h }
+          end
+
+          def beliefs_needing_testing(**)
+            beliefs = reality_engine.beliefs_needing_testing
+            Legion::Logging.debug "[reality_testing] needs_testing count=#{beliefs.size}"
+            { count: beliefs.size, beliefs: beliefs.map(&:to_h) }
+          end
+
+          def strongest_beliefs(limit: 10, **)
+            beliefs = reality_engine.strongest_beliefs(limit: limit)
+            { count: beliefs.size, beliefs: beliefs.map(&:to_h) }
+          end
+
+          def weakest_beliefs(limit: 10, **)
+            beliefs = reality_engine.weakest_beliefs(limit: limit)
+            { count: beliefs.size, beliefs: beliefs.map(&:to_h) }
+          end
+
+          def beliefs_by_domain(domain:, **)
+            beliefs = reality_engine.beliefs_by_domain(domain: domain.to_sym)
+            { domain: domain, count: beliefs.size, beliefs: beliefs.map(&:to_h) }
+          end
+
+          def overall_coherence(**)
+            coherence = reality_engine.overall_reality_coherence
+            Legion::Logging.debug "[reality_testing] coherence=#{coherence.round(3)}"
+            { coherence: coherence.round(3) }
+          end
+
+          def decay_beliefs(**)
+            count = reality_engine.decay_all
+            Legion::Logging.debug "[reality_testing] decay_all count=#{count}"
+            { decayed: count }
+          end
+
+          def prune_rejected_beliefs(**)
+            pruned = reality_engine.prune_rejected
+            { pruned: pruned }
+          end
+
+          def reality_report(**)
+            reality_engine.reality_report
+          end
+
+          def reality_status(**)
+            {
+              total_beliefs:   reality_engine.size,
+              coherence:       reality_engine.overall_reality_coherence.round(3),
+              needing_testing: reality_engine.beliefs_needing_testing.size
+            }
+          end
+
+          private
+
+          def reality_engine
+            @reality_engine ||= Helpers::RealityEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/reality_testing.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/reality_testing/version'
+require 'legion/extensions/reality_testing/helpers/constants'
+require 'legion/extensions/reality_testing/helpers/belief'
+require 'legion/extensions/reality_testing/helpers/reality_engine'
+require 'legion/extensions/reality_testing/runners/reality_testing'
+
+module Legion
+  module Extensions
+    module RealityTesting
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/reality_testing/client'
+
+RSpec.describe Legion::Extensions::RealityTesting::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:create_belief)
+    expect(client).to respond_to(:test_belief)
+    expect(client).to respond_to(:get_belief)
+    expect(client).to respond_to(:beliefs_needing_testing)
+    expect(client).to respond_to(:strongest_beliefs)
+    expect(client).to respond_to(:weakest_beliefs)
+    expect(client).to respond_to(:beliefs_by_domain)
+    expect(client).to respond_to(:overall_coherence)
+    expect(client).to respond_to(:decay_beliefs)
+    expect(client).to respond_to(:prune_rejected_beliefs)
+    expect(client).to respond_to(:reality_report)
+    expect(client).to respond_to(:reality_status)
+  end
+
+  it 'maintains isolated state per instance' do
+    client_a = described_class.new
+    client_b = described_class.new
+    client_a.create_belief(claim: 'only in A')
+    expect(client_b.reality_status[:total_beliefs]).to eq(0)
+  end
+end

data/spec/legion/extensions/reality_testing/helpers/belief_spec.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::RealityTesting::Helpers::Belief do
+  subject(:belief) { described_class.new(id: 'b1', claim: 'The sky is blue', domain: :perception) }
+
+  describe '#initialize' do
+    it 'sets id' do
+      expect(belief.id).to eq('b1')
+    end
+
+    it 'sets claim' do
+      expect(belief.claim).to eq('The sky is blue')
+    end
+
+    it 'sets domain' do
+      expect(belief.domain).to eq(:perception)
+    end
+
+    it 'sets default confidence' do
+      expect(belief.confidence).to eq(0.5)
+    end
+
+    it 'clamps confidence above 1.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 1.5)
+      expect(b.confidence).to eq(1.0)
+    end
+
+    it 'clamps confidence below 0.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: -0.5)
+      expect(b.confidence).to eq(0.0)
+    end
+
+    it 'initializes evidence counts to zero' do
+      expect(belief.evidence_count).to eq(0)
+      expect(belief.confirming_count).to eq(0)
+      expect(belief.disconfirming_count).to eq(0)
+    end
+  end
+
+  describe '#test_with_evidence!' do
+    it 'increments evidence_count for any type' do
+      belief.test_with_evidence!(evidence_type: :confirming)
+      expect(belief.evidence_count).to eq(1)
+    end
+
+    it 'increases confidence for confirming evidence' do
+      before = belief.confidence
+      belief.test_with_evidence!(evidence_type: :confirming)
+      expect(belief.confidence).to be > before
+    end
+
+    it 'decreases confidence for disconfirming evidence' do
+      before = belief.confidence
+      belief.test_with_evidence!(evidence_type: :disconfirming)
+      expect(belief.confidence).to be < before
+    end
+
+    it 'does not change confidence for neutral evidence' do
+      before = belief.confidence
+      belief.test_with_evidence!(evidence_type: :neutral)
+      expect(belief.confidence).to eq(before)
+    end
+
+    it 'nudges confidence toward 0.5 for ambiguous evidence when above' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.8)
+      before = b.confidence
+      b.test_with_evidence!(evidence_type: :ambiguous)
+      expect(b.confidence).to be < before
+    end
+
+    it 'nudges confidence toward 0.5 for ambiguous evidence when below' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.2)
+      before = b.confidence
+      b.test_with_evidence!(evidence_type: :ambiguous)
+      expect(b.confidence).to be > before
+    end
+
+    it 'tracks confirming_count' do
+      belief.test_with_evidence!(evidence_type: :confirming)
+      expect(belief.confirming_count).to eq(1)
+    end
+
+    it 'tracks disconfirming_count' do
+      belief.test_with_evidence!(evidence_type: :disconfirming)
+      expect(belief.disconfirming_count).to eq(1)
+    end
+
+    it 'raises for unknown evidence_type' do
+      expect { belief.test_with_evidence!(evidence_type: :unknown) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns self for chaining' do
+      result = belief.test_with_evidence!(evidence_type: :neutral)
+      expect(result).to be(belief)
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns :certain at 1.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 1.0)
+      expect(b.confidence_label).to eq(:certain)
+    end
+
+    it 'returns :tentative at 0.5' do
+      expect(belief.confidence_label).to eq(:tentative)
+    end
+
+    it 'returns :rejected near 0.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.05)
+      expect(b.confidence_label).to eq(:rejected)
+    end
+  end
+
+  describe '#validity' do
+    it 'returns 0.5 when no evidence' do
+      expect(belief.validity).to eq(0.5)
+    end
+
+    it 'returns 1.0 with only confirming evidence' do
+      3.times { belief.test_with_evidence!(evidence_type: :confirming) }
+      expect(belief.validity).to eq(1.0)
+    end
+
+    it 'returns 0.0 with only disconfirming evidence' do
+      3.times { belief.test_with_evidence!(evidence_type: :disconfirming) }
+      expect(belief.validity).to eq(0.0)
+    end
+
+    it 'returns 0.5 with equal confirming and disconfirming' do
+      belief.test_with_evidence!(evidence_type: :confirming)
+      belief.test_with_evidence!(evidence_type: :disconfirming)
+      expect(belief.validity).to eq(0.5)
+    end
+  end
+
+  describe '#validity_label' do
+    it 'returns :validated with all confirming' do
+      3.times { belief.test_with_evidence!(evidence_type: :confirming) }
+      expect(belief.validity_label).to eq(:validated)
+    end
+
+    it 'returns :refuted with all disconfirming' do
+      3.times { belief.test_with_evidence!(evidence_type: :disconfirming) }
+      expect(belief.validity_label).to eq(:refuted)
+    end
+  end
+
+  describe '#needs_testing?' do
+    it 'returns true at default confidence 0.5' do
+      expect(belief.needs_testing?).to be true
+    end
+
+    it 'returns false at high confidence' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.9)
+      expect(b.needs_testing?).to be false
+    end
+
+    it 'returns false at low confidence' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.1)
+      expect(b.needs_testing?).to be false
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces confidence by CONFIDENCE_DECAY' do
+      before = belief.confidence
+      belief.decay!
+      expect(belief.confidence).to be_within(0.001).of(before - 0.02)
+    end
+
+    it 'floors at 0.0' do
+      b = described_class.new(id: 'x', claim: 'test', confidence: 0.01)
+      b.decay!
+      expect(b.confidence).to eq(0.0)
+    end
+
+    it 'returns self' do
+      expect(belief.decay!).to be(belief)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = belief.to_h
+      expect(h).to include(
+        :id, :claim, :domain, :confidence, :confidence_label,
+        :evidence_count, :confirming_count, :disconfirming_count,
+        :validity, :validity_label, :needs_testing, :created_at, :last_tested_at
+      )
+    end
+
+    it 'sets last_tested_at after testing' do
+      belief.test_with_evidence!(evidence_type: :confirming)
+      expect(belief.to_h[:last_tested_at]).not_to be_nil
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::RealityTesting::Helpers::Constants do
+  subject(:mod) { described_class }
+
+  describe 'capacity constants' do
+    it 'defines MAX_BELIEFS as 300' do
+      expect(mod::MAX_BELIEFS).to eq(300)
+    end
+
+    it 'defines MAX_EVIDENCE as 500' do
+      expect(mod::MAX_EVIDENCE).to eq(500)
+    end
+  end
+
+  describe 'confidence constants' do
+    it 'defines DEFAULT_CONFIDENCE as 0.5' do
+      expect(mod::DEFAULT_CONFIDENCE).to eq(0.5)
+    end
+
+    it 'defines CONFIDENCE_BOOST as 0.1' do
+      expect(mod::CONFIDENCE_BOOST).to eq(0.1)
+    end
+
+    it 'defines CONFIDENCE_PENALTY as 0.15' do
+      expect(mod::CONFIDENCE_PENALTY).to eq(0.15)
+    end
+
+    it 'defines CONFIDENCE_DECAY as 0.02' do
+      expect(mod::CONFIDENCE_DECAY).to eq(0.02)
+    end
+  end
+
+  describe 'CONFIDENCE_LABELS' do
+    it 'returns :certain for 1.0' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(1.0) }[:label]
+      expect(label).to eq(:certain)
+    end
+
+    it 'returns :confident for 0.75' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(0.75) }[:label]
+      expect(label).to eq(:confident)
+    end
+
+    it 'returns :tentative for 0.5' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(0.5) }[:label]
+      expect(label).to eq(:tentative)
+    end
+
+    it 'returns :doubtful for 0.2' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(0.2) }[:label]
+      expect(label).to eq(:doubtful)
+    end
+
+    it 'returns :rejected for 0.05' do
+      label = mod::CONFIDENCE_LABELS.find { |e| e[:range].cover?(0.05) }[:label]
+      expect(label).to eq(:rejected)
+    end
+  end
+
+  describe 'EVIDENCE_TYPES' do
+    it 'includes all four types' do
+      expect(mod::EVIDENCE_TYPES).to eq(%i[confirming disconfirming neutral ambiguous])
+    end
+  end
+
+  describe 'VALIDITY_LABELS' do
+    it 'returns :validated for 0.9' do
+      label = mod::VALIDITY_LABELS.find { |e| e[:range].cover?(0.9) }[:label]
+      expect(label).to eq(:validated)
+    end
+
+    it 'returns :refuted for 0.05' do
+      label = mod::VALIDITY_LABELS.find { |e| e[:range].cover?(0.05) }[:label]
+      expect(label).to eq(:refuted)
+    end
+  end
+end

data/spec/legion/extensions/reality_testing/helpers/reality_engine_spec.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::RealityTesting::Helpers::RealityEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create_belief' do
+    it 'creates a belief and returns created: true' do
+      result = engine.create_belief(claim: 'All humans are mortal')
+      expect(result[:created]).to be true
+    end
+
+    it 'includes the belief hash in the result' do
+      result = engine.create_belief(claim: 'All humans are mortal')
+      expect(result[:belief]).to include(:id, :claim, :confidence)
+    end
+
+    it 'assigns sequential IDs' do
+      r1 = engine.create_belief(claim: 'claim 1')
+      r2 = engine.create_belief(claim: 'claim 2')
+      expect(r1[:belief][:id]).to eq('belief_1')
+      expect(r2[:belief][:id]).to eq('belief_2')
+    end
+
+    it 'respects custom domain' do
+      result = engine.create_belief(claim: 'test', domain: :science)
+      expect(result[:belief][:domain]).to eq(:science)
+    end
+
+    it 'respects custom confidence' do
+      result = engine.create_belief(claim: 'test', confidence: 0.8)
+      expect(result[:belief][:confidence]).to eq(0.8)
+    end
+
+    it 'returns at_capacity when MAX_BELIEFS reached' do
+      stub_const('Legion::Extensions::RealityTesting::Helpers::Constants::MAX_BELIEFS', 2)
+      engine.create_belief(claim: 'one')
+      engine.create_belief(claim: 'two')
+      result = engine.create_belief(claim: 'three')
+      expect(result[:created]).to be false
+      expect(result[:reason]).to eq(:at_capacity)
+    end
+  end
+
+  describe '#test_belief' do
+    let(:belief_id) do
+      engine.create_belief(claim: 'test claim')[:belief][:id]
+    end
+
+    it 'returns tested: true for known belief' do
+      result = engine.test_belief(belief_id: belief_id, evidence_type: :confirming)
+      expect(result[:tested]).to be true
+    end
+
+    it 'returns tested: false for unknown belief' do
+      result = engine.test_belief(belief_id: 'nope', evidence_type: :confirming)
+      expect(result[:tested]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+
+    it 'updates confidence after confirming evidence' do
+      before = engine.test_belief(belief_id: belief_id, evidence_type: :confirming)
+      expect(before[:belief][:confidence]).to be > 0.5
+    end
+
+    it 'updates confidence after disconfirming evidence' do
+      result = engine.test_belief(belief_id: belief_id, evidence_type: :disconfirming)
+      expect(result[:belief][:confidence]).to be < 0.5
+    end
+  end
+
+  describe '#beliefs_needing_testing' do
+    it 'returns beliefs with confidence between 0.3 and 0.7' do
+      engine.create_belief(claim: 'uncertain', confidence: 0.5)
+      engine.create_belief(claim: 'strong', confidence: 0.95)
+      engine.create_belief(claim: 'weak', confidence: 0.05)
+      result = engine.beliefs_needing_testing
+      expect(result.size).to eq(1)
+      expect(result.first.claim).to eq('uncertain')
+    end
+  end
+
+  describe '#strongest_beliefs' do
+    it 'returns beliefs sorted by descending confidence' do
+      engine.create_belief(claim: 'low', confidence: 0.2)
+      engine.create_belief(claim: 'high', confidence: 0.9)
+      engine.create_belief(claim: 'mid', confidence: 0.5)
+      result = engine.strongest_beliefs(limit: 2)
+      expect(result.first.claim).to eq('high')
+      expect(result.size).to eq(2)
+    end
+  end
+
+  describe '#weakest_beliefs' do
+    it 'returns beliefs sorted by ascending confidence' do
+      engine.create_belief(claim: 'low', confidence: 0.2)
+      engine.create_belief(claim: 'high', confidence: 0.9)
+      result = engine.weakest_beliefs(limit: 1)
+      expect(result.first.claim).to eq('low')
+    end
+  end
+
+  describe '#beliefs_by_domain' do
+    it 'filters beliefs by domain' do
+      engine.create_belief(claim: 'science fact', domain: :science)
+      engine.create_belief(claim: 'social fact', domain: :social)
+      result = engine.beliefs_by_domain(domain: :science)
+      expect(result.size).to eq(1)
+      expect(result.first.domain).to eq(:science)
+    end
+  end
+
+  describe '#overall_reality_coherence' do
+    it 'returns 0.0 with no beliefs' do
+      expect(engine.overall_reality_coherence).to eq(0.0)
+    end
+
+    it 'returns 0.5 with one belief and no evidence' do
+      engine.create_belief(claim: 'test')
+      expect(engine.overall_reality_coherence).to eq(0.5)
+    end
+
+    it 'increases toward 1.0 with confirming evidence' do
+      id = engine.create_belief(claim: 'test')[:belief][:id]
+      5.times { engine.test_belief(belief_id: id, evidence_type: :confirming) }
+      expect(engine.overall_reality_coherence).to be > 0.5
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all beliefs and returns count' do
+      engine.create_belief(claim: 'b1')
+      engine.create_belief(claim: 'b2')
+      count = engine.decay_all
+      expect(count).to eq(2)
+    end
+
+    it 'reduces confidence of each belief' do
+      id = engine.create_belief(claim: 'test')[:belief][:id]
+      belief_before = engine.instance_variable_get(:@beliefs)[id].confidence
+      engine.decay_all
+      belief_after = engine.instance_variable_get(:@beliefs)[id].confidence
+      expect(belief_after).to be < belief_before
+    end
+  end
+
+  describe '#prune_rejected' do
+    it 'removes beliefs with confidence below 0.1' do
+      id = engine.create_belief(claim: 'very weak', confidence: 0.05)[:belief][:id]
+      engine.create_belief(claim: 'strong', confidence: 0.8)
+      pruned = engine.prune_rejected
+      expect(pruned).to eq(1)
+      expect(engine.instance_variable_get(:@beliefs)).not_to have_key(id)
+    end
+
+    it 'returns 0 when nothing to prune' do
+      engine.create_belief(claim: 'ok', confidence: 0.5)
+      expect(engine.prune_rejected).to eq(0)
+    end
+  end
+
+  describe '#reality_report' do
+    it 'returns a report hash with required keys' do
+      engine.create_belief(claim: 'test')
+      report = engine.reality_report
+      expect(report).to include(:total_beliefs, :coherence, :needing_testing, :domains)
+    end
+
+    it 'reports total_beliefs correctly' do
+      engine.create_belief(claim: 'a')
+      engine.create_belief(claim: 'b')
+      expect(engine.reality_report[:total_beliefs]).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns belief_count and beliefs array' do
+      engine.create_belief(claim: 'one')
+      h = engine.to_h
+      expect(h[:belief_count]).to eq(1)
+      expect(h[:beliefs]).to be_an(Array)
+    end
+  end
+
+  describe '#size' do
+    it 'returns the number of stored beliefs' do
+      expect(engine.size).to eq(0)
+      engine.create_belief(claim: 'one')
+      expect(engine.size).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/reality_testing/runners/reality_testing_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/reality_testing/client'
+
+RSpec.describe Legion::Extensions::RealityTesting::Runners::RealityTesting do
+  let(:client) { Legion::Extensions::RealityTesting::Client.new }
+
+  describe '#create_belief' do
+    it 'creates a belief and returns created: true' do
+      result = client.create_belief(claim: 'Water boils at 100C')
+      expect(result[:created]).to be true
+    end
+
+    it 'uses default confidence when not specified' do
+      result = client.create_belief(claim: 'default conf')
+      expect(result[:belief][:confidence]).to eq(0.5)
+    end
+
+    it 'accepts custom confidence' do
+      result = client.create_belief(claim: 'high conf', confidence: 0.9)
+      expect(result[:belief][:confidence]).to eq(0.9)
+    end
+
+    it 'accepts custom domain' do
+      result = client.create_belief(claim: 'domain test', domain: :physics)
+      expect(result[:belief][:domain]).to eq(:physics)
+    end
+  end
+
+  describe '#test_belief' do
+    let(:belief_id) { client.create_belief(claim: 'testable')[:belief][:id] }
+
+    it 'returns tested: true for known belief' do
+      expect(client.test_belief(belief_id: belief_id, evidence_type: :confirming)[:tested]).to be true
+    end
+
+    it 'returns tested: false for unknown belief' do
+      result = client.test_belief(belief_id: 'ghost', evidence_type: :confirming)
+      expect(result[:tested]).to be false
+    end
+
+    it 'accepts string evidence_type' do
+      result = client.test_belief(belief_id: belief_id, evidence_type: 'confirming')
+      expect(result[:tested]).to be true
+    end
+
+    it 'increases confidence with confirming evidence' do
+      result = client.test_belief(belief_id: belief_id, evidence_type: :confirming)
+      expect(result[:belief][:confidence]).to be > 0.5
+    end
+
+    it 'decreases confidence with disconfirming evidence' do
+      result = client.test_belief(belief_id: belief_id, evidence_type: :disconfirming)
+      expect(result[:belief][:confidence]).to be < 0.5
+    end
+  end
+
+  describe '#get_belief' do
+    it 'returns found: true for existing belief' do
+      id = client.create_belief(claim: 'fetch me')[:belief][:id]
+      result = client.get_belief(belief_id: id)
+      expect(result[:found]).to be true
+      expect(result[:belief][:claim]).to eq('fetch me')
+    end
+
+    it 'returns found: false for missing belief' do
+      result = client.get_belief(belief_id: 'missing')
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#beliefs_needing_testing' do
+    it 'returns count and beliefs array' do
+      client.create_belief(claim: 'uncertain', confidence: 0.5)
+      result = client.beliefs_needing_testing
+      expect(result).to include(:count, :beliefs)
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#strongest_beliefs' do
+    it 'returns highest-confidence beliefs' do
+      client.create_belief(claim: 'weak', confidence: 0.2)
+      client.create_belief(claim: 'strong', confidence: 0.9)
+      result = client.strongest_beliefs(limit: 1)
+      expect(result[:beliefs].first[:claim]).to eq('strong')
+    end
+  end
+
+  describe '#weakest_beliefs' do
+    it 'returns lowest-confidence beliefs' do
+      client.create_belief(claim: 'weak', confidence: 0.2)
+      client.create_belief(claim: 'strong', confidence: 0.9)
+      result = client.weakest_beliefs(limit: 1)
+      expect(result[:beliefs].first[:claim]).to eq('weak')
+    end
+  end
+
+  describe '#beliefs_by_domain' do
+    it 'filters beliefs by domain' do
+      client.create_belief(claim: 'logic rule', domain: :logic)
+      client.create_belief(claim: 'social norm', domain: :social)
+      result = client.beliefs_by_domain(domain: :logic)
+      expect(result[:domain]).to eq(:logic)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#overall_coherence' do
+    it 'returns a coherence value between 0 and 1' do
+      client.create_belief(claim: 'test')
+      result = client.overall_coherence
+      expect(result[:coherence]).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#decay_beliefs' do
+    it 'returns the number of decayed beliefs' do
+      client.create_belief(claim: 'one')
+      result = client.decay_beliefs
+      expect(result[:decayed]).to eq(1)
+    end
+  end
+
+  describe '#prune_rejected_beliefs' do
+    it 'returns count of pruned beliefs' do
+      client.create_belief(claim: 'dead', confidence: 0.05)
+      result = client.prune_rejected_beliefs
+      expect(result[:pruned]).to eq(1)
+    end
+
+    it 'returns 0 when nothing pruned' do
+      client.create_belief(claim: 'alive', confidence: 0.8)
+      expect(client.prune_rejected_beliefs[:pruned]).to eq(0)
+    end
+  end
+
+  describe '#reality_report' do
+    it 'returns a full report hash' do
+      client.create_belief(claim: 'fact')
+      report = client.reality_report
+      expect(report).to include(:total_beliefs, :coherence, :needing_testing, :domains)
+    end
+  end
+
+  describe '#reality_status' do
+    it 'returns total_beliefs, coherence, needing_testing' do
+      client.create_belief(claim: 'status test')
+      result = client.reality_status
+      expect(result).to include(:total_beliefs, :coherence, :needing_testing)
+      expect(result[:total_beliefs]).to eq(1)
+    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/reality_testing'
+
+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-reality-testing
+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: Belief validation, evidence accumulation, and reality coherence for brain-modeled
+  agentic AI
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- lex-reality-testing.gemspec
+- lib/legion/extensions/reality_testing.rb
+- lib/legion/extensions/reality_testing/client.rb
+- lib/legion/extensions/reality_testing/helpers/belief.rb
+- lib/legion/extensions/reality_testing/helpers/constants.rb
+- lib/legion/extensions/reality_testing/helpers/reality_engine.rb
+- lib/legion/extensions/reality_testing/runners/reality_testing.rb
+- lib/legion/extensions/reality_testing/version.rb
+- spec/legion/extensions/reality_testing/client_spec.rb
+- spec/legion/extensions/reality_testing/helpers/belief_spec.rb
+- spec/legion/extensions/reality_testing/helpers/constants_spec.rb
+- spec/legion/extensions/reality_testing/helpers/reality_engine_spec.rb
+- spec/legion/extensions/reality_testing/runners/reality_testing_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-reality-testing
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-reality-testing
+  source_code_uri: https://github.com/LegionIO/lex-reality-testing
+  documentation_uri: https://github.com/LegionIO/lex-reality-testing
+  changelog_uri: https://github.com/LegionIO/lex-reality-testing
+  bug_tracker_uri: https://github.com/LegionIO/lex-reality-testing/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 Reality Testing
+test_files: []