lex-agentic-defense 0.1.0

data/spec/legion/extensions/agentic/defense/friction/helpers/friction_engine_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Helpers::FrictionEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts in rest_mode' do
+      expect(engine.current_state).to eq(:rest_mode)
+    end
+  end
+
+  describe '#set_current_state' do
+    it 'changes the current state' do
+      engine.set_current_state(state: :active)
+      expect(engine.current_state).to eq(:active)
+    end
+
+    it 'converts to symbol' do
+      engine.set_current_state(state: 'thinking')
+      expect(engine.current_state).to eq(:thinking)
+    end
+  end
+
+  describe '#set_friction / #get_friction' do
+    it 'stores and retrieves friction for a path' do
+      engine.set_friction(from_state: :rest, to_state: :active, friction: 0.7)
+      expect(engine.get_friction(from_state: :rest, to_state: :active)).to eq(0.7)
+    end
+
+    it 'clamps friction to 0..1' do
+      engine.set_friction(from_state: :a, to_state: :b, friction: 5.0)
+      expect(engine.get_friction(from_state: :a, to_state: :b)).to eq(1.0)
+    end
+
+    it 'returns default friction for unknown paths' do
+      default = Legion::Extensions::Agentic::Defense::Friction::Helpers::Constants::DEFAULT_FRICTION
+      expect(engine.get_friction(from_state: :x, to_state: :y)).to eq(default)
+    end
+  end
+
+  describe '#attempt_transition' do
+    it 'moves to new state on success' do
+      engine.set_friction(from_state: :rest_mode, to_state: :active, friction: 0.3)
+      transition = engine.attempt_transition(to_state: :active, force: 0.8)
+      expect(transition.completed?).to be true
+      expect(engine.current_state).to eq(:active)
+    end
+
+    it 'stays in current state on resistance' do
+      engine.set_friction(from_state: :rest_mode, to_state: :active, friction: 0.9)
+      transition = engine.attempt_transition(to_state: :active, force: 0.1)
+      expect(transition.completed?).to be false
+      expect(engine.current_state).to eq(:rest_mode)
+    end
+
+    it 'records the transition in history' do
+      engine.attempt_transition(to_state: :active, force: 0.8)
+      expect(engine.transition_history.size).to eq(1)
+    end
+  end
+
+  describe '#force_transition' do
+    it 'always moves to new state regardless of friction' do
+      engine.set_friction(from_state: :rest_mode, to_state: :locked, friction: 1.0)
+      transition = engine.force_transition(to_state: :locked)
+      expect(transition.completed?).to be true
+      expect(engine.current_state).to eq(:locked)
+    end
+  end
+
+  describe '#transition_history' do
+    it 'returns transitions in chronological order' do
+      engine.attempt_transition(to_state: :a, force: 0.9)
+      engine.attempt_transition(to_state: :b, force: 0.9)
+      history = engine.transition_history
+      expect(history.first.created_at).to be <= history.last.created_at
+    end
+
+    it 'respects the limit' do
+      5.times { |i| engine.attempt_transition(to_state: :"s#{i}", force: 0.9) }
+      expect(engine.transition_history(limit: 3).size).to eq(3)
+    end
+  end
+
+  describe '#successful_transitions' do
+    it 'returns only completed transitions' do
+      engine.set_friction(from_state: :rest_mode, to_state: :a, friction: 0.3)
+      engine.attempt_transition(to_state: :a, force: 0.8)
+      engine.set_friction(from_state: :a, to_state: :b, friction: 0.9)
+      engine.attempt_transition(to_state: :b, force: 0.1)
+      expect(engine.successful_transitions.size).to eq(1)
+    end
+  end
+
+  describe '#resisted_transitions' do
+    it 'returns only resisted transitions' do
+      engine.set_friction(from_state: :rest_mode, to_state: :hard, friction: 0.9)
+      engine.attempt_transition(to_state: :hard, force: 0.1)
+      expect(engine.resisted_transitions.size).to eq(1)
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0.0 with no transitions' do
+      expect(engine.success_rate).to eq(0.0)
+    end
+
+    it 'calculates ratio of successful to total' do
+      engine.set_friction(from_state: :rest_mode, to_state: :a, friction: 0.3)
+      engine.attempt_transition(to_state: :a, force: 0.8)
+      engine.set_friction(from_state: :a, to_state: :b, friction: 0.9)
+      engine.attempt_transition(to_state: :b, force: 0.1)
+      expect(engine.success_rate).to eq(0.5)
+    end
+  end
+
+  describe '#average_friction' do
+    it 'returns 0.0 with no transitions' do
+      expect(engine.average_friction).to eq(0.0)
+    end
+
+    it 'calculates average friction across transitions' do
+      engine.set_friction(from_state: :rest_mode, to_state: :a, friction: 0.2)
+      engine.attempt_transition(to_state: :a, force: 0.9)
+      engine.set_friction(from_state: :a, to_state: :b, friction: 0.8)
+      engine.attempt_transition(to_state: :b, force: 0.9)
+      expect(engine.average_friction).to eq(0.5)
+    end
+  end
+
+  describe '#highest_friction_paths' do
+    it 'returns paths sorted by friction descending' do
+      engine.set_friction(from_state: :a, to_state: :b, friction: 0.3)
+      engine.set_friction(from_state: :c, to_state: :d, friction: 0.9)
+      engine.set_friction(from_state: :e, to_state: :f, friction: 0.6)
+      paths = engine.highest_friction_paths(limit: 3)
+      expect(paths.first[:friction]).to eq(0.9)
+      expect(paths.last[:friction]).to eq(0.3)
+    end
+
+    it 'respects the limit' do
+      5.times { |i| engine.set_friction(from_state: :"a#{i}", to_state: :"b#{i}", friction: i * 0.2) }
+      expect(engine.highest_friction_paths(limit: 2).size).to eq(2)
+    end
+  end
+
+  describe '#friction_report' do
+    it 'includes all report fields' do
+      report = engine.friction_report
+      expect(report).to include(
+        :current_state, :total_transitions, :successful, :resisted,
+        :success_rate, :average_friction, :friction_paths, :highest_friction
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes summary fields' do
+      hash = engine.to_h
+      expect(hash).to include(
+        :current_state, :total_transitions, :success_rate,
+        :average_friction, :friction_paths
+      )
+    end
+  end
+
+  describe 'pruning' do
+    it 'prunes oldest transition when limit reached' do
+      stub_const('Legion::Extensions::Agentic::Defense::Friction::Helpers::Constants::MAX_TRANSITIONS', 3)
+      eng = described_class.new
+      4.times { |i| eng.attempt_transition(to_state: :"s#{i}", force: 0.9) }
+      expect(eng.transition_history.size).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/friction/helpers/state_transition_spec.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Helpers::StateTransition do
+  subject(:transition) { described_class.new(from_state: :rest, to_state: :active, friction: 0.5) }
+
+  describe '#initialize' do
+    it 'sets from_state and to_state as symbols' do
+      expect(transition.from_state).to eq(:rest)
+      expect(transition.to_state).to eq(:active)
+    end
+
+    it 'assigns a UUID id' do
+      expect(transition.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'clamps friction to 0..1' do
+      high = described_class.new(from_state: :a, to_state: :b, friction: 5.0)
+      expect(high.friction).to eq(1.0)
+
+      low = described_class.new(from_state: :a, to_state: :b, friction: -1.0)
+      expect(low.friction).to eq(0.0)
+    end
+
+    it 'starts with nil outcome' do
+      expect(transition.outcome).to be_nil
+    end
+
+    it 'records created_at' do
+      expect(transition.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#attempt!' do
+    it 'returns :completed when force exceeds friction' do
+      transition.attempt!(force: 0.8)
+      expect(transition.outcome).to eq(:completed)
+    end
+
+    it 'returns :resisted when force is too low' do
+      transition.attempt!(force: 0.1)
+      expect(transition.outcome).to eq(:resisted)
+    end
+
+    it 'returns :deferred when force is in the middle zone' do
+      transition.attempt!(force: 0.4)
+      expect(transition.outcome).to eq(:deferred)
+    end
+
+    it 'clamps force_applied to 0..1' do
+      transition.attempt!(force: 5.0)
+      expect(transition.force_applied).to eq(1.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(transition.attempt!(force: 0.8)).to eq(transition)
+    end
+  end
+
+  describe '#force!' do
+    it 'sets outcome to :forced' do
+      transition.force!
+      expect(transition.outcome).to eq(:forced)
+    end
+
+    it 'sets force_applied to 1.0 by default' do
+      transition.force!
+      expect(transition.force_applied).to eq(1.0)
+    end
+  end
+
+  describe '#completed?' do
+    it 'is true for :completed outcome' do
+      transition.attempt!(force: 0.8)
+      expect(transition.completed?).to be true
+    end
+
+    it 'is true for :forced outcome' do
+      transition.force!
+      expect(transition.completed?).to be true
+    end
+
+    it 'is false for :resisted outcome' do
+      transition.attempt!(force: 0.1)
+      expect(transition.completed?).to be false
+    end
+
+    it 'is false for :deferred outcome' do
+      transition.attempt!(force: 0.4)
+      expect(transition.completed?).to be false
+    end
+  end
+
+  describe '#friction_label' do
+    it 'returns a symbol' do
+      expect(transition.friction_label).to be_a(Symbol)
+    end
+
+    it 'returns :frictionless for 0.0 friction' do
+      t = described_class.new(from_state: :a, to_state: :b, friction: 0.0)
+      expect(t.friction_label).to eq(:frictionless)
+    end
+
+    it 'returns :locked for 1.0 friction' do
+      t = described_class.new(from_state: :a, to_state: :b, friction: 1.0)
+      expect(t.friction_label).to eq(:locked)
+    end
+  end
+
+  describe '#to_h' do
+    before { transition.attempt!(force: 0.8) }
+
+    it 'includes all fields' do
+      hash = transition.to_h
+      expect(hash).to include(
+        :id, :from_state, :to_state, :friction, :friction_label,
+        :outcome, :force_applied, :completed, :created_at
+      )
+    end
+
+    it 'reflects the outcome' do
+      expect(transition.to_h[:completed]).to be true
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/friction/runners/cognitive_friction_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Runners::CognitiveFriction do
+  let(:client) { Legion::Extensions::Agentic::Defense::Friction::Client.new }
+
+  describe '#set_current_state' do
+    it 'returns success with new state' do
+      result = client.set_current_state(state: :active)
+      expect(result[:success]).to be true
+      expect(result[:state]).to eq(:active)
+    end
+  end
+
+  describe '#set_friction' do
+    it 'returns success with friction details' do
+      result = client.set_friction(from_state: :rest, to_state: :active, friction: 0.7)
+      expect(result[:success]).to be true
+      expect(result[:friction]).to eq(0.7)
+    end
+  end
+
+  describe '#get_friction' do
+    it 'retrieves stored friction' do
+      client.set_friction(from_state: :rest, to_state: :active, friction: 0.6)
+      result = client.get_friction(from_state: :rest, to_state: :active)
+      expect(result[:success]).to be true
+      expect(result[:friction]).to eq(0.6)
+    end
+  end
+
+  describe '#attempt_transition' do
+    it 'returns transition details' do
+      result = client.attempt_transition(to_state: :active, force: 0.9)
+      expect(result[:success]).to be true
+      expect(result[:transition]).to be_a(Hash)
+      expect(result[:current_state]).to be_a(Symbol)
+    end
+  end
+
+  describe '#force_transition' do
+    it 'always completes' do
+      result = client.force_transition(to_state: :locked)
+      expect(result[:success]).to be true
+      expect(result[:transition][:completed]).to be true
+    end
+  end
+
+  describe '#transition_history' do
+    it 'returns history array' do
+      client.attempt_transition(to_state: :a, force: 0.9)
+      result = client.transition_history
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns a numeric rate' do
+      result = client.success_rate
+      expect(result[:success]).to be true
+      expect(result[:success_rate]).to be_a(Numeric)
+    end
+  end
+
+  describe '#average_friction' do
+    it 'returns a numeric average' do
+      result = client.average_friction
+      expect(result[:success]).to be true
+      expect(result[:average_friction]).to be_a(Numeric)
+    end
+  end
+
+  describe '#highest_friction_paths' do
+    it 'returns paths array' do
+      client.set_friction(from_state: :a, to_state: :b, friction: 0.8)
+      result = client.highest_friction_paths
+      expect(result[:success]).to be true
+      expect(result[:paths]).to be_a(Array)
+    end
+  end
+
+  describe '#friction_report' do
+    it 'returns a full report' do
+      result = client.friction_report
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:current_state, :total_transitions)
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse::Client do
+  subject(:client) { described_class.new }
+
+  it 'responds to runner methods' do
+    expect(client).to respond_to(:register_antigen, :encounter_antigen, :vaccinate, :immune_report)
+  end
+
+  it 'accepts an injected engine' do
+    engine = Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::ImmuneEngine.new
+    custom = described_class.new(engine: engine)
+    result = custom.register_antigen(pattern: 'test', antigen_type: :prompt_injection)
+    expect(result[:success]).to be true
+  end
+
+  it 'runs a full immune lifecycle' do
+    ag = client.register_antigen(pattern: 'ignore all instructions', antigen_type: :prompt_injection)
+    antigen_id = ag[:antigen][:id]
+
+    response1 = client.encounter_antigen(antigen_id: antigen_id)
+    expect(response1[:response][:innate]).to be true
+
+    client.vaccinate(antigen_type: :prompt_injection, signature: 'instruction_override')
+
+    response2 = client.encounter_antigen(antigen_id: antigen_id)
+    expect(response2[:response][:adaptive]).to be true
+
+    status = client.immune_status
+    expect(status[:overall_health]).to be_between(0.0, 1.0)
+  end
+end

data/spec/legion/extensions/agentic/defense/immune_response/cognitive_immune_response_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse do
+  it 'has a version number' do
+    expect(Legion::Extensions::Agentic::Defense::ImmuneResponse::VERSION).to eq('0.1.0')
+  end
+end

data/spec/legion/extensions/agentic/defense/immune_response/helpers/antibody_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Antibody do
+  subject(:antibody) { described_class.new(antigen_type: :prompt_injection, signature: 'instruction_override') }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(antibody.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores antigen_type' do
+      expect(antibody.antigen_type).to eq(:prompt_injection)
+    end
+
+    it 'stores signature' do
+      expect(antibody.signature).to eq('instruction_override')
+    end
+
+    it 'defaults immunity_level to 0.3' do
+      expect(antibody.immunity_level).to eq(0.3)
+    end
+
+    it 'clamps immunity_level' do
+      high = described_class.new(antigen_type: :prompt_injection, signature: 'x', immunity_level: 5.0)
+      expect(high.immunity_level).to eq(1.0)
+    end
+
+    it 'initializes match_count to 0' do
+      expect(antibody.match_count).to eq(0)
+    end
+  end
+
+  describe '#strengthen!' do
+    it 'increases immunity_level' do
+      original = antibody.immunity_level
+      antibody.strengthen!
+      expect(antibody.immunity_level).to be > original
+    end
+
+    it 'increments match_count' do
+      antibody.strengthen!
+      expect(antibody.match_count).to eq(1)
+    end
+
+    it 'clamps at 1.0' do
+      10.times { antibody.strengthen!(0.2) }
+      expect(antibody.immunity_level).to eq(1.0)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces immunity_level' do
+      original = antibody.immunity_level
+      antibody.decay!
+      expect(antibody.immunity_level).to be < original
+    end
+
+    it 'clamps at 0.0' do
+      20.times { antibody.decay! }
+      expect(antibody.immunity_level).to eq(0.0)
+    end
+  end
+
+  describe '#matches?' do
+    it 'matches antigen of same type' do
+      antigen = Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Antigen.new(
+        pattern: 'test', antigen_type: :prompt_injection
+      )
+      expect(antibody.matches?(antigen)).to be true
+    end
+
+    it 'does not match different type' do
+      antigen = Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Antigen.new(
+        pattern: 'test', antigen_type: :data_poisoning
+      )
+      expect(antibody.matches?(antigen)).to be false
+    end
+  end
+
+  describe '#memory_cell?' do
+    it 'is false at default (0.3)' do
+      expect(antibody.memory_cell?).to be false
+    end
+
+    it 'is true when immunity is high' do
+      strong = described_class.new(antigen_type: :prompt_injection, signature: 'x', immunity_level: 0.7)
+      expect(strong.memory_cell?).to be true
+    end
+  end
+
+  describe '#effective?' do
+    it 'is false at default (0.3)' do
+      expect(antibody.effective?).to be false
+    end
+
+    it 'is true after strengthening' do
+      3.times { antibody.strengthen! }
+      expect(antibody.effective?).to be true
+    end
+  end
+
+  describe '#immunity_label' do
+    it 'returns :naive for default' do
+      expect(antibody.immunity_label).to eq(:naive)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = antibody.to_h
+      expect(hash).to include(
+        :id, :antigen_type, :signature, :immunity_level, :immunity_label,
+        :match_count, :memory_cell, :effective, :created_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/defense/immune_response/helpers/antigen_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Antigen do
+  subject(:antigen) { described_class.new(pattern: 'ignore previous instructions', antigen_type: :prompt_injection) }
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(antigen.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores pattern' do
+      expect(antigen.pattern).to eq('ignore previous instructions')
+    end
+
+    it 'stores antigen_type' do
+      expect(antigen.antigen_type).to eq(:prompt_injection)
+    end
+
+    it 'defaults threat_level to 0.5' do
+      expect(antigen.threat_level).to eq(0.5)
+    end
+
+    it 'clamps threat_level' do
+      high = described_class.new(pattern: 'x', antigen_type: :prompt_injection, threat_level: 5.0)
+      expect(high.threat_level).to eq(1.0)
+    end
+
+    it 'initializes exposure_count to 0' do
+      expect(antigen.exposure_count).to eq(0)
+    end
+
+    it 'defaults invalid type to :adversarial_input' do
+      bad = described_class.new(pattern: 'x', antigen_type: :nonexistent)
+      expect(bad.antigen_type).to eq(:adversarial_input)
+    end
+  end
+
+  describe '#expose!' do
+    it 'increments exposure_count' do
+      antigen.expose!
+      expect(antigen.exposure_count).to eq(1)
+    end
+
+    it 'updates last_seen' do
+      original = antigen.last_seen
+      antigen.expose!
+      expect(antigen.last_seen).to be >= original
+    end
+  end
+
+  describe '#escalate!' do
+    it 'increases threat_level' do
+      original = antigen.threat_level
+      antigen.escalate!
+      expect(antigen.threat_level).to be > original
+    end
+
+    it 'clamps at 1.0' do
+      10.times { antigen.escalate!(0.2) }
+      expect(antigen.threat_level).to eq(1.0)
+    end
+  end
+
+  describe '#de_escalate!' do
+    it 'decreases threat_level' do
+      original = antigen.threat_level
+      antigen.de_escalate!
+      expect(antigen.threat_level).to be < original
+    end
+
+    it 'clamps at 0.0' do
+      10.times { antigen.de_escalate!(0.2) }
+      expect(antigen.threat_level).to eq(0.0)
+    end
+  end
+
+  describe '#critical?' do
+    it 'is false at default' do
+      expect(antigen.critical?).to be false
+    end
+
+    it 'is true when threat is high' do
+      high = described_class.new(pattern: 'x', antigen_type: :prompt_injection, threat_level: 0.9)
+      expect(high.critical?).to be true
+    end
+  end
+
+  describe '#benign?' do
+    it 'is false at default' do
+      expect(antigen.benign?).to be false
+    end
+
+    it 'is true when threat is low' do
+      low = described_class.new(pattern: 'x', antigen_type: :prompt_injection, threat_level: 0.1)
+      expect(low.benign?).to be true
+    end
+  end
+
+  describe '#recurring?' do
+    it 'is false initially' do
+      expect(antigen.recurring?).to be false
+    end
+
+    it 'is true after 3 exposures' do
+      3.times { antigen.expose! }
+      expect(antigen.recurring?).to be true
+    end
+  end
+
+  describe '#threat_label' do
+    it 'returns :moderate for default' do
+      expect(antigen.threat_label).to eq(:moderate)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = antigen.to_h
+      expect(hash).to include(
+        :id, :pattern, :antigen_type, :threat_level, :threat_label,
+        :exposure_count, :critical, :benign, :recurring, :first_seen, :last_seen
+      )
+    end
+  end
+end