lex-agentic-defense 0.1.0

data/spec/legion/extensions/agentic/defense/avalanche/helpers/snowpack_spec.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Avalanche::Helpers::Snowpack do
+  subject(:snowpack) do
+    described_class.new(snowpack_type: :ideas, domain: :reasoning, content: 'recursive self-improvement')
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(snowpack.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets snowpack_type' do
+      expect(snowpack.snowpack_type).to eq(:ideas)
+    end
+
+    it 'sets domain' do
+      expect(snowpack.domain).to eq(:reasoning)
+    end
+
+    it 'sets content' do
+      expect(snowpack.content).to eq('recursive self-improvement')
+    end
+
+    it 'defaults depth to 0.0' do
+      expect(snowpack.depth).to eq(0.0)
+    end
+
+    it 'defaults stability to 1.0' do
+      expect(snowpack.stability).to eq(1.0)
+    end
+
+    it 'records created_at timestamp' do
+      expect(snowpack.created_at).to be_a(Time)
+    end
+
+    it 'clamps depth above 1.0 to 1.0' do
+      sp = described_class.new(snowpack_type: :emotions, domain: :test, content: 'x', depth: 2.5)
+      expect(sp.depth).to eq(1.0)
+    end
+
+    it 'clamps stability below 0.0 to 0.0' do
+      sp = described_class.new(snowpack_type: :emotions, domain: :test, content: 'x', stability: -0.5)
+      expect(sp.stability).to eq(0.0)
+    end
+
+    it 'raises ArgumentError for unknown snowpack_type' do
+      expect do
+        described_class.new(snowpack_type: :unknown_type, domain: :test, content: 'x')
+      end.to raise_error(ArgumentError, /unknown snowpack_type/)
+    end
+
+    it 'accepts all valid snowpack_types' do
+      %i[ideas emotions memories associations impulses].each do |type|
+        expect do
+          described_class.new(snowpack_type: type, domain: :test, content: 'x')
+        end.not_to raise_error
+      end
+    end
+  end
+
+  describe '#accumulate!' do
+    it 'increases depth by default rate' do
+      expect { snowpack.accumulate! }.to change(snowpack, :depth).by(0.06)
+    end
+
+    it 'increases depth by given rate' do
+      expect { snowpack.accumulate!(0.1) }.to change(snowpack, :depth).by(0.1)
+    end
+
+    it 'clamps depth at 1.0' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', depth: 0.98)
+      sp.accumulate!(0.1)
+      expect(sp.depth).to eq(1.0)
+    end
+
+    it 'uses absolute value of rate' do
+      before = snowpack.depth
+      snowpack.accumulate!(-0.05)
+      expect(snowpack.depth).to eq((before + 0.05).round(10))
+    end
+  end
+
+  describe '#compact!' do
+    it 'increases stability by 0.05' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.5)
+      before = sp.stability
+      sp.compact!
+      expect(sp.stability).to be_within(0.0001).of(before + 0.05)
+    end
+
+    it 'clamps stability at 1.0' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.98)
+      sp.compact!
+      expect(sp.stability).to eq(1.0)
+    end
+  end
+
+  describe '#destabilize!' do
+    it 'reduces stability by force' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.8)
+      before = sp.stability
+      sp.destabilize!(0.2)
+      expect(sp.stability).to be_within(0.0001).of(before - 0.2)
+    end
+
+    it 'clamps stability at 0.0' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.1)
+      sp.destabilize!(0.5)
+      expect(sp.stability).to eq(0.0)
+    end
+
+    it 'uses absolute value of force' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.8)
+      sp.destabilize!(-0.2)
+      expect(sp.stability).to eq(0.6)
+    end
+  end
+
+  describe '#stable?' do
+    it 'returns true when stability >= 0.6' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.7)
+      expect(sp.stable?).to be(true)
+    end
+
+    it 'returns false when stability < 0.6' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.5)
+      expect(sp.stable?).to be(false)
+    end
+
+    it 'returns true at exactly 0.6' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.6)
+      expect(sp.stable?).to be(true)
+    end
+  end
+
+  describe '#unstable?' do
+    it 'returns true when stability < 0.4' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.3)
+      expect(sp.unstable?).to be(true)
+    end
+
+    it 'returns false when stability >= 0.4' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.5)
+      expect(sp.unstable?).to be(false)
+    end
+  end
+
+  describe '#critical?' do
+    it 'returns true when stability < 0.2' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.1)
+      expect(sp.critical?).to be(true)
+    end
+
+    it 'returns false when stability >= 0.2' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.2)
+      expect(sp.critical?).to be(false)
+    end
+  end
+
+  describe '#stability_label' do
+    it 'returns :catastrophic for stability 0.1' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.1)
+      expect(sp.stability_label).to eq(:catastrophic)
+    end
+
+    it 'returns :bedrock for stability 1.0' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 1.0)
+      expect(sp.stability_label).to eq(:bedrock)
+    end
+  end
+
+  describe '#instability' do
+    it 'returns 1.0 - stability' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.7)
+      expect(sp.instability).to eq(0.3)
+    end
+
+    it 'returns 0.0 when fully stable' do
+      sp = described_class.new(snowpack_type: :ideas, domain: :test, content: 'x', stability: 1.0)
+      expect(sp.instability).to eq(0.0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      h = snowpack.to_h
+      expect(h.keys).to include(:id, :snowpack_type, :domain, :content, :depth, :stability,
+                                :stable, :unstable, :critical, :stability_label, :created_at)
+    end
+
+    it 'reflects current stability state' do
+      h = snowpack.to_h
+      expect(h[:stable]).to eq(snowpack.stable?)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/avalanche/runners/cognitive_avalanche_spec.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Avalanche::Runners::CognitiveAvalanche do
+  let(:engine) { Legion::Extensions::Agentic::Defense::Avalanche::Helpers::AvalancheEngine.new }
+  let(:runner) { Object.new.extend(described_module) }
+
+  def described_module
+    Legion::Extensions::Agentic::Defense::Avalanche::Runners::CognitiveAvalanche
+  end
+
+  let(:unstable_snowpack_id) do
+    engine.create_snowpack(
+      snowpack_type: :ideas,
+      domain:        :creativity,
+      content:       'cascading concept',
+      stability:     0.1
+    )[:snowpack_id]
+  end
+
+  let(:stable_snowpack_id) do
+    engine.create_snowpack(
+      snowpack_type: :memories,
+      domain:        :identity,
+      content:       'core belief',
+      stability:     0.95
+    )[:snowpack_id]
+  end
+
+  describe '#create_snowpack' do
+    it 'creates a snowpack with valid params' do
+      result = runner.create_snowpack(snowpack_type: :emotions, domain: :fear, content: 'baseline anxiety', engine: engine)
+      expect(result[:success]).to be(true)
+      expect(result[:snowpack_id]).not_to be_nil
+    end
+
+    it 'returns failure when snowpack_type is missing' do
+      result = runner.create_snowpack(domain: :test, content: 'x', engine: engine)
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to match(/snowpack_type/)
+    end
+
+    it 'returns failure when domain is missing' do
+      result = runner.create_snowpack(snowpack_type: :ideas, content: 'x', engine: engine)
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to match(/domain/)
+    end
+
+    it 'returns failure when content is missing' do
+      result = runner.create_snowpack(snowpack_type: :ideas, domain: :test, engine: engine)
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to match(/content/)
+    end
+
+    it 'passes depth to engine' do
+      result = runner.create_snowpack(snowpack_type: :ideas, domain: :test, content: 'x', depth: 0.4, engine: engine)
+      expect(engine.snowpacks[result[:snowpack_id]].depth).to eq(0.4)
+    end
+
+    it 'passes stability to engine' do
+      result = runner.create_snowpack(snowpack_type: :ideas, domain: :test, content: 'x', stability: 0.3, engine: engine)
+      expect(engine.snowpacks[result[:snowpack_id]].stability).to eq(0.3)
+    end
+
+    it 'accepts extra kwargs without error' do
+      result = runner.create_snowpack(
+        snowpack_type: :impulses, domain: :test, content: 'x', engine: engine, irrelevant: true
+      )
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '#trigger' do
+    before { unstable_snowpack_id && stable_snowpack_id }
+
+    it 'triggers a cascade for an unstable snowpack' do
+      result = runner.trigger(snowpack_id: unstable_snowpack_id, force: 0.5, engine: engine)
+      expect(result[:success]).to be(true)
+      expect(result[:triggered]).to be(true)
+    end
+
+    it 'returns no trigger for stable snowpack with low force' do
+      result = runner.trigger(snowpack_id: stable_snowpack_id, force: 0.01, engine: engine)
+      expect(result[:success]).to be(true)
+      expect(result[:triggered]).to be(false)
+    end
+
+    it 'returns failure when snowpack_id is missing' do
+      result = runner.trigger(force: 0.5, engine: engine)
+      expect(result[:success]).to be(false)
+      expect(result[:error]).to match(/snowpack_id/)
+    end
+
+    it 'returns failure for unknown snowpack_id' do
+      result = runner.trigger(snowpack_id: 'ghost', force: 0.5, engine: engine)
+      expect(result[:success]).to be(false)
+    end
+
+    it 'defaults force to 0.5' do
+      result = runner.trigger(snowpack_id: unstable_snowpack_id, engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'accepts custom cascade_type' do
+      result = runner.trigger(
+        snowpack_id: unstable_snowpack_id, force: 0.5,
+        cascade_type: :analytical, engine: engine
+      )
+      expect(result[:cascade][:cascade_type]).to eq(:analytical) if result[:triggered]
+    end
+
+    it 'accepts extra kwargs without error' do
+      result = runner.trigger(snowpack_id: unstable_snowpack_id, force: 0.5, engine: engine, trace: 'debug')
+      expect(result[:success]).to be(true)
+    end
+  end
+
+  describe '#accumulate' do
+    before { unstable_snowpack_id }
+
+    it 'returns success' do
+      result = runner.accumulate(engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'reports packs_accumulated' do
+      result = runner.accumulate(engine: engine)
+      expect(result[:packs_accumulated]).to eq(1)
+    end
+
+    it 'accepts custom rate' do
+      result = runner.accumulate(rate: 0.1, engine: engine)
+      expect(result[:rate]).to eq(0.1)
+    end
+
+    it 'uses default ACCUMULATION_RATE when not specified' do
+      result = runner.accumulate(engine: engine)
+      expect(result[:rate]).to eq(Legion::Extensions::Agentic::Defense::Avalanche::Helpers::Constants::ACCUMULATION_RATE)
+    end
+  end
+
+  describe '#list_snowpacks' do
+    before { unstable_snowpack_id && stable_snowpack_id }
+
+    it 'returns success' do
+      result = runner.list_snowpacks(engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'includes snowpacks array' do
+      result = runner.list_snowpacks(engine: engine)
+      expect(result[:snowpacks]).to be_an(Array)
+      expect(result[:snowpacks].size).to eq(2)
+    end
+
+    it 'includes count' do
+      result = runner.list_snowpacks(engine: engine)
+      expect(result[:count]).to eq(2)
+    end
+
+    it 'returns hash representations of snowpacks' do
+      result = runner.list_snowpacks(engine: engine)
+      expect(result[:snowpacks].first).to have_key(:id)
+      expect(result[:snowpacks].first).to have_key(:stability)
+    end
+
+    it 'returns empty list when no snowpacks' do
+      empty_engine = Legion::Extensions::Agentic::Defense::Avalanche::Helpers::AvalancheEngine.new
+      result = runner.list_snowpacks(engine: empty_engine)
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#terrain_status' do
+    before { unstable_snowpack_id && stable_snowpack_id }
+
+    it 'returns success' do
+      result = runner.terrain_status(engine: engine)
+      expect(result[:success]).to be(true)
+    end
+
+    it 'includes total_snowpacks' do
+      result = runner.terrain_status(engine: engine)
+      expect(result[:total_snowpacks]).to eq(2)
+    end
+
+    it 'includes cascade_history' do
+      runner.trigger(snowpack_id: unstable_snowpack_id, force: 0.5, engine: engine)
+      result = runner.terrain_status(engine: engine)
+      expect(result[:cascade_history]).to be >= 1
+    end
+
+    it 'includes avg_stability' do
+      result = runner.terrain_status(engine: engine)
+      expect(result[:avg_stability]).to be_a(Float)
+    end
+
+    it 'includes most_unstable_id' do
+      result = runner.terrain_status(engine: engine)
+      expect(result[:most_unstable_id]).to eq(unstable_snowpack_id)
+    end
+  end
+
+  describe 'default engine isolation' do
+    it 'each runner instance has its own default engine' do
+      r1 = Object.new.extend(described_module)
+      r2 = Object.new.extend(described_module)
+      r1.create_snowpack(snowpack_type: :ideas, domain: :test, content: 'isolated')
+      expect(r2.terrain_status[:total_snowpacks]).to eq(0)
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/bias/client'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Bias::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:check_for_bias)
+    expect(client).to respond_to(:record_anchor)
+    expect(client).to respond_to(:update_bias)
+    expect(client).to respond_to(:bias_report)
+    expect(client).to respond_to(:susceptibility_profile)
+    expect(client).to respond_to(:bias_stats)
+  end
+end

data/spec/legion/extensions/agentic/defense/bias/helpers/bias_detector_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/bias/helpers/constants'
+require 'legion/extensions/agentic/defense/bias/helpers/bias_detector'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Bias::Helpers::BiasDetector do
+  subject(:detector) { described_class.new }
+
+  describe '#susceptibility_for' do
+    it 'returns DEFAULT_SUSCEPTIBILITY for all bias types at init' do
+      Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::BIAS_TYPES.each do |bt|
+        expect(detector.susceptibility_for(bt)).to eq(
+          Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::DEFAULT_SUSCEPTIBILITY
+        )
+      end
+    end
+  end
+
+  describe '#detect_anchoring' do
+    it 'returns high magnitude when current value is very close to anchor' do
+      mag = detector.detect_anchoring(current_value: 100.0, anchor_value: 100.0)
+      expect(mag).to be_within(0.01).of(0.5) # pull=1.0 * susceptibility=0.5
+    end
+
+    it 'returns low magnitude when current value is far from anchor' do
+      mag = detector.detect_anchoring(current_value: 200.0, anchor_value: 100.0)
+      expect(mag).to be < 0.3
+    end
+
+    it 'returns 0.0 when anchor_value is zero' do
+      mag = detector.detect_anchoring(current_value: 50.0, anchor_value: 0.0)
+      expect(mag).to eq(0.0)
+    end
+
+    it 'returns 0.0 when anchor_value is nil' do
+      mag = detector.detect_anchoring(current_value: 50.0, anchor_value: nil)
+      expect(mag).to eq(0.0)
+    end
+
+    it 'clamps result to [0, 1]' do
+      mag = detector.detect_anchoring(current_value: 100.0, anchor_value: 100.0)
+      expect(mag).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#detect_confirmation' do
+    it 'returns higher magnitude when evidence matches hypothesis' do
+      mag_match = detector.detect_confirmation(
+        evidence_direction:   :positive,
+        hypothesis_direction: :positive
+      )
+      mag_mismatch = detector.detect_confirmation(
+        evidence_direction:   :negative,
+        hypothesis_direction: :positive
+      )
+      expect(mag_match).to be > mag_mismatch
+    end
+
+    it 'returns magnitude >= CONFIRMATION_WEIGHT * susceptibility when matching' do
+      mag = detector.detect_confirmation(
+        evidence_direction:   :up,
+        hypothesis_direction: :up
+      )
+      expected = Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::CONFIRMATION_WEIGHT *
+                 Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::DEFAULT_SUSCEPTIBILITY
+      expect(mag).to be_within(0.001).of(expected)
+    end
+  end
+
+  describe '#detect_availability' do
+    it 'returns higher magnitude with more recent events' do
+      mag_full = detector.detect_availability(recent_events: Array.new(10, :event))
+      mag_none = detector.detect_availability(recent_events: [])
+      expect(mag_full).to be > mag_none
+    end
+
+    it 'returns 0 with empty recent_events' do
+      mag = detector.detect_availability(recent_events: [])
+      expect(mag).to eq(0.0)
+    end
+  end
+
+  describe '#detect_recency' do
+    it 'returns 0 with fewer than 2 data points' do
+      mag = detector.detect_recency(data_points: [1.0])
+      expect(mag).to eq(0.0)
+    end
+
+    it 'returns 0 when all values are equal (zero range)' do
+      mag = detector.detect_recency(data_points: [5.0, 5.0, 5.0, 5.0])
+      expect(mag).to eq(0.0)
+    end
+
+    it 'returns higher magnitude when recent half differs significantly from earlier half' do
+      early = [1.0, 1.0, 1.0, 1.0]
+      recent = [9.0, 9.0, 9.0, 9.0]
+      mag = detector.detect_recency(data_points: early + recent)
+      expect(mag).to be > 0.3
+    end
+  end
+
+  describe '#detect_sunk_cost' do
+    it 'returns 0 when invested is 0' do
+      mag = detector.detect_sunk_cost(invested: 0, expected_return: 100)
+      expect(mag).to eq(0.0)
+    end
+
+    it 'returns higher magnitude with large investment and low expected return' do
+      mag = detector.detect_sunk_cost(invested: 1_000_000, expected_return: 1)
+      expect(mag).to be > 0.3
+    end
+
+    it 'returns lower magnitude with small investment and large expected return' do
+      mag = detector.detect_sunk_cost(invested: 1, expected_return: 1_000_000)
+      expect(mag).to be < 0.1
+    end
+  end
+
+  describe '#correction_for' do
+    it 'applies CORRECTION_FACTOR to magnitude' do
+      result = detector.correction_for(0.6)
+      expect(result).to be_within(0.001).of(
+        0.6 * Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::CORRECTION_FACTOR
+      )
+    end
+
+    it 'clamps to [0, 1]' do
+      expect(detector.correction_for(2.0)).to eq(1.0)
+      expect(detector.correction_for(-1.0)).to eq(0.0)
+    end
+  end
+
+  describe '#update_susceptibility' do
+    it 'increases susceptibility toward 1.0 when repeatedly detected' do
+      initial = detector.susceptibility_for(:anchoring)
+      10.times { detector.update_susceptibility(:anchoring, detected: true) }
+      expect(detector.susceptibility_for(:anchoring)).to be > initial
+    end
+
+    it 'decreases susceptibility toward 0.0 when not detected' do
+      initial = detector.susceptibility_for(:anchoring)
+      10.times { detector.update_susceptibility(:anchoring, detected: false) }
+      expect(detector.susceptibility_for(:anchoring)).to be < initial
+    end
+
+    it 'ignores unknown bias types' do
+      expect { detector.update_susceptibility(:unknown_bias, detected: true) }.not_to raise_error
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns susceptibility hash' do
+      h = detector.to_h
+      expect(h[:susceptibility]).to be_a(Hash)
+      expect(h[:susceptibility].keys).to match_array(
+        Legion::Extensions::Agentic::Defense::Bias::Helpers::Constants::BIAS_TYPES
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/bias/helpers/bias_event_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/bias/helpers/bias_event'
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Bias::Helpers::BiasEvent do
+  let(:event) do
+    described_class.new(
+      bias_type:          :anchoring,
+      domain:             :finance,
+      magnitude:          0.6,
+      corrected:          true,
+      correction_applied: 0.3,
+      context:            { current_value: 100 }
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(event.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'assigns bias_type' do
+      expect(event.bias_type).to eq(:anchoring)
+    end
+
+    it 'assigns domain' do
+      expect(event.domain).to eq(:finance)
+    end
+
+    it 'assigns magnitude' do
+      expect(event.magnitude).to eq(0.6)
+    end
+
+    it 'assigns corrected flag' do
+      expect(event.corrected).to be true
+    end
+
+    it 'assigns correction_applied' do
+      expect(event.correction_applied).to eq(0.3)
+    end
+
+    it 'assigns context' do
+      expect(event.context).to eq({ current_value: 100 })
+    end
+
+    it 'sets timestamp to a Time' do
+      expect(event.timestamp).to be_a(Time)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all fields' do
+      h = event.to_h
+      expect(h[:id]).to eq(event.id)
+      expect(h[:bias_type]).to eq(:anchoring)
+      expect(h[:domain]).to eq(:finance)
+      expect(h[:magnitude]).to eq(0.6)
+      expect(h[:corrected]).to be true
+      expect(h[:correction_applied]).to eq(0.3)
+      expect(h[:context]).to eq({ current_value: 100 })
+      expect(h[:timestamp]).to be_a(Time)
+    end
+  end
+end