lex-agentic-defense 0.1.0

data/lib/legion/extensions/agentic/defense/bias/helpers/bias_detector.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Bias
+          module Helpers
+            class BiasDetector
+              include Constants
+
+              def initialize
+                @susceptibility = Constants::BIAS_TYPES.to_h { |b| [b, Constants::DEFAULT_SUSCEPTIBILITY] }
+              end
+
+              def detect_anchoring(current_value:, anchor_value:, domain: nil) # rubocop:disable Lint/UnusedMethodArgument
+                return 0.0 if anchor_value.nil? || anchor_value.zero?
+
+                distance = (current_value - anchor_value).abs.to_f / anchor_value.abs
+                pull      = 1.0 - distance.clamp(0.0, 1.0)
+                magnitude = pull * susceptibility_for(:anchoring)
+                update_susceptibility(:anchoring, detected: magnitude >= Constants::DETECTION_THRESHOLD)
+                magnitude.clamp(0.0, 1.0)
+              end
+
+              def detect_confirmation(evidence_direction:, hypothesis_direction:, domain: nil) # rubocop:disable Lint/UnusedMethodArgument
+                magnitude = if evidence_direction == hypothesis_direction
+                              Constants::CONFIRMATION_WEIGHT * susceptibility_for(:confirmation)
+                            else
+                              (1.0 - Constants::CONFIRMATION_WEIGHT) * susceptibility_for(:confirmation)
+                            end
+                update_susceptibility(:confirmation, detected: magnitude >= Constants::DETECTION_THRESHOLD)
+                magnitude.clamp(0.0, 1.0)
+              end
+
+              def detect_availability(recent_events:, domain: nil) # rubocop:disable Lint/UnusedMethodArgument
+                window    = Constants::AVAILABILITY_RECENCY_WINDOW
+                density   = [recent_events.size, window].min.to_f / window
+                magnitude = density * susceptibility_for(:availability)
+                update_susceptibility(:availability, detected: magnitude >= Constants::DETECTION_THRESHOLD)
+                magnitude.clamp(0.0, 1.0)
+              end
+
+              def detect_recency(data_points:, domain: nil) # rubocop:disable Lint/UnusedMethodArgument
+                return 0.0 if data_points.size < 2
+
+                total = data_points.size
+                half  = total / 2
+                recent_half  = data_points.last(half)
+                earlier_half = data_points.first(half)
+
+                recent_mean  = mean(recent_half)
+                earlier_mean = mean(earlier_half)
+
+                range = (data_points.max - data_points.min).to_f
+                return 0.0 if range.zero?
+
+                skew      = (recent_mean - earlier_mean).abs / range
+                magnitude = skew * susceptibility_for(:recency)
+                update_susceptibility(:recency, detected: magnitude >= Constants::DETECTION_THRESHOLD)
+                magnitude.clamp(0.0, 1.0)
+              end
+
+              def detect_sunk_cost(invested:, expected_return:, domain: nil) # rubocop:disable Lint/UnusedMethodArgument
+                return 0.0 if invested <= 0
+
+                ratio     = invested.to_f / (invested + expected_return.abs + 1.0)
+                magnitude = ratio * susceptibility_for(:sunk_cost)
+                update_susceptibility(:sunk_cost, detected: magnitude >= Constants::DETECTION_THRESHOLD)
+                magnitude.clamp(0.0, 1.0)
+              end
+
+              def susceptibility_for(bias_type)
+                @susceptibility.fetch(bias_type, Constants::DEFAULT_SUSCEPTIBILITY)
+              end
+
+              def update_susceptibility(bias_type, detected:)
+                return unless @susceptibility.key?(bias_type)
+
+                alpha   = Constants::SUSCEPTIBILITY_ALPHA
+                signal  = detected ? 1.0 : 0.0
+                current = @susceptibility[bias_type]
+                @susceptibility[bias_type] = ((alpha * signal) + ((1.0 - alpha) * current)).clamp(0.0, 1.0)
+              end
+
+              def correction_for(magnitude)
+                (magnitude * Constants::CORRECTION_FACTOR).clamp(0.0, 1.0)
+              end
+
+              def to_h
+                { susceptibility: @susceptibility.dup }
+              end
+
+              private
+
+              def mean(values)
+                return 0.0 if values.empty?
+
+                values.sum.to_f / values.size
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/bias/helpers/bias_event.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Bias
+          module Helpers
+            class BiasEvent
+              attr_reader :id, :bias_type, :domain, :magnitude, :corrected,
+                          :correction_applied, :context, :timestamp
+
+              def initialize(bias_type:, domain:, magnitude:, **opts)
+                @id                 = SecureRandom.uuid
+                @bias_type          = bias_type
+                @domain             = domain
+                @magnitude          = magnitude
+                @corrected          = opts.fetch(:corrected, false)
+                @correction_applied = opts.fetch(:correction_applied, 0.0)
+                @context            = opts.fetch(:context, {})
+                @timestamp          = Time.now.utc
+              end
+
+              def to_h
+                {
+                  id:                 @id,
+                  bias_type:          @bias_type,
+                  domain:             @domain,
+                  magnitude:          @magnitude,
+                  corrected:          @corrected,
+                  correction_applied: @correction_applied,
+                  context:            @context,
+                  timestamp:          @timestamp
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/bias/helpers/bias_store.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Bias
+          module Helpers
+            class BiasStore
+              def initialize
+                @events  = []
+                @anchors = {} # domain -> array of { value:, influence:, recorded_at: }
+              end
+
+              def record(event)
+                @events << event
+                @events.shift while @events.size > Constants::MAX_BIAS_EVENTS
+                event
+              end
+
+              def recent(count = 10)
+                @events.last(count).map(&:to_h)
+              end
+
+              def by_type(bias_type)
+                @events.select { |e| e.bias_type == bias_type }.map(&:to_h)
+              end
+
+              def by_domain(domain)
+                @events.select { |e| e.domain == domain }.map(&:to_h)
+              end
+
+              def register_anchor(domain, value:, influence: 1.0)
+                @anchors[domain] ||= []
+                @anchors[domain] << { value: value, influence: influence, recorded_at: Time.now.utc }
+                @anchors[domain].shift while @anchors[domain].size > Constants::MAX_ANCHORS
+              end
+
+              def anchors_for(domain)
+                @anchors.fetch(domain, [])
+              end
+
+              def decay_anchors
+                @anchors.each_value do |anchor_list|
+                  anchor_list.each { |a| a[:influence] = (a[:influence] - Constants::ANCHOR_DECAY).clamp(0.0, 1.0) }
+                  anchor_list.reject! { |a| a[:influence] <= 0.0 }
+                end
+              end
+
+              def stats
+                return { total: 0, by_type: {}, by_domain: {} } if @events.empty?
+
+                by_type = Constants::BIAS_TYPES.to_h do |bt|
+                  events = @events.select { |e| e.bias_type == bt }
+                  avg_mag = events.empty? ? 0.0 : events.sum(&:magnitude) / events.size
+                  [bt, { count: events.size, avg_magnitude: avg_mag.round(4) }]
+                end
+
+                domains = @events.map(&:domain).uniq
+                by_domain = domains.to_h do |d|
+                  events = @events.select { |e| e.domain == d }
+                  [d, { count: events.size }]
+                end
+
+                {
+                  total:     @events.size,
+                  by_type:   by_type,
+                  by_domain: by_domain
+                }
+              end
+
+              def to_h
+                {
+                  total_events:   @events.size,
+                  anchor_domains: @anchors.keys
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Bias
+          module Helpers
+            module Constants
+              BIAS_TYPES = %i[anchoring confirmation availability recency sunk_cost].freeze
+
+              DETECTION_THRESHOLD          = 0.3   # above this = bias likely influencing decision
+              CORRECTION_FACTOR            = 0.5   # how much to correct when bias detected
+              DEFAULT_SUSCEPTIBILITY       = 0.5   # starting susceptibility per bias
+              SUSCEPTIBILITY_ALPHA         = 0.1   # EMA alpha for updating susceptibility
+              DECAY_RATE                   = 0.02  # how fast bias activation decays per tick
+              MAX_BIAS_EVENTS              = 200   # max tracked bias events
+              MAX_ANCHORS                  = 50    # max tracked anchor values
+              ANCHOR_DECAY                 = 0.05  # how fast anchor influence decays
+              CONFIRMATION_WEIGHT          = 0.7   # weight of confirming vs disconfirming evidence
+              AVAILABILITY_RECENCY_WINDOW  = 10    # recent events window for availability heuristic
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Bias
+          module Runners
+            module Bias
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def check_for_bias(domain:, decision_context: {}, **)
+                Legion::Logging.debug "[bias] check_for_bias domain=#{domain}"
+                detected = collect_bias_detections(domain, decision_context)
+                active   = detected.select { |b| b[:magnitude] >= Helpers::Constants::DETECTION_THRESHOLD }
+                Legion::Logging.debug "[bias] check_for_bias domain=#{domain} detected=#{active.size}"
+                { success: true, domain: domain, detected: active, all: detected }
+              end
+
+              def record_anchor(domain:, value:, **)
+                bias_store.register_anchor(domain, value: value)
+                Legion::Logging.debug "[bias] anchor recorded domain=#{domain} value=#{value}"
+                { success: true, domain: domain, value: value }
+              end
+
+              def update_bias(**)
+                bias_store.decay_anchors
+                Legion::Logging.debug '[bias] update_bias: anchors decayed'
+                { success: true }
+              end
+
+              def bias_report(domain: nil, **)
+                events = domain ? bias_store.by_domain(domain) : bias_store.recent(50)
+                Legion::Logging.debug "[bias] bias_report domain=#{domain.inspect} events=#{events.size}"
+                { success: true, domain: domain, events: events, count: events.size }
+              end
+
+              def susceptibility_profile(**)
+                profile = bias_detector.to_h
+                Legion::Logging.debug '[bias] susceptibility_profile'
+                { success: true, **profile }
+              end
+
+              def bias_stats(**)
+                stats = bias_store.stats
+                Legion::Logging.debug "[bias] bias_stats total=#{stats[:total]}"
+                { success: true, **stats }
+              end
+
+              private
+
+              def bias_detector
+                @bias_detector ||= Helpers::BiasDetector.new
+              end
+
+              def bias_store
+                @bias_store ||= Helpers::BiasStore.new
+              end
+
+              def collect_bias_detections(domain, ctx)
+                results = []
+                results.concat(detect_anchoring_bias(domain, ctx))
+                results.concat(detect_confirmation_bias(domain, ctx))
+                results.concat(detect_availability_bias(domain, ctx))
+                results.concat(detect_recency_bias(domain, ctx))
+                results.concat(detect_sunk_cost_bias(domain, ctx))
+                results
+              end
+
+              def detect_anchoring_bias(domain, ctx)
+                anchors = bias_store.anchors_for(domain)
+                return [] unless anchors.any? && ctx[:current_value]
+
+                anchor_value = anchors.max_by { |a| a[:influence] }&.dig(:value)
+                return [] unless anchor_value
+
+                mag = bias_detector.detect_anchoring(
+                  current_value: ctx[:current_value],
+                  anchor_value:  anchor_value,
+                  domain:        domain
+                )
+                [build_bias_result(:anchoring, domain, mag, ctx)]
+              end
+
+              def detect_confirmation_bias(domain, ctx)
+                return [] unless ctx[:evidence_direction] && ctx[:hypothesis_direction]
+
+                mag = bias_detector.detect_confirmation(
+                  evidence_direction:   ctx[:evidence_direction],
+                  hypothesis_direction: ctx[:hypothesis_direction],
+                  domain:               domain
+                )
+                [build_bias_result(:confirmation, domain, mag, ctx)]
+              end
+
+              def detect_availability_bias(domain, ctx)
+                return [] unless ctx[:recent_events]
+
+                mag = bias_detector.detect_availability(recent_events: ctx[:recent_events], domain: domain)
+                [build_bias_result(:availability, domain, mag, ctx)]
+              end
+
+              def detect_recency_bias(domain, ctx)
+                return [] unless ctx[:data_points]
+
+                mag = bias_detector.detect_recency(data_points: ctx[:data_points], domain: domain)
+                [build_bias_result(:recency, domain, mag, ctx)]
+              end
+
+              def detect_sunk_cost_bias(domain, ctx)
+                return [] unless ctx[:invested] && !ctx[:expected_return].nil?
+
+                mag = bias_detector.detect_sunk_cost(
+                  invested:        ctx[:invested],
+                  expected_return: ctx[:expected_return],
+                  domain:          domain
+                )
+                [build_bias_result(:sunk_cost, domain, mag, ctx)]
+              end
+
+              def build_bias_result(bias_type, domain, magnitude, context)
+                correction = bias_detector.correction_for(magnitude)
+                corrected  = magnitude >= Helpers::Constants::DETECTION_THRESHOLD
+
+                if corrected
+                  event = Helpers::BiasEvent.new(
+                    bias_type:          bias_type,
+                    domain:             domain,
+                    magnitude:          magnitude,
+                    corrected:          corrected,
+                    correction_applied: correction,
+                    context:            context
+                  )
+                  bias_store.record(event)
+                end
+
+                {
+                  bias_type:          bias_type,
+                  magnitude:          magnitude,
+                  corrected:          corrected,
+                  correction_applied: correction
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/bias/version'
+require 'legion/extensions/agentic/defense/bias/helpers/constants'
+require 'legion/extensions/agentic/defense/bias/helpers/bias_event'
+require 'legion/extensions/agentic/defense/bias/helpers/bias_detector'
+require 'legion/extensions/agentic/defense/bias/helpers/bias_store'
+require 'legion/extensions/agentic/defense/bias/runners/bias'
+require 'legion/extensions/agentic/defense/bias/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Bias
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/confabulation/actors/decay.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Confabulation
+          module Actor
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Defense::Confabulation::Runners::Confabulation
+              end
+
+              def runner_function
+                'confabulation_report'
+              end
+
+              def time
+                300
+              end
+
+              def run_now?
+                false
+              end
+
+              def use_runner?
+                false
+              end
+
+              def check_subtask?
+                false
+              end
+
+              def generate_task?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/confabulation/helpers/constants'
+require 'legion/extensions/agentic/defense/confabulation/helpers/claim'
+require 'legion/extensions/agentic/defense/confabulation/helpers/confabulation_engine'
+require 'legion/extensions/agentic/defense/confabulation/runners/confabulation'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Confabulation
+          class Client
+            include Runners::Confabulation
+
+            def initialize(**)
+              @confabulation_engine = Helpers::ConfabulationEngine.new
+            end
+
+            private
+
+            attr_reader :confabulation_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/confabulation/helpers/claim.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Confabulation
+          module Helpers
+            class Claim
+              attr_reader :id, :content, :claim_type, :confidence, :evidence_strength,
+                          :verified, :confabulated, :created_at
+
+              def initialize(content:, claim_type:, confidence:, evidence_strength:)
+                @id               = SecureRandom.uuid
+                @content          = content
+                @claim_type       = claim_type
+                @confidence       = confidence.clamp(0.0, 1.0)
+                @evidence_strength = evidence_strength.clamp(0.0, 1.0)
+                @verified         = false
+                @confabulated     = false
+                @created_at       = Time.now.utc
+              end
+
+              def confabulation_risk
+                (confidence - evidence_strength).clamp(0.0, 1.0)
+              end
+
+              def verify!
+                @verified = true
+                self
+              end
+
+              def mark_confabulated!
+                @confabulated = true
+                self
+              end
+
+              def risk_label
+                Constants::RISK_LABELS.each do |range, label|
+                  return label if range.cover?(confabulation_risk)
+                end
+                :extreme
+              end
+
+              def to_h
+                {
+                  id:                 id,
+                  content:            content,
+                  claim_type:         claim_type,
+                  confidence:         confidence.round(10),
+                  evidence_strength:  evidence_strength.round(10),
+                  confabulation_risk: confabulation_risk.round(10),
+                  risk_label:         risk_label,
+                  verified:           verified,
+                  confabulated:       confabulated,
+                  created_at:         created_at.iso8601
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end