lex-agentic-defense 0.1.0

data/spec/legion/extensions/agentic/defense/confabulation/runners/confabulation_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/confabulation/client'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Confabulation::Runners::Confabulation do
+  let(:client) { Legion::Extensions::Agentic::Defense::Confabulation::Client.new }
+
+  describe '#register_claim' do
+    it 'returns a claim hash with an id' do
+      result = client.register_claim(content: 'Pigeons navigate by smell', claim_type: :factual,
+                                     confidence: 0.7, evidence_strength: 0.2)
+      expect(result[:id]).not_to be_nil
+      expect(result[:claim_type]).to eq(:factual)
+    end
+
+    it 'includes confabulation_risk and risk_label' do
+      result = client.register_claim(content: 'x', claim_type: :causal, confidence: 0.9, evidence_strength: 0.1)
+      expect(result).to have_key(:confabulation_risk)
+      expect(result).to have_key(:risk_label)
+    end
+
+    it 'accepts all valid claim types' do
+      Legion::Extensions::Agentic::Defense::Confabulation::Helpers::Constants::CLAIM_TYPES.each do |type|
+        result = client.register_claim(content: 'x', claim_type: type, confidence: 0.5, evidence_strength: 0.5)
+        expect(result[:claim_type]).to eq(type)
+      end
+    end
+  end
+
+  describe '#verify_claim' do
+    it 'verifies an existing claim' do
+      claim = client.register_claim(content: 'testable fact', claim_type: :factual,
+                                    confidence: 0.6, evidence_strength: 0.6)
+      result = client.verify_claim(claim_id: claim[:id])
+      expect(result[:found]).to be true
+      expect(result[:verified]).to be true
+    end
+
+    it 'returns found: false for a missing claim' do
+      result = client.verify_claim(claim_id: 'does-not-exist')
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#flag_confabulation' do
+    it 'flags an existing claim as confabulated' do
+      claim = client.register_claim(content: 'false memory', claim_type: :autobiographical,
+                                    confidence: 0.9, evidence_strength: 0.05)
+      result = client.flag_confabulation(claim_id: claim[:id])
+      expect(result[:found]).to be true
+      expect(result[:confabulated]).to be true
+    end
+
+    it 'returns found: false for a missing claim' do
+      result = client.flag_confabulation(claim_id: 'no-such-id')
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#confabulation_report' do
+    it 'returns a report hash' do
+      client.register_claim(content: 'risky', claim_type: :factual, confidence: 0.9, evidence_strength: 0.05)
+      report = client.confabulation_report
+      expect(report[:total_claims]).to eq(1)
+      expect(report[:risk_label]).to be_a(Symbol)
+    end
+
+    it 'includes overall_risk and average_calibration' do
+      report = client.confabulation_report
+      expect(report).to have_key(:overall_risk)
+      expect(report).to have_key(:average_calibration)
+    end
+  end
+
+  describe '#high_risk_claims' do
+    it 'returns claims above the threshold' do
+      client.register_claim(content: 'overconfident', claim_type: :predictive,
+                            confidence: 0.95, evidence_strength: 0.05)
+      client.register_claim(content: 'calibrated', claim_type: :predictive,
+                            confidence: 0.5, evidence_strength: 0.5)
+      result = client.high_risk_claims
+      expect(result[:count]).to eq(1)
+      expect(result[:claims].first[:content]).to eq('overconfident')
+    end
+
+    it 'returns empty list when no high-risk claims' do
+      client.register_claim(content: 'ok', claim_type: :factual, confidence: 0.5, evidence_strength: 0.5)
+      result = client.high_risk_claims
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#confabulation_status' do
+    it 'returns engine summary' do
+      result = client.confabulation_status
+      expect(result[:engine]).to have_key(:claim_count)
+      expect(result[:engine]).to have_key(:confabulation_rate)
+      expect(result[:engine]).to have_key(:average_calibration)
+    end
+  end
+
+  describe 'full cycle' do
+    it 'registers, verifies, flags and reports correctly' do
+      c1 = client.register_claim(content: 'valid fact', claim_type: :factual,
+                                 confidence: 0.6, evidence_strength: 0.6)
+      c2 = client.register_claim(content: 'false memory', claim_type: :autobiographical,
+                                 confidence: 0.9, evidence_strength: 0.05)
+
+      client.verify_claim(claim_id: c1[:id])
+      client.flag_confabulation(claim_id: c2[:id])
+
+      report = client.confabulation_report
+      expect(report[:total_claims]).to eq(2)
+      expect(report[:verified_claims]).to eq(1)
+      expect(report[:confabulated_claims]).to eq(1)
+      expect(report[:confabulation_rate]).to be_within(0.001).of(0.5)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/dissonance/client_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/dissonance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Dissonance::Client do
+  describe '#initialize' do
+    it 'creates a default DissonanceModel when none provided' do
+      client = described_class.new
+      expect(client.model).to be_a(Legion::Extensions::Agentic::Defense::Dissonance::Helpers::DissonanceModel)
+    end
+
+    it 'accepts a custom model' do
+      custom_model = Legion::Extensions::Agentic::Defense::Dissonance::Helpers::DissonanceModel.new
+      client = described_class.new(model: custom_model)
+      expect(client.model).to be(custom_model)
+    end
+  end
+
+  describe 'responds to all runner methods' do
+    let(:client) { described_class.new }
+
+    it { expect(client).to respond_to(:add_belief) }
+    it { expect(client).to respond_to(:update_dissonance) }
+    it { expect(client).to respond_to(:resolve_dissonance) }
+    it { expect(client).to respond_to(:dissonance_status) }
+    it { expect(client).to respond_to(:domain_dissonance) }
+    it { expect(client).to respond_to(:beliefs_for) }
+    it { expect(client).to respond_to(:unresolved) }
+    it { expect(client).to respond_to(:dissonance_stats) }
+  end
+
+  describe 'state isolation between instances' do
+    it 'two clients do not share belief state' do
+      client1 = described_class.new
+      client2 = described_class.new
+      client1.add_belief(domain: 'x', content: 'some belief')
+      result = client2.beliefs_for(domain: 'x')
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe 'custom model integration' do
+    it 'uses the beliefs already in a pre-populated model' do
+      model = Legion::Extensions::Agentic::Defense::Dissonance::Helpers::DissonanceModel.new
+      model.add_belief(domain: 'shared', content: 'a shared belief')
+      client = described_class.new(model: model)
+      result = client.beliefs_for(domain: 'shared')
+      expect(result[:count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/dissonance/helpers/belief_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Dissonance::Helpers::Belief do
+  let(:belief) { described_class.new(domain: 'ethics', content: 'honesty is required', confidence: 0.9, importance: :core) }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(belief.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns domain' do
+      expect(belief.domain).to eq('ethics')
+    end
+
+    it 'assigns content' do
+      expect(belief.content).to eq('honesty is required')
+    end
+
+    it 'assigns confidence' do
+      expect(belief.confidence).to eq(0.9)
+    end
+
+    it 'assigns importance' do
+      expect(belief.importance).to eq(:core)
+    end
+
+    it 'assigns created_at as UTC Time' do
+      expect(belief.created_at).to be_a(Time)
+    end
+
+    it 'clamps confidence to 0-1 range (above)' do
+      b = described_class.new(domain: 'd', content: 'c', confidence: 1.5)
+      expect(b.confidence).to eq(1.0)
+    end
+
+    it 'clamps confidence to 0-1 range (below)' do
+      b = described_class.new(domain: 'd', content: 'c', confidence: -0.5)
+      expect(b.confidence).to eq(0.0)
+    end
+
+    it 'defaults confidence to 0.7' do
+      b = described_class.new(domain: 'd', content: 'c')
+      expect(b.confidence).to eq(0.7)
+    end
+
+    it 'defaults importance to :moderate' do
+      b = described_class.new(domain: 'd', content: 'c')
+      expect(b.importance).to eq(:moderate)
+    end
+  end
+
+  describe '#contradicts?' do
+    let(:other_same) do
+      described_class.new(domain: 'ethics', content: 'honesty is required', confidence: 0.8, importance: :moderate)
+    end
+
+    let(:other_different) do
+      described_class.new(domain: 'ethics', content: 'deception is acceptable', confidence: 0.6, importance: :moderate)
+    end
+
+    let(:other_domain) do
+      described_class.new(domain: 'safety', content: 'honesty is required', confidence: 0.8, importance: :moderate)
+    end
+
+    it 'returns false for same content' do
+      expect(belief.contradicts?(other_same)).to be false
+    end
+
+    it 'returns true for different content in same domain' do
+      expect(belief.contradicts?(other_different)).to be true
+    end
+
+    it 'returns false for different domain' do
+      expect(belief.contradicts?(other_domain)).to be false
+    end
+
+    it 'returns false when compared to itself' do
+      expect(belief.contradicts?(belief)).to be false
+    end
+
+    it 'is case-insensitive for content comparison' do
+      upper = described_class.new(domain: 'ethics', content: 'HONESTY IS REQUIRED', confidence: 0.8, importance: :moderate)
+      expect(belief.contradicts?(upper)).to be false
+    end
+
+    it 'ignores leading/trailing whitespace in content comparison' do
+      padded = described_class.new(domain: 'ethics', content: '  honesty is required  ', confidence: 0.8, importance: :moderate)
+      expect(belief.contradicts?(padded)).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all fields' do
+      h = belief.to_h
+      expect(h[:id]).to eq(belief.id)
+      expect(h[:domain]).to eq('ethics')
+      expect(h[:content]).to eq('honesty is required')
+      expect(h[:confidence]).to eq(0.9)
+      expect(h[:importance]).to eq(:core)
+      expect(h[:created_at]).to be_a(Time)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/dissonance/helpers/constants_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Dissonance::Helpers::Constants do
+  it 'defines DISSONANCE_THRESHOLD' do
+    expect(described_class::DISSONANCE_THRESHOLD).to eq(0.4)
+  end
+
+  it 'defines MAX_BELIEFS' do
+    expect(described_class::MAX_BELIEFS).to eq(200)
+  end
+
+  it 'defines MAX_DISSONANCE_EVENTS' do
+    expect(described_class::MAX_DISSONANCE_EVENTS).to eq(100)
+  end
+
+  it 'defines DECAY_RATE' do
+    expect(described_class::DECAY_RATE).to eq(0.03)
+  end
+
+  it 'defines RESOLUTION_RELIEF' do
+    expect(described_class::RESOLUTION_RELIEF).to eq(0.3)
+  end
+
+  it 'defines RATIONALIZATION_FACTOR' do
+    expect(described_class::RATIONALIZATION_FACTOR).to eq(0.5)
+  end
+
+  it 'defines IMPORTANCE_WEIGHTS with four levels' do
+    weights = described_class::IMPORTANCE_WEIGHTS
+    expect(weights[:core]).to eq(1.0)
+    expect(weights[:significant]).to eq(0.7)
+    expect(weights[:moderate]).to eq(0.5)
+    expect(weights[:peripheral]).to eq(0.25)
+  end
+
+  it 'defines RESOLUTION_STRATEGIES' do
+    expect(described_class::RESOLUTION_STRATEGIES).to contain_exactly(:belief_revision, :rationalization, :avoidance)
+  end
+
+  it 'defines STRESS_CEILING and STRESS_FLOOR' do
+    expect(described_class::STRESS_CEILING).to eq(1.0)
+    expect(described_class::STRESS_FLOOR).to eq(0.0)
+  end
+
+  it 'defines CONTRADICTION_TYPES' do
+    expect(described_class::CONTRADICTION_TYPES).to contain_exactly(:direct, :inverse, :conditional, :temporal)
+  end
+
+  it 'freezes IMPORTANCE_WEIGHTS' do
+    expect(described_class::IMPORTANCE_WEIGHTS).to be_frozen
+  end
+
+  it 'freezes RESOLUTION_STRATEGIES' do
+    expect(described_class::RESOLUTION_STRATEGIES).to be_frozen
+  end
+
+  it 'freezes CONTRADICTION_TYPES' do
+    expect(described_class::CONTRADICTION_TYPES).to be_frozen
+  end
+end

data/spec/legion/extensions/agentic/defense/dissonance/helpers/dissonance_event_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Dissonance::Helpers::DissonanceEvent do
+  let(:event) do
+    described_class.new(
+      belief_a_id:        'uuid-a',
+      belief_b_id:        'uuid-b',
+      domain:             'ethics',
+      magnitude:          0.6,
+      contradiction_type: :direct
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(event.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns belief_a_id' do
+      expect(event.belief_a_id).to eq('uuid-a')
+    end
+
+    it 'assigns belief_b_id' do
+      expect(event.belief_b_id).to eq('uuid-b')
+    end
+
+    it 'assigns domain' do
+      expect(event.domain).to eq('ethics')
+    end
+
+    it 'assigns magnitude' do
+      expect(event.magnitude).to eq(0.6)
+    end
+
+    it 'assigns contradiction_type' do
+      expect(event.contradiction_type).to eq(:direct)
+    end
+
+    it 'starts as unresolved' do
+      expect(event.resolved).to be false
+    end
+
+    it 'starts with nil resolution_strategy' do
+      expect(event.resolution_strategy).to be_nil
+    end
+
+    it 'assigns timestamp as UTC Time' do
+      expect(event.timestamp).to be_a(Time)
+    end
+
+    it 'clamps magnitude above 1.0' do
+      ev = described_class.new(belief_a_id: 'a', belief_b_id: 'b', domain: 'd', magnitude: 1.5)
+      expect(ev.magnitude).to eq(1.0)
+    end
+
+    it 'clamps magnitude below 0.0' do
+      ev = described_class.new(belief_a_id: 'a', belief_b_id: 'b', domain: 'd', magnitude: -0.5)
+      expect(ev.magnitude).to eq(0.0)
+    end
+
+    it 'defaults contradiction_type to :direct' do
+      ev = described_class.new(belief_a_id: 'a', belief_b_id: 'b', domain: 'd', magnitude: 0.5)
+      expect(ev.contradiction_type).to eq(:direct)
+    end
+  end
+
+  describe '#resolve!' do
+    it 'marks the event as resolved' do
+      event.resolve!(:belief_revision)
+      expect(event.resolved).to be true
+    end
+
+    it 'records the resolution strategy' do
+      event.resolve!(:rationalization)
+      expect(event.resolution_strategy).to eq(:rationalization)
+    end
+
+    it 'returns self for chaining' do
+      result = event.resolve!(:avoidance)
+      expect(result).to be(event)
+    end
+
+    it 'can be resolved with any valid strategy' do
+      Legion::Extensions::Agentic::Defense::Dissonance::Helpers::Constants::RESOLUTION_STRATEGIES.each do |strategy|
+        ev = described_class.new(belief_a_id: 'a', belief_b_id: 'b', domain: 'd', magnitude: 0.5)
+        ev.resolve!(strategy)
+        expect(ev.resolution_strategy).to eq(strategy)
+      end
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash with all fields when unresolved' do
+      h = event.to_h
+      expect(h[:id]).to eq(event.id)
+      expect(h[:belief_a_id]).to eq('uuid-a')
+      expect(h[:belief_b_id]).to eq('uuid-b')
+      expect(h[:domain]).to eq('ethics')
+      expect(h[:magnitude]).to eq(0.6)
+      expect(h[:contradiction_type]).to eq(:direct)
+      expect(h[:resolved]).to be false
+      expect(h[:resolution_strategy]).to be_nil
+      expect(h[:timestamp]).to be_a(Time)
+    end
+
+    it 'reflects resolved state in to_h' do
+      event.resolve!(:belief_revision)
+      h = event.to_h
+      expect(h[:resolved]).to be true
+      expect(h[:resolution_strategy]).to eq(:belief_revision)
+    end
+  end
+end