lex-agentic-defense 0.1.0 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38b6880ab2168a8ec8e0e037c8f031d175eb30312cea1b00981b7d5b67a631b1
-  data.tar.gz: ee8f26503794b5f3168120b1bd9537f9fdcad7eedfb5dd0efab75b016ce55b59
+  metadata.gz: 3dabe10b53cfee2ee630d2f7094a78a0731f7a0f4038f218bf2ac177d409352b
+  data.tar.gz: 78a58c65ef5d6465e03322e6fe9031c333078c65b983bf0be11b07b2f27b3fd7
 SHA512:
-  metadata.gz: 8cfe651310f156f79c8c1476e210fd17b90a2344d689d5b636edd94396d59353b42f8ae53e36f4e4e400f0c7584272dbc79ae6d0fa434fded2a8f2f3c4e4fcd7
-  data.tar.gz: 929f72c0515d624586865faed6ed4ecd65cfa8f3c65849f66363539b1d7c66c2b65210c8cca8190f4dccf19eb4fe5fe4f9634e55a61d477e4662e9a841fa0eae
+  metadata.gz: 671ce401a9d8ba558d5ee77e8223b716115543d892944542155be97748052c0240830c535995c60251bd2d8fcb40abf16eeffe15f84bce38eae6bcd9eaabb493
+  data.tar.gz: 5c91978e36743338e7fa07bc290d8c26650016a9d6523ea1ffc7532a241a6a83617dc4a1b9f5483d0c8abc26111f02bfc19051fb954b79b639a9dc0bf26cb139

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [0.1.3] - 2026-03-21
+
+### Added
+- Right-to-erasure propagation from extinction level 4 to Apollo knowledge store
+- Apollo erasure wired in enforce_escalation_effects (delete non-confirmed, redact confirmed)
+
+### Changed
+- enforce_escalation_effects restructured: DigitalWorker termination uses if-block instead of early return
+
+## [0.1.2] - 2026-03-18
+
+### Changed
+- Enforce ANTIGEN_TYPES at ImmuneResponse::ImmuneEngine method boundaries: `register_antigen` and `create_antibody` return nil for invalid antigen_type values (v0.1.1)
+- Enforce MANIPULATION_TACTICS at Immunology::ImmuneEngine method boundaries: `detect_threat` and `create_antibody` return nil for invalid tactic values (v0.1.1)
+- Added 8 new enum validation specs (2 per enforced constant)
+
+## [0.1.1] - 2026-03-18
+
+### Changed
+- Enforce STATE_TYPES at FrictionEngine method boundaries: `set_current_state`, `set_friction`, `get_friction`, `attempt_transition`, `force_transition` return nil for invalid state values
+- Enforce CLAIM_VERDICTS at VigilanceEngine#adjudicate_claim: returns nil for invalid verdict values
+- Updated specs to use valid STATE_TYPES values; added 8 new enum validation specs
+
 ## [0.1.0] - 2026-03-18
 
 ### Added

data/README.md

@@ -1,13 +1,55 @@
 # lex-agentic-defense
 
-LEX agentic defense domain: threat detection, stress response, boundaries
+Domain consolidation gem for cognitive defense, immunity, and error management. Bundles 15 source extensions into one loadable unit under `Legion::Extensions::Agentic::Defense`.
 
-## Sub-modules
+## Overview
 
