lex-agentic-defense 0.1.0

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Immunology
+          module Helpers
+            class Antibody
+              attr_reader :id, :tactic, :pattern, :created_at
+              attr_accessor :strength, :matches
+
+              def initialize(tactic:, pattern:, strength: 0.5)
+                @id       = SecureRandom.uuid
+                @tactic   = tactic
+                @pattern  = pattern
+                @strength = strength.clamp(0.0, 1.0)
+                @matches  = 0
+                @created_at = Time.now.utc
+              end
+
+              def match!
+                @matches += 1
+                boost = Constants::RESISTANCE_BOOST / (@matches + 1)
+                @strength = (@strength + boost.round(10)).clamp(0.0, 1.0).round(10)
+              end
+
+              def decay!
+                @strength = (@strength - Constants::RESISTANCE_DECAY).clamp(0.0, 1.0).round(10)
+              end
+
+              def effective?
+                @strength >= 0.3
+              end
+
+              def to_h
+                {
+                  id:         @id,
+                  tactic:     @tactic,
+                  pattern:    @pattern,
+                  strength:   @strength,
+                  matches:    @matches,
+                  effective:  effective?,
+                  created_at: @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Immunology
+          module Helpers
+            module Constants
+              DEFAULT_RESISTANCE = 0.5
+              RESISTANCE_BOOST   = 0.1
+              RESISTANCE_DECAY   = 0.02
+              MAX_THREATS        = 500
+              MAX_ANTIBODIES     = 200
+
+              THREAT_LABELS = {
+                (0.8..)     => :critical,
+                (0.6...0.8) => :severe,
+                (0.4...0.6) => :moderate,
+                (0.2...0.4) => :low,
+                (..0.2)     => :negligible
+              }.freeze
+
+              IMMUNITY_LABELS = {
+                (0.8..)     => :immune,
+                (0.6...0.8) => :resistant,
+                (0.4...0.6) => :normal,
+                (0.2...0.4) => :vulnerable,
+                (..0.2)     => :compromised
+              }.freeze
+
+              MANIPULATION_TACTICS = %i[
+                authority_appeal emotional_blackmail false_urgency
+                social_proof_abuse gaslighting strawman ad_hominem
+                sunk_cost_exploit bandwagon fear_mongering
+              ].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Immunology
+          module Helpers
+            class ImmuneEngine
+              attr_reader :resistance, :inflammatory
+
+              def initialize
+                @threats      = {}
+                @antibodies   = {}
+                @resistance   = Constants::DEFAULT_RESISTANCE
+                @inflammatory = false
+              end
+
+              def detect_threat(source:, tactic:, content_hash:, threat_level: 0.5)
+                prune_threats_if_full
+
+                threat = Threat.new(
+                  source:       source,
+                  tactic:       tactic,
+                  content_hash: content_hash,
+                  threat_level: threat_level
+                )
+
+                matched = match_antibodies_for_tactic(tactic)
+                matched.each do |ab|
+                  ab.match!
+                  reduction = (ab.strength * 0.2).round(10)
+                  threat.threat_level = (threat.threat_level - reduction).clamp(0.0, 1.0).round(10)
+                end
+
+                @threats[threat.id] = threat
+                Legion::Logging.debug "[cognitive_immunology] threat detected: id=#{threat.id} tactic=#{tactic} level=#{threat.threat_level.round(2)}"
+                threat
+              end
+
+              def quarantine_threat(threat_id:)
+                threat = @threats.fetch(threat_id, nil)
+                return { success: false, reason: 'not found' } unless threat
+
+                threat.quarantine!
+                Legion::Logging.info "[cognitive_immunology] quarantined: id=#{threat_id} tactic=#{threat.tactic}"
+                { success: true, threat_id: threat_id }
+              end
+
+              def release_threat(threat_id:)
+                threat = @threats.fetch(threat_id, nil)
+                return { success: false, reason: 'not found' } unless threat
+
+                threat.release!
+                Legion::Logging.debug "[cognitive_immunology] released: id=#{threat_id}"
+                { success: true, threat_id: threat_id }
+              end
+
+              def inoculate(threat_id:)
+                threat = @threats.fetch(threat_id, nil)
+                return { success: false, reason: 'not found' } unless threat
+
+                threat.expose!
+                boost = (Constants::RESISTANCE_BOOST / (threat.exposure_count + 1)).round(10)
+                @resistance = (@resistance + boost).clamp(0.0, 1.0).round(10)
+                Legion::Logging.debug "[cognitive_immunology] inoculate: id=#{threat_id} exposure=#{threat.exposure_count} resistance=#{@resistance.round(2)}"
+                { success: true, threat_id: threat_id, exposure_count: threat.exposure_count, resistance: @resistance }
+              end
+
+              def create_antibody(tactic:, pattern:, strength: 0.5)
+                prune_antibodies_if_full
+
+                ab = Antibody.new(tactic: tactic, pattern: pattern, strength: strength)
+                @antibodies[ab.id] = ab
+                Legion::Logging.info "[cognitive_immunology] antibody created: id=#{ab.id} tactic=#{tactic} strength=#{strength}"
+                ab
+              end
+
+              def scan_for_tactic(tactic:)
+                @threats.values.select { |t| t.tactic == tactic }
+              end
+
+              def trigger_inflammatory_response
+                @inflammatory = true
+                Legion::Logging.warn '[cognitive_immunology] inflammatory response triggered — heightened scrutiny mode'
+                { inflammatory: true }
+              end
+
+              def resolve_inflammation
+                @inflammatory = false
+                Legion::Logging.info '[cognitive_immunology] inflammation resolved — returning to normal scrutiny'
+                { inflammatory: false }
+              end
+
+              def overall_immunity
+                ab_coverage = antibody_coverage_score
+                score = ((@resistance * 0.6) + (ab_coverage * 0.4)).round(10)
+                score.clamp(0.0, 1.0)
+              end
+
+              def immunity_label
+                score = overall_immunity
+                Constants::IMMUNITY_LABELS.find { |range, _| range.cover?(score) }&.last || :compromised
+              end
+
+              def vulnerability_report
+                covered_tactics = @antibodies.values.map(&:tactic).uniq
+                uncovered = Constants::MANIPULATION_TACTICS.reject { |t| covered_tactics.include?(t) }
+                {
+                  covered:   covered_tactics,
+                  uncovered: uncovered,
+                  coverage:  (covered_tactics.size.to_f / Constants::MANIPULATION_TACTICS.size).round(10)
+                }
+              end
+
+              def threat_history(limit: 10)
+                @threats.values
+                        .sort_by(&:created_at)
+                        .last(limit)
+                        .map(&:to_h)
+              end
+
+              def decay_all
+                @antibodies.each_value(&:decay!)
+                @resistance = (@resistance - Constants::RESISTANCE_DECAY).clamp(0.0, 1.0).round(10)
+                Legion::Logging.debug "[cognitive_immunology] decay cycle: resistance=#{@resistance.round(2)} antibodies=#{@antibodies.size}"
+                { resistance: @resistance, antibodies_decayed: @antibodies.size }
+              end
+
+              def prune_ineffective
+                before = @antibodies.size
+                @antibodies.select! { |_, ab| ab.effective? }
+                pruned = before - @antibodies.size
+                Legion::Logging.debug "[cognitive_immunology] pruned #{pruned} ineffective antibodies"
+                { pruned: pruned, remaining: @antibodies.size }
+              end
+
+              def to_h
+                {
+                  threat_count:             @threats.size,
+                  quarantined_count:        @threats.values.count(&:quarantined),
+                  antibody_count:           @antibodies.size,
+                  effective_antibody_count: @antibodies.values.count(&:effective?),
+                  resistance:               @resistance,
+                  inflammatory:             @inflammatory,
+                  overall_immunity:         overall_immunity,
+                  immunity_label:           immunity_label
+                }
+              end
+
+              private
+
+              def match_antibodies_for_tactic(tactic)
+                @antibodies.values.select { |ab| ab.tactic == tactic && ab.effective? }
+              end
+
+              def antibody_coverage_score
+                return 0.0 if @antibodies.empty?
+
+                effective = @antibodies.values.select(&:effective?)
+                return 0.0 if effective.empty?
+
+                avg_strength = effective.sum(&:strength) / effective.size.to_f
+                tactic_coverage = vulnerability_report[:coverage]
+                ((avg_strength * 0.5) + (tactic_coverage * 0.5)).round(10)
+              end
+
+              def prune_threats_if_full
+                return unless @threats.size >= Constants::MAX_THREATS
+
+                oldest = @threats.values.min_by(&:created_at)
+                @threats.delete(oldest.id) if oldest
+              end
+
+              def prune_antibodies_if_full
+                return unless @antibodies.size >= Constants::MAX_ANTIBODIES
+
+                weakest = @antibodies.values.min_by(&:strength)
+                @antibodies.delete(weakest.id) if weakest
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Immunology
+          module Helpers
+            class Threat
+              attr_reader :id, :source, :tactic, :content_hash, :created_at
+              attr_accessor :threat_level, :quarantined, :exposure_count
+
+              def initialize(source:, tactic:, content_hash:, threat_level: 0.5)
+                @id             = SecureRandom.uuid
+                @source         = source
+                @tactic         = tactic
+                @content_hash   = content_hash
+                @threat_level   = threat_level.clamp(0.0, 1.0)
+                @quarantined    = false
+                @exposure_count = 0
+                @created_at     = Time.now.utc
+              end
+
+              def threat_label
+                Constants::THREAT_LABELS.find { |range, _| range.cover?(@threat_level) }&.last || :negligible
+              end
+
+              def quarantine!
+                @quarantined = true
+              end
+
+              def release!
+                @quarantined = false
+              end
+
+              def expose!
+                @exposure_count += 1
+                reduction = (0.05 / (@exposure_count + 1)).round(10)
+                @threat_level = (@threat_level - reduction).clamp(0.0, 1.0).round(10)
+              end
+
+              def escalate!(amount: 0.1)
+                @threat_level = (@threat_level + amount).clamp(0.0, 1.0).round(10)
+              end
+
+              def to_h
+                {
+                  id:             @id,
+                  source:         @source,
+                  tactic:         @tactic,
+                  content_hash:   @content_hash,
+                  threat_level:   @threat_level,
+                  threat_label:   threat_label,
+                  quarantined:    @quarantined,
+                  exposure_count: @exposure_count,
+                  created_at:     @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/immunology/runners/cognitive_immunology.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Immunology
+          module Runners
+            module CognitiveImmunology
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def detect_threat(source:, tactic:, content_hash:, threat_level: 0.5, **)
+                threat = engine.detect_threat(source: source, tactic: tactic, content_hash: content_hash, threat_level: threat_level)
+                { success: true, threat: threat.to_h }
+              end
+
+              def quarantine_threat(threat_id:, **)
+                result = engine.quarantine_threat(threat_id: threat_id)
+                result.merge(success: result.fetch(:success, false))
+              end
+
+              def release_threat(threat_id:, **)
+                result = engine.release_threat(threat_id: threat_id)
+                result.merge(success: result.fetch(:success, false))
+              end
+
+              def inoculate(threat_id:, **)
+                engine.inoculate(threat_id: threat_id)
+              end
+
+              def create_antibody(tactic:, pattern:, strength: 0.5, **)
+                ab = engine.create_antibody(tactic: tactic, pattern: pattern, strength: strength)
+                { success: true, antibody: ab.to_h }
+              end
+
+              def scan_for_tactic(tactic:, **)
+                threats = engine.scan_for_tactic(tactic: tactic)
+                { success: true, tactic: tactic, threats: threats.map(&:to_h), count: threats.size }
+              end
+
+              def trigger_inflammatory_response(**)
+                result = engine.trigger_inflammatory_response
+                { success: true }.merge(result)
+              end
+
+              def resolve_inflammation(**)
+                result = engine.resolve_inflammation
+                { success: true }.merge(result)
+              end
+
+              def overall_immunity(**)
+                score = engine.overall_immunity
+                { success: true, score: score, label: engine.immunity_label }
+              end
+
+              def vulnerability_report(**)
+                report = engine.vulnerability_report
+                { success: true }.merge(report)
+              end
+
+              def threat_history(limit: 10, **)
+                threats = engine.threat_history(limit: limit)
+                { success: true, threats: threats, count: threats.size }
+              end
+
+              def decay_all(**)
+                result = engine.decay_all
+                { success: true }.merge(result)
+              end
+
+              def prune_ineffective(**)
+                result = engine.prune_ineffective
+                { success: true }.merge(result)
+              end
+
+              def immune_status(**)
+                { success: true }.merge(engine.to_h)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::ImmuneEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Immunology
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/immunology/version'
+require 'legion/extensions/agentic/defense/immunology/helpers/constants'
+require 'legion/extensions/agentic/defense/immunology/helpers/threat'
+require 'legion/extensions/agentic/defense/immunology/helpers/antibody'
+require 'legion/extensions/agentic/defense/immunology/helpers/immune_engine'
+require 'legion/extensions/agentic/defense/immunology/runners/cognitive_immunology'
+require 'legion/extensions/agentic/defense/immunology/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Immunology
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/phantom/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/phantom/helpers/constants'
+require 'legion/extensions/agentic/defense/phantom/helpers/phantom_signal'
+require 'legion/extensions/agentic/defense/phantom/helpers/phantom_limb'
+require 'legion/extensions/agentic/defense/phantom/helpers/phantom_engine'
+require 'legion/extensions/agentic/defense/phantom/runners/cognitive_phantom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Phantom
+          class Client
+            include Runners::CognitivePhantom
+
+            def initialize(**)
+              @phantom_engine = Helpers::PhantomEngine.new
+            end
+
+            private
+
+            attr_reader :phantom_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/phantom/helpers/constants.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Phantom
+          module Helpers
+            module Constants
+              MAX_PHANTOMS = 100
+              INITIAL_INTENSITY = 0.8
+              INTENSITY_DECAY   = 0.05
+              MIN_INTENSITY     = 0.01
+
+              PHANTOM_STATES = %i[acute adapting residual resolved].freeze
+              TRIGGER_TYPES  = %i[stimulus_match contextual_association temporal_pattern habitual].freeze
+
+              STATE_THRESHOLDS = {
+                acute:    0.6,
+                adapting: 0.3,
+                residual: MIN_INTENSITY
+              }.freeze
+
+              PHANTOM_LABELS = {
+                acute:    'Active phantom — strong ghost signals firing',
+                adapting: 'Adapting — agent learning to cope with absence',
+                residual: 'Residual — faint ghost signals, near resolution',
+                resolved: 'Resolved — phantom fully integrated and silent'
+              }.freeze
+
+              module_function
+
+              def label_for(state)
+                PHANTOM_LABELS.fetch(state, 'Unknown state')
+              end
+
+              def state_for(intensity)
+                if intensity >= STATE_THRESHOLDS[:acute]
+                  :acute
+                elsif intensity >= STATE_THRESHOLDS[:adapting]
+                  :adapting
+                elsif intensity > MIN_INTENSITY
+                  :residual
+                else
+                  :resolved
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/phantom/helpers/phantom_engine.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Phantom
+          module Helpers
+            class PhantomEngine
+              def initialize
+                @phantoms = {}
+              end
+
+              def register_removal(capability_name:, capability_domain: :general)
+                if @phantoms.size >= Constants::MAX_PHANTOMS
+                  Legion::Logging.warn "[cognitive_phantom] MAX_PHANTOMS (#{Constants::MAX_PHANTOMS}) reached, skipping #{capability_name}"
+                  return nil
+                end
+
+                limb = PhantomLimb.new(capability_name: capability_name, capability_domain: capability_domain)
+                @phantoms[limb.id] = limb
+                Legion::Logging.info "[cognitive_phantom] registered phantom: capability=#{capability_name} domain=#{capability_domain} id=#{limb.id[0..7]}"
+                limb
+              end
+
+              def process_stimulus(stimulus:, domain: :general)
+                fired = []
+                @phantoms.each_value do |limb|
+                  next if limb.resolved?
+                  next unless domain_match?(limb, domain)
+
+                  signal = limb.trigger!(stimulus)
+                  next unless signal
+
+                  fired << signal
+                  intensity_str = limb.intensity.round(3).to_s
+                  Legion::Logging.debug "[cognitive_phantom] phantom fired: cap=#{limb.capability_name} trigger=#{signal.trigger_type} i=#{intensity_str}"
+                end
+                fired
+              end
+
+              def decay_all!
+                @phantoms.each_value(&:decay!)
+                resolve_check!
+              end
+
+              def acknowledge(phantom_id:)
+                limb = @phantoms[phantom_id]
+                return { acknowledged: false, reason: :not_found } unless limb
+
+                limb.adapt!
+                Legion::Logging.info "[cognitive_phantom] acknowledged phantom id=#{phantom_id[0..7]} intensity=#{limb.intensity.round(3)} state=#{limb.state}"
+                { acknowledged: true, phantom_id: phantom_id, state: limb.state, intensity: limb.intensity }
+              end
+
+              def all_phantoms
+                @phantoms.values
+              end
+
+              def active_phantoms
+                @phantoms.values.reject(&:resolved?)
+              end
+
+              def phantom_activity_report
+                all = @phantoms.values
+                by_state = Constants::PHANTOM_STATES.to_h { |s| [s, all.count { |p| p.state == s }] }
+                {
+                  total:             all.size,
+                  active:            active_phantoms.size,
+                  by_state:          by_state,
+                  total_activations: all.sum(&:activation_count)
+                }
+              end
+
+              def most_persistent(limit: 5)
+                active_phantoms.sort_by(&:activation_count).last(limit).reverse
+              end
+
+              def recently_triggered(limit: 5)
+                active_phantoms
+                  .select(&:last_triggered)
+                  .sort_by(&:last_triggered)
+                  .last(limit)
+                  .reverse
+              end
+
+              def resolve_check!
+                newly_resolved = @phantoms.values.select(&:resolved?)
+                newly_resolved.each do |limb|
+                  Legion::Logging.info "[cognitive_phantom] resolved: capability=#{limb.capability_name} activations=#{limb.activation_count}"
+                end
+                newly_resolved.size
+              end
+
+              private
+
+              def domain_match?(limb, domain)
+                domain == :any || limb.capability_domain == domain || limb.capability_domain == :general
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end