lex-dissonance 0.1.0

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::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/dissonance/helpers/dissonance_event_spec.rb

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

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

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::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::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::Dissonance::Helpers::Belief.new(domain: 'ethics', content: 'be honest')
+      b2 = Legion::Extensions::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::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