-*(populated as extensions are consolidated)*
+**Gem**: `lex-agentic-defense`
+**Version**: 0.1.2
+**Namespace**: `Legion::Extensions::Agentic::Defense`
+
+## Sub-Modules
+
+| Sub-Module | Source Gem | Purpose |
+|---|---|---|
+| `Defense::ImmuneResponse` | `lex-cognitive-immune-response` | Active defense responses to cognitive threats |
+| `Defense::Immunology` | `lex-cognitive-immunology` | Immune system modeling for belief protection |
+| `Defense::Erosion` | `lex-cognitive-erosion` | Gradual degradation of outdated beliefs |
+| `Defense::Friction` | `lex-cognitive-friction` | Resistance to undesired belief or behavior change |
+| `Defense::Quicksand` | `lex-cognitive-quicksand` | Entrapment patterns — stuck states |
+| `Defense::Quicksilver` | `lex-cognitive-quicksilver` | Rapid adaptive response to threats |
+| `Defense::Phantom` | `lex-cognitive-phantom` | Phantom cognitive states — residual patterns after removal |
+| `Defense::EpistemicVigilance` | `lex-epistemic-vigilance` | Critical evaluation of incoming information, deception detection |
+| `Defense::Bias` | `lex-bias` | Cognitive bias catalog and de-biasing strategies |
+| `Defense::Confabulation` | `lex-confabulation` | False memory generation detection |
+| `Defense::Dissonance` | `lex-dissonance` | Cognitive dissonance detection and reduction |
+| `Defense::ErrorMonitoring` | `lex-error-monitoring` | ACC error monitoring — anterior cingulate analog |
+| `Defense::Extinction` | `lex-extinction` | Four-level containment ladder with authority-gated escalation |
+| `Defense::Avalanche` | `lex-cognitive-avalanche` | Cascading cognitive failure detection |
+| `Defense::Whirlpool` | `lex-cognitive-whirlpool` | Circular/recursive thought pattern detection |
+
+## Actors
+
+- `Defense::Bias::Actors::Update` — interval actor, updates bias calibration state
+- `Defense::Confabulation::Actors::Decay` — interval actor, decays confabulation detections
+- `Defense::EpistemicVigilance::Actors::Update` — interval actor, updates vigilance baseline
+- `Defense::ErrorMonitoring::Actors::Tick` — interval actor, runs error monitoring tick
+- `Defense::Extinction::Actors::ProtocolMonitor` — runs every 300s, monitors containment protocol state
 
 ## Installation
 
 ```ruby
 gem 'lex-agentic-defense'
 ```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec        # 1706 examples, 0 failures
