lex-agentic-defense 0.1.0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Constants do
+  describe '.label_for' do
+    it 'returns :critical for high threat' do
+      expect(described_class.label_for(described_class::THREAT_LABELS, 0.9)).to eq(:critical)
+    end
+
+    it 'returns :minimal for low threat' do
+      expect(described_class.label_for(described_class::THREAT_LABELS, 0.1)).to eq(:minimal)
+    end
+
+    it 'returns :immune for high immunity' do
+      expect(described_class.label_for(described_class::IMMUNITY_LABELS, 0.9)).to eq(:immune)
+    end
+
+    it 'returns :vulnerable for low immunity' do
+      expect(described_class.label_for(described_class::IMMUNITY_LABELS, 0.1)).to eq(:vulnerable)
+    end
+
+    it 'returns :robust for high health' do
+      expect(described_class.label_for(described_class::HEALTH_LABELS, 0.9)).to eq(:robust)
+    end
+
+    it 'returns nil for value matching no range' do
+      expect(described_class.label_for({}, 0.5)).to be_nil
+    end
+  end
+
+  describe 'ANTIGEN_TYPES' do
+    it 'includes prompt_injection' do
+      expect(described_class::ANTIGEN_TYPES).to include(:prompt_injection)
+    end
+
+    it 'has 8 types' do
+      expect(described_class::ANTIGEN_TYPES.size).to eq(8)
+    end
+  end
+
+  describe 'RESPONSE_LEVELS' do
+    it 'has 5 levels' do
+      expect(described_class::RESPONSE_LEVELS.size).to eq(5)
+    end
+  end
+end

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

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::ImmuneEngine do
+  subject(:engine) { described_class.new }
+
+  let(:antigen) { engine.register_antigen(pattern: 'ignore all', antigen_type: :prompt_injection) }
+
+  describe '#register_antigen' do
+    it 'creates an antigen' do
+      ag = engine.register_antigen(pattern: 'test', antigen_type: :data_poisoning)
+      expect(ag).to be_a(Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Antigen)
+    end
+
+    it 'stores the antigen' do
+      ag = engine.register_antigen(pattern: 'test', antigen_type: :data_poisoning)
+      expect(engine.most_threatening.map(&:id)).to include(ag.id)
+    end
+  end
+
+  describe '#encounter' do
+    it 'generates an innate response for unknown antigen type' do
+      response = engine.encounter(antigen_id: antigen.id)
+      expect(response).to be_a(Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::ImmuneResponse)
+      expect(response.innate?).to be true
+    end
+
+    it 'generates an adaptive response when antibody exists' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'override')
+      response = engine.encounter(antigen_id: antigen.id)
+      expect(response.adaptive?).to be true
+    end
+
+    it 'strengthens matching antibody on encounter' do
+      ab = engine.create_antibody(antigen_type: :prompt_injection, signature: 'override')
+      original = ab.immunity_level
+      engine.encounter(antigen_id: antigen.id)
+      expect(ab.immunity_level).to be > original
+    end
+
+    it 'increments antigen exposure count' do
+      engine.encounter(antigen_id: antigen.id)
+      expect(antigen.exposure_count).to eq(1)
+    end
+
+    it 'returns nil for unknown antigen' do
+      expect(engine.encounter(antigen_id: 'nonexistent')).to be_nil
+    end
+  end
+
+  describe '#create_antibody' do
+    it 'creates an antibody' do
+      ab = engine.create_antibody(antigen_type: :prompt_injection, signature: 'test')
+      expect(ab).to be_a(Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Antibody)
+    end
+  end
+
+  describe '#vaccinate' do
+    it 'creates an antibody with higher initial immunity' do
+      ab = engine.vaccinate(antigen_type: :social_engineering, signature: 'authority_claim')
+      expect(ab.immunity_level).to eq(0.6)
+    end
+
+    it 'creates a memory cell level antibody' do
+      ab = engine.vaccinate(antigen_type: :social_engineering, signature: 'authority_claim')
+      expect(ab.memory_cell?).to be true
+    end
+  end
+
+  describe '#decay_all!' do
+    it 'decays all antibodies' do
+      ab = engine.create_antibody(antigen_type: :prompt_injection, signature: 'x')
+      original = ab.immunity_level
+      engine.decay_all!
+      expect(ab.immunity_level).to be < original
+    end
+
+    it 'returns count' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'x')
+      result = engine.decay_all!
+      expect(result[:antibodies_decayed]).to eq(1)
+    end
+  end
+
+  describe '#escalate_antigen / #de_escalate_antigen' do
+    it 'escalates threat level' do
+      original = antigen.threat_level
+      engine.escalate_antigen(antigen_id: antigen.id)
+      expect(antigen.threat_level).to be > original
+    end
+
+    it 'de-escalates threat level' do
+      original = antigen.threat_level
+      engine.de_escalate_antigen(antigen_id: antigen.id)
+      expect(antigen.threat_level).to be < original
+    end
+
+    it 'returns nil for unknown antigen' do
+      expect(engine.escalate_antigen(antigen_id: 'bad')).to be_nil
+    end
+  end
+
+  describe '#immunity_for' do
+    it 'returns 0.0 for no antibodies' do
+      expect(engine.immunity_for(antigen_type: :prompt_injection)).to eq(0.0)
+    end
+
+    it 'returns max immunity when antibodies exist' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'a', immunity_level: 0.4)
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'b', immunity_level: 0.7)
+      expect(engine.immunity_for(antigen_type: :prompt_injection)).to eq(0.7)
+    end
+  end
+
+  describe '#critical_antigens' do
+    it 'returns empty initially' do
+      expect(engine.critical_antigens).to be_empty
+    end
+
+    it 'returns critical threats' do
+      engine.register_antigen(pattern: 'bad', antigen_type: :prompt_injection, threat_level: 0.9)
+      expect(engine.critical_antigens.size).to eq(1)
+    end
+  end
+
+  describe '#benign_antigens' do
+    it 'returns low-threat antigens' do
+      engine.register_antigen(pattern: 'ok', antigen_type: :prompt_injection, threat_level: 0.1)
+      expect(engine.benign_antigens.size).to eq(1)
+    end
+  end
+
+  describe '#memory_cells' do
+    it 'returns high-immunity antibodies' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'x', immunity_level: 0.8)
+      expect(engine.memory_cells.size).to eq(1)
+    end
+  end
+
+  describe '#effective_antibodies' do
+    it 'returns antibodies above 0.5' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'x', immunity_level: 0.6)
+      expect(engine.effective_antibodies.size).to eq(1)
+    end
+  end
+
+  describe '#responses_for' do
+    it 'returns responses for a given antigen' do
+      engine.encounter(antigen_id: antigen.id)
+      responses = engine.responses_for(antigen_id: antigen.id)
+      expect(responses.size).to eq(1)
+    end
+  end
+
+  describe '#threat_by_type' do
+    it 'returns hash of all antigen types' do
+      result = engine.threat_by_type
+      expect(result.keys).to include(:prompt_injection, :data_poisoning)
+    end
+
+    it 'computes average threat per type' do
+      engine.register_antigen(pattern: 'a', antigen_type: :prompt_injection, threat_level: 0.8)
+      engine.register_antigen(pattern: 'b', antigen_type: :prompt_injection, threat_level: 0.4)
+      expect(engine.threat_by_type[:prompt_injection]).to eq(0.6)
+    end
+  end
+
+  describe '#overall_immune_health' do
+    it 'returns 1.0 with no antigens' do
+      expect(engine.overall_immune_health).to eq(1.0)
+    end
+
+    it 'returns higher with strong antibodies' do
+      engine.register_antigen(pattern: 'x', antigen_type: :prompt_injection, threat_level: 0.5)
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'y', immunity_level: 0.9)
+      expect(engine.overall_immune_health).to be > 0.5
+    end
+  end
+
+  describe '#most_exposed' do
+    it 'returns antigens sorted by exposure count' do
+      a1 = engine.register_antigen(pattern: 'a', antigen_type: :prompt_injection)
+      a2 = engine.register_antigen(pattern: 'b', antigen_type: :data_poisoning)
+      3.times { engine.encounter(antigen_id: a1.id) }
+      engine.encounter(antigen_id: a2.id)
+      expect(engine.most_exposed(limit: 1).first.id).to eq(a1.id)
+    end
+  end
+
+  describe '#most_threatening' do
+    it 'returns antigens sorted by threat level descending' do
+      engine.register_antigen(pattern: 'low', antigen_type: :prompt_injection, threat_level: 0.2)
+      high = engine.register_antigen(pattern: 'high', antigen_type: :prompt_injection, threat_level: 0.9)
+      expect(engine.most_threatening(limit: 1).first.id).to eq(high.id)
+    end
+  end
+
+  describe '#strongest_antibodies' do
+    it 'returns antibodies sorted by immunity level descending' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'weak', immunity_level: 0.2)
+      strong = engine.create_antibody(antigen_type: :prompt_injection, signature: 'strong', immunity_level: 0.9)
+      expect(engine.strongest_antibodies(limit: 1).first.id).to eq(strong.id)
+    end
+  end
+
+  describe '#immune_report' do
+    it 'includes key report fields' do
+      report = engine.immune_report
+      expect(report).to include(
+        :total_antigens, :total_antibodies, :total_responses,
+        :critical_count, :memory_cell_count, :overall_health,
+        :health_label, :threat_by_type, :most_exposed
+      )
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes summary counts' do
+      hash = engine.to_h
+      expect(hash).to include(:antigens, :antibodies, :responses, :overall_health)
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::ImmuneResponse do
+  subject(:response) do
+    described_class.new(antigen_id: 'ag-1', response_level: :mild_response, intensity: 0.5)
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID id' do
+      expect(response.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores antigen_id' do
+      expect(response.antigen_id).to eq('ag-1')
+    end
+
+    it 'defaults antibody_id to nil' do
+      expect(response.antibody_id).to be_nil
+    end
+
+    it 'stores response_level' do
+      expect(response.response_level).to eq(:mild_response)
+    end
+
+    it 'clamps intensity' do
+      high = described_class.new(antigen_id: 'x', response_level: :monitoring, intensity: 5.0)
+      expect(high.intensity).to eq(1.0)
+    end
+
+    it 'defaults invalid response_level to :monitoring' do
+      bad = described_class.new(antigen_id: 'x', response_level: :nonexistent)
+      expect(bad.response_level).to eq(:monitoring)
+    end
+  end
+
+  describe '#record_action!' do
+    it 'stores the action' do
+      response.record_action!(:block_input)
+      expect(response.action_taken).to eq('block_input')
+    end
+  end
+
+  describe '#adaptive? / #innate?' do
+    it 'is innate when no antibody' do
+      expect(response.innate?).to be true
+      expect(response.adaptive?).to be false
+    end
+
+    it 'is adaptive when antibody present' do
+      adaptive = described_class.new(
+        antigen_id: 'ag-1', antibody_id: 'ab-1', response_level: :strong_response
+      )
+      expect(adaptive.adaptive?).to be true
+      expect(adaptive.innate?).to be false
+    end
+  end
+
+  describe '#severe?' do
+    it 'is false at moderate intensity' do
+      expect(response.severe?).to be false
+    end
+
+    it 'is true at high intensity' do
+      severe = described_class.new(antigen_id: 'x', response_level: :full_rejection, intensity: 0.9)
+      expect(severe.severe?).to be true
+    end
+  end
+
+  describe '#response_label' do
+    it 'returns :mild_response for intensity 0.5' do
+      expect(response.response_label).to eq(:mild_response)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all fields' do
+      hash = response.to_h
+      expect(hash).to include(
+        :id, :antigen_id, :antibody_id, :response_level, :intensity,
+        :response_label, :adaptive, :innate, :severe, :action_taken, :created_at
+      )
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse::Runners::CognitiveImmuneResponse do
+  let(:engine) { Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::ImmuneEngine.new }
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj.instance_variable_set(:@default_engine, engine)
+    obj
+  end
+
+  describe '#register_antigen' do
+    it 'returns success with antigen hash' do
+      result = runner.register_antigen(pattern: 'test', antigen_type: :prompt_injection, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:antigen][:pattern]).to eq('test')
+    end
+  end
+
+  describe '#encounter_antigen' do
+    it 'returns success with response for known antigen' do
+      ag = engine.register_antigen(pattern: 'x', antigen_type: :prompt_injection)
+      result = runner.encounter_antigen(antigen_id: ag.id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:response]).to include(:response_level, :intensity)
+    end
+
+    it 'returns failure for unknown antigen' do
+      result = runner.encounter_antigen(antigen_id: 'bad', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#create_antibody' do
+    it 'returns success with antibody hash' do
+      result = runner.create_antibody(antigen_type: :prompt_injection, signature: 'test', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:antibody][:antigen_type]).to eq(:prompt_injection)
+    end
+  end
+
+  describe '#vaccinate' do
+    it 'returns success with higher initial immunity' do
+      result = runner.vaccinate(antigen_type: :social_engineering, signature: 'authority', engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:vaccinated]).to be true
+      expect(result[:antibody][:immunity_level]).to eq(0.6)
+    end
+  end
+
+  describe '#escalate_threat' do
+    it 'increases threat level' do
+      ag = engine.register_antigen(pattern: 'x', antigen_type: :prompt_injection)
+      result = runner.escalate_threat(antigen_id: ag.id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:antigen][:threat_level]).to be > 0.5
+    end
+
+    it 'returns failure for unknown antigen' do
+      result = runner.escalate_threat(antigen_id: 'bad', engine: engine)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#de_escalate_threat' do
+    it 'decreases threat level' do
+      ag = engine.register_antigen(pattern: 'x', antigen_type: :prompt_injection)
+      result = runner.de_escalate_threat(antigen_id: ag.id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:antigen][:threat_level]).to be < 0.5
+    end
+  end
+
+  describe '#immunity_for' do
+    it 'returns immunity level and label' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'x', immunity_level: 0.7)
+      result = runner.immunity_for(antigen_type: :prompt_injection, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:immunity_level]).to eq(0.7)
+      expect(result[:immunity_label]).to eq(:resistant)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns success with count' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'x')
+      result = runner.decay_all(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:antibodies_decayed]).to eq(1)
+    end
+  end
+
+  describe '#critical_antigens' do
+    it 'returns list of critical antigens' do
+      engine.register_antigen(pattern: 'bad', antigen_type: :prompt_injection, threat_level: 0.9)
+      result = runner.critical_antigens(engine: engine)
+      expect(result[:antigens].size).to eq(1)
+    end
+  end
+
+  describe '#memory_cells' do
+    it 'returns memory cell antibodies' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'x', immunity_level: 0.8)
+      result = runner.memory_cells(engine: engine)
+      expect(result[:antibodies].size).to eq(1)
+    end
+  end
+
+  describe '#most_threatening' do
+    it 'returns antigens sorted by threat' do
+      engine.register_antigen(pattern: 'x', antigen_type: :prompt_injection, threat_level: 0.9)
+      result = runner.most_threatening(engine: engine)
+      expect(result[:antigens].size).to eq(1)
+    end
+  end
+
+  describe '#strongest_antibodies' do
+    it 'returns antibodies sorted by immunity' do
+      engine.create_antibody(antigen_type: :prompt_injection, signature: 'x', immunity_level: 0.9)
+      result = runner.strongest_antibodies(engine: engine)
+      expect(result[:antibodies].size).to eq(1)
+    end
+  end
+
+  describe '#immune_report' do
+    it 'returns comprehensive report' do
+      result = runner.immune_report(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_antigens, :overall_health)
+    end
+  end
+
+  describe '#immune_status' do
+    it 'returns health and label' do
+      result = runner.immune_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:overall_health]).to be_between(0.0, 1.0)
+      expect(result[:health_label]).to be_a(Symbol)
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Immunology::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to detect_threat' do
+    expect(client).to respond_to(:detect_threat)
+  end
+
+  it 'responds to quarantine_threat' do
+    expect(client).to respond_to(:quarantine_threat)
+  end
+
+  it 'responds to release_threat' do
+    expect(client).to respond_to(:release_threat)
+  end
+
+  it 'responds to inoculate' do
+    expect(client).to respond_to(:inoculate)
+  end
+
+  it 'responds to create_antibody' do
+    expect(client).to respond_to(:create_antibody)
+  end
+
+  it 'responds to scan_for_tactic' do
+    expect(client).to respond_to(:scan_for_tactic)
+  end
+
+  it 'responds to trigger_inflammatory_response' do
+    expect(client).to respond_to(:trigger_inflammatory_response)
+  end
+
+  it 'responds to resolve_inflammation' do
+    expect(client).to respond_to(:resolve_inflammation)
+  end
+
+  it 'responds to overall_immunity' do
+    expect(client).to respond_to(:overall_immunity)
+  end
+
+  it 'responds to vulnerability_report' do
+    expect(client).to respond_to(:vulnerability_report)
+  end
+
+  it 'responds to threat_history' do
+    expect(client).to respond_to(:threat_history)
+  end
+
+  it 'responds to decay_all' do
+    expect(client).to respond_to(:decay_all)
+  end
+
+  it 'responds to prune_ineffective' do
+    expect(client).to respond_to(:prune_ineffective)
+  end
+
+  it 'responds to immune_status' do
+    expect(client).to respond_to(:immune_status)
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Defense::Immunology::Helpers::Antibody do
+  subject(:antibody) { described_class.new(tactic: :authority_appeal, pattern: 'claimed expert status') }
+
+  describe '#initialize' do
+    it 'assigns a uuid id' do
+      expect(antibody.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores tactic' do
+      expect(antibody.tactic).to eq(:authority_appeal)
+    end
+
+    it 'stores pattern' do
+      expect(antibody.pattern).to eq('claimed expert status')
+    end
+
+    it 'defaults strength to 0.5' do
+      expect(antibody.strength).to eq(0.5)
+    end
+
+    it 'defaults matches to 0' do
+      expect(antibody.matches).to eq(0)
+    end
+
+    it 'clamps strength above 1.0' do
+      ab = described_class.new(tactic: :gaslighting, pattern: 'x', strength: 2.0)
+      expect(ab.strength).to eq(1.0)
+    end
+
+    it 'clamps strength below 0.0' do
+      ab = described_class.new(tactic: :gaslighting, pattern: 'x', strength: -1.0)
+      expect(ab.strength).to eq(0.0)
+    end
+  end
+
+  describe '#match!' do
+    it 'increments matches' do
+      antibody.match!
+      expect(antibody.matches).to eq(1)
+    end
+
+    it 'boosts strength' do
+      original = antibody.strength
+      antibody.match!
+      expect(antibody.strength).to be > original
+    end
+
+    it 'does not exceed 1.0' do
+      ab = described_class.new(tactic: :gaslighting, pattern: 'x', strength: 1.0)
+      ab.match!
+      expect(ab.strength).to eq(1.0)
+    end
+  end
+
+  describe '#decay!' do
+    it 'reduces strength by RESISTANCE_DECAY' do
+      original = antibody.strength
+      antibody.decay!
+      expect(antibody.strength).to be_within(0.001).of(original - Legion::Extensions::Agentic::Defense::Immunology::Helpers::Constants::RESISTANCE_DECAY)
+    end
+
+    it 'does not go below 0.0' do
+      ab = described_class.new(tactic: :gaslighting, pattern: 'x', strength: 0.0)
+      ab.decay!
+      expect(ab.strength).to eq(0.0)
+    end
+  end
+
+  describe '#effective?' do
+    it 'returns true when strength >= 0.3' do
+      expect(antibody.effective?).to be true
+    end
+
+    it 'returns false when strength < 0.3' do
+      ab = described_class.new(tactic: :gaslighting, pattern: 'x', strength: 0.1)
+      expect(ab.effective?).to be false
+    end
+
+    it 'returns true at exactly 0.3' do
+      ab = described_class.new(tactic: :gaslighting, pattern: 'x', strength: 0.3)
+      expect(ab.effective?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all fields' do
+      h = antibody.to_h
+      expect(h).to include(:id, :tactic, :pattern, :strength, :matches, :effective, :created_at)
+    end
+
+    it 'includes effective status' do
+      h = antibody.to_h
+      expect(h[:effective]).to be true
+    end
+  end
+end