lex-agentic-defense 0.1.0

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

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Dissonance::Helpers::DissonanceModel do
+  subject(:model) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty beliefs' do
+      expect(model.beliefs).to be_empty
+    end
+
+    it 'starts with empty events' do
+      expect(model.events).to be_empty
+    end
+
+    it 'starts with zero stress' do
+      expect(model.stress).to eq(0.0)
+    end
+  end
+
+  describe '#add_belief' do
+    it 'adds a belief to the model' do
+      model.add_belief(domain: 'ethics', content: 'honesty matters', confidence: 0.8, importance: :core)
+      expect(model.beliefs.size).to eq(1)
+    end
+
+    it 'returns the new belief and empty events for first belief in domain' do
+      result = model.add_belief(domain: 'ethics', content: 'honesty matters')
+      expect(result[:belief]).to be_a(Legion::Extensions::Agentic::Defense::Dissonance::Helpers::Belief)
+      expect(result[:new_dissonance_events]).to be_empty
+    end
+
+    it 'detects contradiction between beliefs in the same domain' do
+      model.add_belief(domain: 'safety', content: 'always ask permission')
+      result = model.add_belief(domain: 'safety', content: 'act autonomously')
+      expect(result[:new_dissonance_events].size).to eq(1)
+    end
+
+    it 'does not detect contradiction for same content' do
+      model.add_belief(domain: 'safety', content: 'always ask permission')
+      result = model.add_belief(domain: 'safety', content: 'always ask permission')
+      expect(result[:new_dissonance_events]).to be_empty
+    end
+
+    it 'does not create duplicate contradiction events for the same pair' do
+      model.add_belief(domain: 'safety', content: 'always ask permission')
+      result1 = model.add_belief(domain: 'safety', content: 'act autonomously')
+      ev_id = result1[:new_dissonance_events].first.id
+      # Artificially call detect_contradictions again — no new events since pair is tracked
+      new_evs = model.detect_contradictions
+      expect(new_evs).to be_empty
+      expect(model.events.size).to eq(1)
+      expect(model.events.key?(ev_id)).to be true
+    end
+
+    it 'does not create contradiction across different domains' do
+      model.add_belief(domain: 'ethics', content: 'be transparent')
+      result = model.add_belief(domain: 'safety', content: 'act differently')
+      expect(result[:new_dissonance_events]).to be_empty
+    end
+
+    it 'stores the belief with the correct importance weight' do
+      result = model.add_belief(domain: 'ethics', content: 'test', importance: :significant)
+      expect(result[:belief].importance).to eq(:significant)
+    end
+  end
+
+  describe '#detect_contradictions' do
+    it 'returns empty array when no contradictions exist' do
+      model.add_belief(domain: 'ethics', content: 'honesty matters')
+      expect(model.detect_contradictions).to be_empty
+    end
+
+    it 'finds untracked contradictions among existing beliefs' do
+      b1 = Legion::Extensions::Agentic::Defense::Dissonance::Helpers::Belief.new(domain: 'ethics', content: 'be honest')
+      b2 = Legion::Extensions::Agentic::Defense::Dissonance::Helpers::Belief.new(domain: 'ethics', content: 'deceive when needed')
+      model.beliefs[b1.id] = b1
+      model.beliefs[b2.id] = b2
+      new_events = model.detect_contradictions
+      expect(new_events.size).to eq(1)
+    end
+
+    it 'does not re-detect already tracked contradictions' do
+      model.add_belief(domain: 'ethics', content: 'tell truth')
+      model.add_belief(domain: 'ethics', content: 'lie sometimes')
+      model.detect_contradictions
+      second_run = model.detect_contradictions
+      expect(second_run).to be_empty
+    end
+  end
+
+  describe '#resolve' do
+    let(:event_id) do
+      model.add_belief(domain: 'ethics', content: 'be honest')
+      result = model.add_belief(domain: 'ethics', content: 'deceive when useful')
+      result[:new_dissonance_events].first.id
+    end
+
+    it 'returns the resolved event' do
+      event = model.resolve(event_id, strategy: :belief_revision)
+      expect(event).to be_a(Legion::Extensions::Agentic::Defense::Dissonance::Helpers::DissonanceEvent)
+      expect(event.resolved).to be true
+    end
+
+    it 'reduces stress after belief_revision resolution' do
+      model.add_belief(domain: 'ethics', content: 'be honest')
+      result = model.add_belief(domain: 'ethics', content: 'deceive when useful')
+      ev_id = result[:new_dissonance_events].first.id
+      model.decay
+      stress_before = model.stress
+      model.resolve(ev_id, strategy: :belief_revision)
+      expect(model.stress).to be < stress_before
+    end
+
+    it 'reduces stress less with rationalization than belief_revision' do
+      model2 = described_class.new
+      model.add_belief(domain: 'domain', content: 'claim a')
+      ev_id_m1 = model.add_belief(domain: 'domain', content: 'claim b')[:new_dissonance_events].first.id
+      model2.add_belief(domain: 'domain', content: 'claim a')
+      ev_id_m2 = model2.add_belief(domain: 'domain', content: 'claim b')[:new_dissonance_events].first.id
+      # Build up enough stress so that relief amounts differ meaningfully after clamping
+      15.times { model.decay }
+      15.times { model2.decay }
+      model.resolve(ev_id_m1, strategy: :belief_revision)
+      model2.resolve(ev_id_m2, strategy: :rationalization)
+      expect(model.stress).to be < model2.stress
+    end
+
+    it 'returns nil for unknown event_id' do
+      expect(model.resolve('non-existent-id', strategy: :belief_revision)).to be_nil
+    end
+
+    it 'returns nil if already resolved' do
+      model.add_belief(domain: 'ethics', content: 'be honest')
+      result = model.add_belief(domain: 'ethics', content: 'deceive when useful')
+      ev_id = result[:new_dissonance_events].first.id
+      model.resolve(ev_id, strategy: :belief_revision)
+      expect(model.resolve(ev_id, strategy: :rationalization)).to be_nil
+    end
+
+    it 'returns nil for invalid strategy' do
+      model.add_belief(domain: 'x', content: 'a')
+      result = model.add_belief(domain: 'x', content: 'b')
+      ev_id = result[:new_dissonance_events].first.id
+      expect(model.resolve(ev_id, strategy: :invalid_strategy)).to be_nil
+    end
+  end
+
+  describe '#stress_level' do
+    it 'returns 0.0 initially' do
+      expect(model.stress_level).to eq(0.0)
+    end
+
+    it 'increases after decay with unresolved events' do
+      model.add_belief(domain: 'x', content: 'a')
+      model.add_belief(domain: 'x', content: 'b')
+      model.decay
+      expect(model.stress_level).to be > 0.0
+    end
+  end
+
+  describe '#domain_stress' do
+    it 'returns 0.0 for a domain with no unresolved events' do
+      expect(model.domain_stress('ethics')).to eq(0.0)
+    end
+
+    it 'returns positive stress for domain with unresolved events' do
+      model.add_belief(domain: 'ethics', content: 'be honest')
+      model.add_belief(domain: 'ethics', content: 'hide truth')
+      expect(model.domain_stress('ethics')).to be > 0.0
+    end
+
+    it 'returns 0.0 for a domain after all events resolved' do
+      model.add_belief(domain: 'ethics', content: 'be honest')
+      result = model.add_belief(domain: 'ethics', content: 'hide truth')
+      ev_id = result[:new_dissonance_events].first.id
+      model.resolve(ev_id, strategy: :belief_revision)
+      expect(model.domain_stress('ethics')).to eq(0.0)
+    end
+  end
+
+  describe '#unresolved_events' do
+    it 'returns empty list when no events' do
+      expect(model.unresolved_events).to be_empty
+    end
+
+    it 'returns only unresolved events' do
+      model.add_belief(domain: 'x', content: 'a')
+      result = model.add_belief(domain: 'x', content: 'b')
+      ev_id = result[:new_dissonance_events].first.id
+      model.resolve(ev_id, strategy: :belief_revision)
+
+      model.add_belief(domain: 'y', content: 'p')
+      model.add_belief(domain: 'y', content: 'q')
+
+      unresolved = model.unresolved_events
+      expect(unresolved.all? { |ev| !ev.resolved }).to be true
+    end
+  end
+
+  describe '#decay' do
+    it 'increases stress when there are unresolved events' do
+      model.add_belief(domain: 'x', content: 'a')
+      model.add_belief(domain: 'x', content: 'b')
+      initial_stress = model.stress
+      model.decay
+      expect(model.stress).to be > initial_stress
+    end
+
+    it 'decreases stress when there are no unresolved events' do
+      model.instance_variable_set(:@stress, 0.5)
+      model.decay
+      expect(model.stress).to be < 0.5
+    end
+
+    it 'does not exceed STRESS_CEILING' do
+      model.instance_variable_set(:@stress, 0.99)
+      100.times { model.add_belief(domain: 'x', content: "belief_#{rand}") }
+      model.decay
+      expect(model.stress).to be <= 1.0
+    end
+
+    it 'does not go below STRESS_FLOOR' do
+      model.decay
+      expect(model.stress).to be >= 0.0
+    end
+
+    it 'returns the current stress value' do
+      result = model.decay
+      expect(result).to eq(model.stress)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a snapshot hash' do
+      model.add_belief(domain: 'ethics', content: 'test')
+      h = model.to_h
+      expect(h[:beliefs]).to be_an(Array)
+      expect(h[:events]).to be_an(Array)
+      expect(h[:stress]).to eq(model.stress)
+      expect(h[:total_beliefs]).to eq(1)
+      expect(h[:total_events]).to eq(0)
+      expect(h[:unresolved_count]).to eq(0)
+    end
+
+    it 'counts unresolved events correctly' do
+      model.add_belief(domain: 'x', content: 'a')
+      model.add_belief(domain: 'x', content: 'b')
+      h = model.to_h
+      expect(h[:unresolved_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/dissonance/runners/dissonance_spec.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/dissonance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Dissonance::Runners::Dissonance do
+  let(:client) { Legion::Extensions::Agentic::Defense::Dissonance::Client.new }
+
+  describe '#add_belief' do
+    it 'returns success true with a belief_id' do
+      result = client.add_belief(domain: 'ethics', content: 'honesty is required')
+      expect(result[:success]).to be true
+      expect(result[:belief_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns the domain' do
+      result = client.add_belief(domain: 'ethics', content: 'test')
+      expect(result[:domain]).to eq('ethics')
+    end
+
+    it 'returns empty new_dissonance_events for first belief in domain' do
+      result = client.add_belief(domain: 'ethics', content: 'honesty is required')
+      expect(result[:new_dissonance_events]).to be_empty
+    end
+
+    it 'returns dissonance events when contradiction detected' do
+      client.add_belief(domain: 'safety', content: 'always ask permission')
+      result = client.add_belief(domain: 'safety', content: 'act without asking')
+      expect(result[:new_dissonance_events].size).to eq(1)
+    end
+
+    it 'sets dissonance_triggered when magnitude >= threshold' do
+      client.add_belief(domain: 'ethics', content: 'tell the truth', confidence: 1.0, importance: :core)
+      result = client.add_belief(domain: 'ethics', content: 'lie when convenient', confidence: 1.0, importance: :core)
+      expect(result[:dissonance_triggered]).to be true
+    end
+
+    it 'returns success false for invalid importance' do
+      result = client.add_belief(domain: 'ethics', content: 'test', importance: :invalid)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_importance)
+    end
+
+    it 'returns valid importance levels on error' do
+      result = client.add_belief(domain: 'ethics', content: 'test', importance: :invalid)
+      expect(result[:valid]).to contain_exactly(:core, :significant, :moderate, :peripheral)
+    end
+
+    it 'accepts all valid importance levels' do
+      %i[core significant moderate peripheral].each do |imp|
+        result = client.add_belief(domain: 'test', content: "content_#{imp}", importance: imp)
+        expect(result[:success]).to be true
+      end
+    end
+  end
+
+  describe '#update_dissonance' do
+    it 'returns success true' do
+      result = client.update_dissonance
+      expect(result[:success]).to be true
+    end
+
+    it 'returns current stress' do
+      result = client.update_dissonance
+      expect(result[:stress]).to be_a(Float)
+      expect(result[:stress]).to be_between(0.0, 1.0)
+    end
+
+    it 'returns unresolved_count' do
+      result = client.update_dissonance
+      expect(result[:unresolved_count]).to eq(0)
+    end
+
+    it 'above_threshold is false when no unresolved events' do
+      result = client.update_dissonance
+      expect(result[:above_threshold]).to be false
+    end
+
+    it 'above_threshold is true when high-magnitude unresolved events exist' do
+      client.add_belief(domain: 'x', content: 'a', confidence: 1.0, importance: :core)
+      client.add_belief(domain: 'x', content: 'b', confidence: 1.0, importance: :core)
+      result = client.update_dissonance
+      expect(result[:above_threshold]).to be true
+    end
+
+    it 'increases unresolved_count after adding contradictions' do
+      client.add_belief(domain: 'y', content: 'claim1')
+      client.add_belief(domain: 'y', content: 'claim2')
+      result = client.update_dissonance
+      expect(result[:unresolved_count]).to eq(1)
+    end
+  end
+
+  describe '#resolve_dissonance' do
+    let(:event_id) do
+      client.add_belief(domain: 'ethics', content: 'be honest')
+      result = client.add_belief(domain: 'ethics', content: 'deceive when convenient')
+      result[:new_dissonance_events].first[:id]
+    end
+
+    it 'returns success true on valid resolution' do
+      result = client.resolve_dissonance(event_id: event_id, strategy: :belief_revision)
+      expect(result[:success]).to be true
+      expect(result[:resolved]).to be true
+    end
+
+    it 'returns the strategy used' do
+      result = client.resolve_dissonance(event_id: event_id, strategy: :rationalization)
+      expect(result[:strategy]).to eq(:rationalization)
+    end
+
+    it 'returns the event hash' do
+      result = client.resolve_dissonance(event_id: event_id, strategy: :belief_revision)
+      expect(result[:event]).to be_a(Hash)
+      expect(result[:event][:resolved]).to be true
+    end
+
+    it 'returns success false for invalid strategy' do
+      result = client.resolve_dissonance(event_id: event_id, strategy: :magic)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_strategy)
+    end
+
+    it 'returns valid strategies on invalid strategy error' do
+      result = client.resolve_dissonance(event_id: event_id, strategy: :magic)
+      expect(result[:valid]).to eq(Legion::Extensions::Agentic::Defense::Dissonance::Helpers::Constants::RESOLUTION_STRATEGIES)
+    end
+
+    it 'returns success false for unknown event_id' do
+      result = client.resolve_dissonance(event_id: 'no-such-id', strategy: :belief_revision)
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:not_found_or_already_resolved)
+    end
+
+    it 'returns success false when event already resolved' do
+      client.resolve_dissonance(event_id: event_id, strategy: :belief_revision)
+      result = client.resolve_dissonance(event_id: event_id, strategy: :rationalization)
+      expect(result[:success]).to be false
+    end
+
+    it 'defaults strategy to belief_revision' do
+      result = client.resolve_dissonance(event_id: event_id)
+      expect(result[:strategy]).to eq(:belief_revision)
+    end
+
+    it 'works with all three resolution strategies' do
+      %i[belief_revision rationalization avoidance].each_with_index do |strategy, i|
+        c = Legion::Extensions::Agentic::Defense::Dissonance::Client.new
+        c.add_belief(domain: 'domain', content: "a#{i}")
+        inner_result = c.add_belief(domain: 'domain', content: "b#{i}")
+        ev_id = inner_result[:new_dissonance_events].first[:id]
+        result = c.resolve_dissonance(event_id: ev_id, strategy: strategy)
+        expect(result[:success]).to be true
+      end
+    end
+  end
+
+  describe '#dissonance_status' do
+    it 'returns success true' do
+      result = client.dissonance_status
+      expect(result[:success]).to be true
+    end
+
+    it 'returns stress value' do
+      result = client.dissonance_status
+      expect(result[:stress]).to be_a(Float)
+    end
+
+    it 'returns total_beliefs count' do
+      client.add_belief(domain: 'x', content: 'test')
+      result = client.dissonance_status
+      expect(result[:total_beliefs]).to eq(1)
+    end
+
+    it 'returns total_events count' do
+      client.add_belief(domain: 'x', content: 'a')
+      client.add_belief(domain: 'x', content: 'b')
+      result = client.dissonance_status
+      expect(result[:total_events]).to eq(1)
+    end
+
+    it 'returns unresolved_count' do
+      result = client.dissonance_status
+      expect(result[:unresolved_count]).to eq(0)
+    end
+  end
+
+  describe '#domain_dissonance' do
+    it 'returns success true' do
+      result = client.domain_dissonance(domain: 'ethics')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns the domain' do
+      result = client.domain_dissonance(domain: 'ethics')
+      expect(result[:domain]).to eq('ethics')
+    end
+
+    it 'returns 0.0 stress for domain with no beliefs' do
+      result = client.domain_dissonance(domain: 'ethics')
+      expect(result[:stress]).to eq(0.0)
+    end
+
+    it 'returns positive stress for domain with contradictions' do
+      client.add_belief(domain: 'ethics', content: 'be honest')
+      client.add_belief(domain: 'ethics', content: 'hide truth')
+      result = client.domain_dissonance(domain: 'ethics')
+      expect(result[:stress]).to be > 0.0
+    end
+
+    it 'returns unresolved events for the domain' do
+      client.add_belief(domain: 'ethics', content: 'be honest')
+      client.add_belief(domain: 'ethics', content: 'hide truth')
+      result = client.domain_dissonance(domain: 'ethics')
+      expect(result[:events].size).to eq(1)
+      expect(result[:events].first[:domain]).to eq('ethics')
+    end
+
+    it 'does not include events from other domains' do
+      client.add_belief(domain: 'ethics', content: 'be honest')
+      client.add_belief(domain: 'ethics', content: 'hide truth')
+      client.add_belief(domain: 'safety', content: 'claim x')
+      client.add_belief(domain: 'safety', content: 'claim y')
+      result = client.domain_dissonance(domain: 'ethics')
+      expect(result[:events].all? { |ev| ev[:domain] == 'ethics' }).to be true
+    end
+  end
+
+  describe '#beliefs_for' do
+    it 'returns success true' do
+      result = client.beliefs_for(domain: 'ethics')
+      expect(result[:success]).to be true
+    end
+
+    it 'returns empty beliefs for unknown domain' do
+      result = client.beliefs_for(domain: 'unknown')
+      expect(result[:beliefs]).to be_empty
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns beliefs for a domain' do
+      client.add_belief(domain: 'ethics', content: 'test belief')
+      result = client.beliefs_for(domain: 'ethics')
+      expect(result[:count]).to eq(1)
+      expect(result[:beliefs].first[:content]).to eq('test belief')
+    end
+
+    it 'does not include beliefs from other domains' do
+      client.add_belief(domain: 'ethics', content: 'ethics belief')
+      client.add_belief(domain: 'safety', content: 'safety belief')
+      result = client.beliefs_for(domain: 'ethics')
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns the domain in the result' do
+      result = client.beliefs_for(domain: 'ethics')
+      expect(result[:domain]).to eq('ethics')
+    end
+  end
+
+  describe '#unresolved' do
+    it 'returns success true' do
+      result = client.unresolved
+      expect(result[:success]).to be true
+    end
+
+    it 'returns empty events initially' do
+      result = client.unresolved
+      expect(result[:events]).to be_empty
+      expect(result[:count]).to eq(0)
+    end
+
+    it 'returns unresolved events after contradiction' do
+      client.add_belief(domain: 'x', content: 'claim a')
+      client.add_belief(domain: 'x', content: 'claim b')
+      result = client.unresolved
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'does not include resolved events' do
+      client.add_belief(domain: 'x', content: 'claim a')
+      inner_result = client.add_belief(domain: 'x', content: 'claim b')
+      ev_id = inner_result[:new_dissonance_events].first[:id]
+      client.resolve_dissonance(event_id: ev_id, strategy: :belief_revision)
+      result = client.unresolved
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#dissonance_stats' do
+    it 'returns success true' do
+      result = client.dissonance_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'returns comprehensive stats hash' do
+      result = client.dissonance_stats
+      expect(result).to include(:stress, :total_beliefs, :total_events, :unresolved_count,
+                                :resolved_count, :domain_stresses, :resolution_breakdown, :above_threshold)
+    end
+
+    it 'resolution_breakdown contains all three strategies' do
+      result = client.dissonance_stats
+      expect(result[:resolution_breakdown].keys).to contain_exactly(:belief_revision, :rationalization, :avoidance)
+    end
+
+    it 'counts resolved events by strategy' do
+      client.add_belief(domain: 'x', content: 'a')
+      inner_result = client.add_belief(domain: 'x', content: 'b')
+      ev_id = inner_result[:new_dissonance_events].first[:id]
+      client.resolve_dissonance(event_id: ev_id, strategy: :rationalization)
+      result = client.dissonance_stats
+      expect(result[:resolution_breakdown][:rationalization]).to eq(1)
+      expect(result[:resolved_count]).to eq(1)
+    end
+
+    it 'domain_stresses includes all domains with beliefs' do
+      client.add_belief(domain: 'domain_a', content: 'alpha')
+      client.add_belief(domain: 'domain_b', content: 'beta')
+      result = client.dissonance_stats
+      expect(result[:domain_stresses].keys).to include('domain_a', 'domain_b')
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/epistemic_vigilance/client'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::EpistemicVigilance::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:register_epistemic_source)
+    expect(client).to respond_to(:submit_epistemic_claim)
+    expect(client).to respond_to(:assess_epistemic_claim)
+    expect(client).to respond_to(:support_epistemic_claim)
+    expect(client).to respond_to(:challenge_epistemic_claim)
+    expect(client).to respond_to(:adjudicate_epistemic_claim)
+    expect(client).to respond_to(:source_reliability_report)
+    expect(client).to respond_to(:contested_claims_report)
+    expect(client).to respond_to(:domain_vigilance_report)
+    expect(client).to respond_to(:update_epistemic_vigilance)
+    expect(client).to respond_to(:epistemic_vigilance_stats)
+  end
+
+  it 'maintains independent engine state per instance' do
+    client2 = described_class.new
+    client.register_epistemic_source(name: 'A', domain: :test)
+    expect(client.epistemic_vigilance_stats[:sources_count]).to eq(1)
+    expect(client2.epistemic_vigilance_stats[:sources_count]).to eq(0)
+  end
+end