+bundle exec rubocop      # 0 offenses
+```
+
+## License
+
+MIT

data/lib/legion/extensions/agentic/defense/epistemic_vigilance/helpers/vigilance_engine.rb

@@ -74,6 +74,8 @@ module Legion
               end
 
               def adjudicate_claim(claim_id:, verdict:)
+                return nil unless CLAIM_VERDICTS.include?(verdict.to_sym)
+
                 claim  = @claims[claim_id]
                 source = claim && @sources[claim.source_id]
                 return { error: :claim_not_found } unless claim

data/lib/legion/extensions/agentic/defense/epistemic_vigilance/version.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Defense
         module EpistemicVigilance
-          VERSION = '0.1.0'
+          VERSION = '0.1.1'
         end
       end
     end

data/lib/legion/extensions/agentic/defense/extinction/runners/extinction.rb

@@ -84,16 +84,26 @@ module Legion
                   Legion::Logging.warn '[extinction] cryptographic erasure triggered'
                 end
 
-                return unless defined?(Legion::Data::Model::DigitalWorker)
+                if defined?(Legion::Data::Model::DigitalWorker)
+                  begin
+                    Legion::Data::Model::DigitalWorker.where(lifecycle_state: 'active').update(
+                      lifecycle_state: 'terminated', updated_at: Time.now.utc
+                    )
+                  rescue StandardError
+                    nil
+                  end
+                  Legion::Logging.warn '[extinction] all active workers terminated'
+                end
+
+                return unless defined?(Legion::Extensions::Apollo::Runners::Knowledge)
 
                 begin
-                  Legion::Data::Model::DigitalWorker.where(lifecycle_state: 'active').update(
-                    lifecycle_state: 'terminated', updated_at: Time.now.utc
-                  )
-                rescue StandardError
-                  nil
+                  obj = Object.new.extend(Legion::Extensions::Apollo::Runners::Knowledge)
+                  obj.handle_erasure_request(agent_id: 'system:extinction')
+                  Legion::Logging.warn '[extinction] apollo erasure propagated'
+                rescue StandardError => e
+                  Legion::Logging.error "[extinction] apollo erasure failed: #{e.message}"
                 end
-                Legion::Logging.warn '[extinction] all active workers terminated'
               end
 
               def emit_escalation_event(level, authority, reason)

data/lib/legion/extensions/agentic/defense/friction/helpers/friction_engine.rb

@@ -16,24 +16,34 @@ module Legion
               end
 
               def set_current_state(state:)
+                return nil unless STATE_TYPES.include?(state.to_sym)
+
                 @current_state = state.to_sym
               end
 
               attr_reader :current_state
 
               def set_friction(from_state:, to_state:, friction:)
+                return nil unless STATE_TYPES.include?(from_state.to_sym)
+                return nil unless STATE_TYPES.include?(to_state.to_sym)
+
                 key = :"#{from_state}_to_#{to_state}"
                 @friction_map[key] = friction.to_f.clamp(0.0, 1.0)
               end
 
               def get_friction(from_state:, to_state:)
+                return nil unless STATE_TYPES.include?(from_state.to_sym)
+                return nil unless STATE_TYPES.include?(to_state.to_sym)
+
                 key = :"#{from_state}_to_#{to_state}"
                 @friction_map.fetch(key, DEFAULT_FRICTION)
               end
 
               def attempt_transition(to_state:, force: 0.5)
+                return nil unless STATE_TYPES.include?(to_state.to_sym)
+
                 prune_if_needed
-                friction = get_friction(from_state: @current_state, to_state: to_state)
+                friction = get_friction(from_state: @current_state, to_state: to_state) || DEFAULT_FRICTION
                 transition = StateTransition.new(
                   from_state: @current_state,
                   to_state:   to_state,
@@ -46,8 +56,10 @@ module Legion
               end
 
               def force_transition(to_state:)
+                return nil unless STATE_TYPES.include?(to_state.to_sym)
+
                 prune_if_needed
-                friction = get_friction(from_state: @current_state, to_state: to_state)
+                friction = get_friction(from_state: @current_state, to_state: to_state) || DEFAULT_FRICTION
                 transition = StateTransition.new(
                   from_state: @current_state,
                   to_state:   to_state,

data/lib/legion/extensions/agentic/defense/friction/version.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Defense
         module Friction
-          VERSION = '0.1.0'
+          VERSION = '0.1.1'
         end
       end
     end

data/lib/legion/extensions/agentic/defense/immune_response/helpers/immune_engine.rb

@@ -16,6 +16,8 @@ module Legion
               end
 
               def register_antigen(pattern:, antigen_type:, threat_level: DEFAULT_THREAT_LEVEL)
+                return nil unless ANTIGEN_TYPES.include?(antigen_type.to_sym)
+
                 prune_antigens
                 antigen = Antigen.new(
                   pattern: pattern, antigen_type: antigen_type, threat_level: threat_level
@@ -38,6 +40,8 @@ module Legion
               end
 
               def create_antibody(antigen_type:, signature:, immunity_level: 0.3)
+                return nil unless ANTIGEN_TYPES.include?(antigen_type.to_sym)
+
                 prune_antibodies
                 antibody = Antibody.new(
                   antigen_type: antigen_type, signature: signature, immunity_level: immunity_level

data/lib/legion/extensions/agentic/defense/immune_response/version.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Defense
         module ImmuneResponse
-          VERSION = '0.1.0'
+          VERSION = '0.1.1'
         end
       end
     end

data/lib/legion/extensions/agentic/defense/immunology/helpers/immune_engine.rb

@@ -17,6 +17,8 @@ module Legion
               end
 
               def detect_threat(source:, tactic:, content_hash:, threat_level: 0.5)
+                return nil unless Constants::MANIPULATION_TACTICS.include?(tactic.to_sym)
+
                 prune_threats_if_full
 
                 threat = Threat.new(
@@ -68,6 +70,8 @@ module Legion
               end
 
               def create_antibody(tactic:, pattern:, strength: 0.5)
+                return nil unless Constants::MANIPULATION_TACTICS.include?(tactic.to_sym)
+
                 prune_antibodies_if_full
 
                 ab = Antibody.new(tactic: tactic, pattern: pattern, strength: strength)

data/lib/legion/extensions/agentic/defense/immunology/version.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Defense
         module Immunology
-          VERSION = '0.1.0'
+          VERSION = '0.1.1'
         end
       end
     end

data/lib/legion/extensions/agentic/defense/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Defense
-        VERSION = '0.1.0'
+        VERSION = '0.1.4'
       end
     end
   end

data/spec/legion/extensions/agentic/defense/epistemic_vigilance/helpers/vigilance_engine_spec.rb

@@ -149,6 +149,20 @@ RSpec.describe Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers
       after = engine.source_reliability(source_id: source_id)[:reliability]
       expect(after).to be < before
     end
+
+    it 'returns nil for an invalid verdict' do
+      result = engine.adjudicate_claim(claim_id: claim_id, verdict: :bogus_verdict)
+      expect(result).to be_nil
+    end
+
+    it 'accepts all valid CLAIM_VERDICTS' do
+      verdicts = Legion::Extensions::Agentic::Defense::EpistemicVigilance::Helpers::Constants::CLAIM_VERDICTS
+      verdicts.each do |v|
+        cid = engine.submit_claim(content: "claim_#{v}", source_id: source_id, domain: :science)[:claim][:id]
+        result = engine.adjudicate_claim(claim_id: cid, verdict: v)
+        expect(result[:verdict]).to eq(v)
+      end
+    end
   end
 
   describe '#source_reliability' do

data/spec/legion/extensions/agentic/defense/extinction/runners/extinction_spec.rb

@@ -80,6 +80,26 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Extinction::Runners::Extinc
       expect(pc_mod).to receive(:erase_all)
       client.escalate(level: 4, authority: :physical_keyholders, reason: 'final')
     end
+
+    it 'propagates Apollo erasure on level 4' do
+      events = Module.new { def self.emit(*, **); end }
+      stub_const('Legion::Events', events)
+      pc_mod = Module.new { def self.erase_all; end }
+      stub_const('Legion::Extensions::Privatecore::Runners::Privatecore', pc_mod)
+
+      apollo_runner = Module.new do
+        def handle_erasure_request(agent_id:, **)
+          { deleted: 1, redacted: 0, agent_id: agent_id }
+        end
+      end
+      stub_const('Legion::Extensions::Apollo::Runners::Knowledge', apollo_runner)
+
+      client.escalate(level: 1, authority: :governance_council, reason: 's1')
+      client.escalate(level: 2, authority: :governance_council, reason: 's2')
+      client.escalate(level: 3, authority: :council_plus_executive, reason: 's3')
+      result = client.escalate(level: 4, authority: :physical_keyholders, reason: 'final')
+      expect(result[:escalated]).to be true
+    end
   end
 
   describe '#monitor_protocol' do

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

@@ -10,92 +10,126 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Helpers::Friction
   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)
+    it 'changes the current state to a valid STATE_TYPE' do
+      engine.set_current_state(state: :focus_mode)
+      expect(engine.current_state).to eq(:focus_mode)
     end
 
-    it 'converts to symbol' do
-      engine.set_current_state(state: 'thinking')
-      expect(engine.current_state).to eq(:thinking)
+    it 'returns nil for an invalid state' do
+      result = engine.set_current_state(state: :invalid_state)
+      expect(result).to be_nil
+      expect(engine.current_state).to eq(:rest_mode)
+    end
+
+    it 'accepts all valid STATE_TYPES' do
+      described_class.include(Legion::Extensions::Agentic::Defense::Friction::Helpers::Constants)
+      Legion::Extensions::Agentic::Defense::Friction::Helpers::Constants::STATE_TYPES.each do |state|
+        eng = described_class.new
+        eng.set_current_state(state: state)
+        expect(eng.current_state).to eq(state)
+      end
     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)
+    it 'stores and retrieves friction for a valid path' do
+      engine.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.7)
+      expect(engine.get_friction(from_state: :rest_mode, to_state: :focus_mode)).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)
+      engine.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 5.0)
+      expect(engine.get_friction(from_state: :rest_mode, to_state: :focus_mode)).to eq(1.0)
+    end
+
+    it 'returns nil when from_state is invalid' do
+      expect(engine.set_friction(from_state: :invalid, to_state: :focus_mode, friction: 0.5)).to be_nil
+    end
+
+    it 'returns nil when to_state is invalid' do
+      expect(engine.set_friction(from_state: :rest_mode, to_state: :invalid, friction: 0.5)).to be_nil
     end
 
-    it 'returns default friction for unknown paths' do
+    it 'returns nil from get_friction when from_state is invalid' do
+      expect(engine.get_friction(from_state: :invalid, to_state: :focus_mode)).to be_nil
+    end
+
+    it 'returns default friction for unknown valid 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)
+      expect(engine.get_friction(from_state: :rest_mode, to_state: :focus_mode)).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)
+      engine.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.3)
+      transition = engine.attempt_transition(to_state: :focus_mode, force: 0.8)
       expect(transition.completed?).to be true
-      expect(engine.current_state).to eq(:active)
+      expect(engine.current_state).to eq(:focus_mode)
     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)
+      engine.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.9)
+      transition = engine.attempt_transition(to_state: :focus_mode, 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)
+      engine.attempt_transition(to_state: :focus_mode, force: 0.8)
       expect(engine.transition_history.size).to eq(1)
     end
+
+    it 'returns nil for invalid to_state' do
+      result = engine.attempt_transition(to_state: :invalid_state, force: 0.9)
+      expect(result).to be_nil
+    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)
+      engine.set_friction(from_state: :rest_mode, to_state: :vigilant_mode, friction: 1.0)
+      transition = engine.force_transition(to_state: :vigilant_mode)
       expect(transition.completed?).to be true
-      expect(engine.current_state).to eq(:locked)
+      expect(engine.current_state).to eq(:vigilant_mode)
+    end
+
+    it 'returns nil for invalid to_state' do
+      result = engine.force_transition(to_state: :bogus_mode)
+      expect(result).to be_nil
     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)
+      engine.attempt_transition(to_state: :focus_mode, force: 0.9)
+      engine.attempt_transition(to_state: :analytical_mode, 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) }
+      states = %i[focus_mode social_mode analytical_mode creative_mode vigilant_mode]
+      states.each { |s| engine.attempt_transition(to_state: s, 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)
+      engine.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.3)
+      engine.attempt_transition(to_state: :focus_mode, force: 0.8)
+      engine.set_current_state(state: :focus_mode)
+      engine.set_friction(from_state: :focus_mode, to_state: :analytical_mode, friction: 0.9)
+      engine.attempt_transition(to_state: :analytical_mode, 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)
+      engine.set_friction(from_state: :rest_mode, to_state: :vigilant_mode, friction: 0.9)
+      engine.attempt_transition(to_state: :vigilant_mode, force: 0.1)
       expect(engine.resisted_transitions.size).to eq(1)
     end
   end
@@ -106,10 +140,11 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Helpers::Friction
     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)
+      engine.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.3)
+      engine.attempt_transition(to_state: :focus_mode, force: 0.8)
+      engine.set_current_state(state: :focus_mode)
+      engine.set_friction(from_state: :focus_mode, to_state: :social_mode, friction: 0.9)
+      engine.attempt_transition(to_state: :social_mode, force: 0.1)
       expect(engine.success_rate).to eq(0.5)
     end
   end
@@ -120,26 +155,28 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Helpers::Friction
     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)
+      engine.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.2)
+      engine.attempt_transition(to_state: :focus_mode, force: 0.9)
+      engine.set_current_state(state: :focus_mode)
+      engine.set_friction(from_state: :focus_mode, to_state: :social_mode, friction: 0.8)
+      engine.attempt_transition(to_state: :social_mode, 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)
+      engine.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.3)
+      engine.set_friction(from_state: :rest_mode, to_state: :social_mode, friction: 0.9)
+      engine.set_friction(from_state: :rest_mode, to_state: :analytical_mode, 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) }
+      valid_states = %i[focus_mode social_mode analytical_mode creative_mode vigilant_mode]
+      valid_states.each { |s| engine.set_friction(from_state: :rest_mode, to_state: s, friction: 0.5) }
       expect(engine.highest_friction_paths(limit: 2).size).to eq(2)
     end
   end
@@ -168,7 +205,8 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Helpers::Friction
     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) }
+      states = %i[focus_mode social_mode analytical_mode creative_mode]
+      states.each { |s| eng.attempt_transition(to_state: s, force: 0.9) }
       expect(eng.transition_history.size).to eq(3)
     end
   end

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

@@ -5,15 +5,15 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Runners::Cognitiv
 
   describe '#set_current_state' do
     it 'returns success with new state' do
-      result = client.set_current_state(state: :active)
+      result = client.set_current_state(state: :focus_mode)
       expect(result[:success]).to be true
-      expect(result[:state]).to eq(:active)
+      expect(result[:state]).to eq(:focus_mode)
     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)
+      result = client.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.7)
       expect(result[:success]).to be true
       expect(result[:friction]).to eq(0.7)
     end
@@ -21,8 +21,8 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Runners::Cognitiv
 
   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)
+      client.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.6)
+      result = client.get_friction(from_state: :rest_mode, to_state: :focus_mode)
       expect(result[:success]).to be true
       expect(result[:friction]).to eq(0.6)
     end
@@ -30,7 +30,7 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Runners::Cognitiv
 
   describe '#attempt_transition' do
     it 'returns transition details' do
-      result = client.attempt_transition(to_state: :active, force: 0.9)
+      result = client.attempt_transition(to_state: :focus_mode, force: 0.9)
       expect(result[:success]).to be true
       expect(result[:transition]).to be_a(Hash)
       expect(result[:current_state]).to be_a(Symbol)
@@ -39,7 +39,7 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Runners::Cognitiv
 
   describe '#force_transition' do
     it 'always completes' do
-      result = client.force_transition(to_state: :locked)
+      result = client.force_transition(to_state: :vigilant_mode)
       expect(result[:success]).to be true
       expect(result[:transition][:completed]).to be true
     end
@@ -47,7 +47,7 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Runners::Cognitiv
 
   describe '#transition_history' do
     it 'returns history array' do
-      client.attempt_transition(to_state: :a, force: 0.9)
+      client.attempt_transition(to_state: :focus_mode, force: 0.9)
       result = client.transition_history
       expect(result[:success]).to be true
       expect(result[:count]).to eq(1)
@@ -72,7 +72,7 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Friction::Runners::Cognitiv
 
   describe '#highest_friction_paths' do
     it 'returns paths array' do
-      client.set_friction(from_state: :a, to_state: :b, friction: 0.8)
+      client.set_friction(from_state: :rest_mode, to_state: :focus_mode, friction: 0.8)
       result = client.highest_friction_paths
       expect(result[:success]).to be true
       expect(result[:paths]).to be_a(Array)

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

@@ -2,6 +2,6 @@
 
 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')
+    expect(Legion::Extensions::Agentic::Defense::ImmuneResponse::VERSION).to eq('0.1.1')
   end
 end

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

@@ -15,6 +15,19 @@ RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Im
       ag = engine.register_antigen(pattern: 'test', antigen_type: :data_poisoning)
       expect(engine.most_threatening.map(&:id)).to include(ag.id)
     end
+
+    it 'rejects invalid antigen_type' do
+      result = engine.register_antigen(pattern: 'test', antigen_type: :nonexistent_threat)
+      expect(result).to be_nil
+    end
+
+    it 'accepts all ANTIGEN_TYPES' do
+      constants = Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Constants::ANTIGEN_TYPES
+      constants.each do |val|
+        result = engine.register_antigen(pattern: 'test', antigen_type: val)
+        expect(result).not_to be_nil, "Expected #{val.inspect} to be accepted"
+      end
+    end
   end
 
   describe '#encounter' do
@@ -52,6 +65,19 @@ RSpec.describe Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Im
       ab = engine.create_antibody(antigen_type: :prompt_injection, signature: 'test')
       expect(ab).to be_a(Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Antibody)
     end
+
+    it 'rejects invalid antigen_type' do
+      result = engine.create_antibody(antigen_type: :nonexistent_threat, signature: 'test')
+      expect(result).to be_nil
+    end
+
+    it 'accepts all ANTIGEN_TYPES' do
+      constants = Legion::Extensions::Agentic::Defense::ImmuneResponse::Helpers::Constants::ANTIGEN_TYPES
+      constants.each do |val|
+        result = engine.create_antibody(antigen_type: val, signature: 'test')
+        expect(result).not_to be_nil, "Expected #{val.inspect} to be accepted"
+      end
+    end
   end
 
   describe '#vaccinate' do

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

@@ -36,6 +36,19 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Immunology::Helpers::Immune
       engine.detect_threat(source: 's2', tactic: :strawman, content_hash: 'b')
       expect(engine.to_h[:threat_count]).to eq(2)
     end
+
+    it 'rejects invalid tactic' do
+      result = engine.detect_threat(source: 'user', tactic: :nonexistent_tactic, content_hash: 'h1')
+      expect(result).to be_nil
+    end
+
+    it 'accepts all MANIPULATION_TACTICS' do
+      constants = Legion::Extensions::Agentic::Defense::Immunology::Helpers::Constants::MANIPULATION_TACTICS
+      constants.each do |val|
+        result = engine.detect_threat(source: 'user', tactic: val, content_hash: "hash_#{val}")
+        expect(result).not_to be_nil, "Expected #{val.inspect} to be accepted"
+      end
+    end
   end
 
   describe '#quarantine_threat' do
@@ -114,6 +127,19 @@ RSpec.describe Legion::Extensions::Agentic::Defense::Immunology::Helpers::Immune
       ab = engine.create_antibody(tactic: :gaslighting, pattern: 'test', strength: 0.8)
       expect(ab.strength).to eq(0.8)
     end
+
+    it 'rejects invalid tactic' do
+      result = engine.create_antibody(tactic: :nonexistent_tactic, pattern: 'test')
+      expect(result).to be_nil
+    end
+
+    it 'accepts all MANIPULATION_TACTICS' do
+      constants = Legion::Extensions::Agentic::Defense::Immunology::Helpers::Constants::MANIPULATION_TACTICS
+      constants.each do |val|
+        result = engine.create_antibody(tactic: val, pattern: "pattern_#{val}")
+        expect(result).not_to be_nil, "Expected #{val.inspect} to be accepted"
+      end
+    end
   end
 
   describe '#scan_for_tactic' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-defense
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.4
 platform: ruby
 authors:
 - Esity