lex-agentic-defense 0.1.0

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Confabulation
+          module Helpers
+            class ConfabulationEngine
+              attr_reader :claims
+
+              def initialize
+                @claims = {}
+              end
+
+              def register_claim(content:, claim_type: :factual, confidence: 0.5, evidence_strength: 0.5)
+                claim_type = claim_type.to_sym
+                claim_type = :factual unless Constants::CLAIM_TYPES.include?(claim_type)
+
+                claim = Claim.new(
+                  content:           content,
+                  claim_type:        claim_type,
+                  confidence:        confidence,
+                  evidence_strength: evidence_strength
+                )
+                prune_if_needed
+                @claims[claim.id] = claim
+                claim
+              end
+
+              def verify_claim(claim_id:)
+                claim = @claims[claim_id]
+                return { found: false, claim_id: claim_id } unless claim
+
+                claim.verify!
+                { found: true, claim_id: claim_id, verified: true }
+              end
+
+              def flag_confabulation(claim_id:)
+                claim = @claims[claim_id]
+                return { found: false, claim_id: claim_id } unless claim
+
+                claim.mark_confabulated!
+                { found: true, claim_id: claim_id, confabulated: true }
+              end
+
+              def high_risk_claims
+                @claims.values.select { |c| c.confabulation_risk >= Constants::CONFABULATION_THRESHOLD }
+              end
+
+              def verified_claims
+                @claims.values.select(&:verified)
+              end
+
+              def confabulation_rate
+                total = @claims.size
+                return 0.0 if total.zero?
+
+                flagged = @claims.values.count(&:confabulated)
+                (flagged.to_f / total).round(10)
+              end
+
+              def average_calibration
+                return 0.0 if @claims.empty?
+
+                total_gap = @claims.values.sum { |c| (c.confidence - c.evidence_strength).abs }
+                gap = total_gap / @claims.size.to_f
+                (1.0 - gap).clamp(0.0, 1.0).round(10)
+              end
+
+              def confabulation_report
+                total          = @claims.size
+                high_risk      = high_risk_claims.size
+                verified       = verified_claims.size
+                confabulated   = @claims.values.count(&:confabulated)
+                overall_risk   = total.zero? ? 0.0 : high_risk.to_f / total
+                risk_label     = risk_label_for(overall_risk)
+
+                {
+                  total_claims:        total,
+                  high_risk_claims:    high_risk,
+                  verified_claims:     verified,
+                  confabulated_claims: confabulated,
+                  confabulation_rate:  confabulation_rate,
+                  average_calibration: average_calibration,
+                  overall_risk:        overall_risk.round(10),
+                  risk_label:          risk_label
+                }
+              end
+
+              def prune_if_needed
+                return unless @claims.size >= Constants::MAX_CLAIMS
+
+                oldest_key = @claims.min_by { |_, c| c.created_at }&.first
+                @claims.delete(oldest_key)
+              end
+
+              def to_h
+                {
+                  claim_count:         @claims.size,
+                  confabulation_rate:  confabulation_rate,
+                  average_calibration: average_calibration
+                }
+              end
+
+              private
+
+              def risk_label_for(value)
+                Constants::RISK_LABELS.each do |range, label|
+                  return label if range.cover?(value)
+                end
+                :extreme
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Confabulation
+          module Helpers
+            module Constants
+              MAX_CLAIMS = 500
+              CONFABULATION_THRESHOLD = 0.6
+              EVIDENCE_DECAY = 0.02
+
+              RISK_LABELS = {
+                0.0..0.2 => :minimal,
+                0.2..0.4 => :low,
+                0.4..0.6 => :moderate,
+                0.6..0.8 => :high,
+                0.8..1.0 => :extreme
+              }.freeze
+
+              CLAIM_TYPES = %i[factual causal explanatory predictive autobiographical].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Confabulation
+          module Runners
+            module Confabulation
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def register_claim(content:, claim_type: :factual, confidence: 0.5, evidence_strength: 0.5, **)
+                claim = confabulation_engine.register_claim(
+                  content:           content,
+                  claim_type:        claim_type,
+                  confidence:        confidence,
+                  evidence_strength: evidence_strength
+                )
+                Legion::Logging.debug "[confabulation] register: id=#{claim.id} type=#{claim.claim_type} " \
+                                      "risk=#{claim.confabulation_risk.round(2)} label=#{claim.risk_label}"
+                claim.to_h
+              end
+
+              def verify_claim(claim_id:, **)
+                result = confabulation_engine.verify_claim(claim_id: claim_id)
+                if result[:found]
+                  Legion::Logging.info "[confabulation] verified: claim_id=#{claim_id}"
+                else
+                  Legion::Logging.debug "[confabulation] verify: claim_id=#{claim_id} not found"
+                end
+                result
+              end
+
+              def flag_confabulation(claim_id:, **)
+                result = confabulation_engine.flag_confabulation(claim_id: claim_id)
+                if result[:found]
+                  Legion::Logging.warn "[confabulation] flagged: claim_id=#{claim_id} marked as confabulated"
+                else
+                  Legion::Logging.debug "[confabulation] flag: claim_id=#{claim_id} not found"
+                end
+                result
+              end
+
+              def confabulation_report(**)
+                report = confabulation_engine.confabulation_report
+                Legion::Logging.debug "[confabulation] report: total=#{report[:total_claims]} " \
+                                      "high_risk=#{report[:high_risk_claims]} " \
+                                      "rate=#{report[:confabulation_rate].round(2)} label=#{report[:risk_label]}"
+                report
+              end
+
+              def high_risk_claims(**)
+                claims = confabulation_engine.high_risk_claims
+                Legion::Logging.debug "[confabulation] high_risk_claims: count=#{claims.size}"
+                { claims: claims.map(&:to_h), count: claims.size }
+              end
+
+              def confabulation_status(**)
+                { engine: confabulation_engine.to_h }
+              end
+
+              private
+
+              def confabulation_engine
+                @confabulation_engine ||= Helpers::ConfabulationEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/confabulation/version'
+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'
+require 'legion/extensions/agentic/defense/confabulation/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Confabulation
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/dissonance/helpers/constants'
+require 'legion/extensions/agentic/defense/dissonance/helpers/belief'
+require 'legion/extensions/agentic/defense/dissonance/helpers/dissonance_event'
+require 'legion/extensions/agentic/defense/dissonance/helpers/dissonance_model'
+require 'legion/extensions/agentic/defense/dissonance/runners/dissonance'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Dissonance
+          class Client
+            include Runners::Dissonance
+
+            attr_reader :model
+
+            def initialize(model: nil, **)
+              @model            = model || Helpers::DissonanceModel.new
+              @dissonance_model = @model
+            end
+
+            private
+
+            attr_accessor :dissonance_model
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/dissonance/helpers/belief.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Dissonance
+          module Helpers
+            class Belief
+              attr_reader :id, :domain, :content, :confidence, :importance, :created_at
+
+              def initialize(domain:, content:, confidence: 0.7, importance: :moderate)
+                @id         = SecureRandom.uuid
+                @domain     = domain
+                @content    = content
+                @confidence = confidence.clamp(0.0, 1.0)
+                @importance = importance
+                @created_at = Time.now.utc
+              end
+
+              def contradicts?(other)
+                return false if id == other.id
+                return false unless domain == other.domain
+
+                content.strip.downcase != other.content.strip.downcase
+              end
+
+              def to_h
+                {
+                  id:         id,
+                  domain:     domain,
+                  content:    content,
+                  confidence: confidence,
+                  importance: importance,
+                  created_at: created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Dissonance
+          module Helpers
+            module Constants
+              DISSONANCE_THRESHOLD  = 0.4
+              MAX_BELIEFS           = 200
+              MAX_DISSONANCE_EVENTS = 100
+              DECAY_RATE            = 0.03
+              RESOLUTION_RELIEF     = 0.3
+              RATIONALIZATION_FACTOR = 0.5
+              IMPORTANCE_WEIGHTS    = { core: 1.0, significant: 0.7, moderate: 0.5, peripheral: 0.25 }.freeze
+              RESOLUTION_STRATEGIES = %i[belief_revision rationalization avoidance].freeze
+              STRESS_CEILING        = 1.0
+              STRESS_FLOOR          = 0.0
+              CONTRADICTION_TYPES   = %i[direct inverse conditional temporal].freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/dissonance/helpers/dissonance_event.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Dissonance
+          module Helpers
+            class DissonanceEvent
+              attr_reader :id, :belief_a_id, :belief_b_id, :domain, :magnitude,
+                          :contradiction_type, :resolved, :resolution_strategy, :timestamp
+
+              def initialize(belief_a_id:, belief_b_id:, domain:, magnitude:, contradiction_type: :direct)
+                @id                  = SecureRandom.uuid
+                @belief_a_id         = belief_a_id
+                @belief_b_id         = belief_b_id
+                @domain              = domain
+                @magnitude           = magnitude.clamp(0.0, 1.0)
+                @contradiction_type  = contradiction_type
+                @resolved            = false
+                @resolution_strategy = nil
+                @timestamp           = Time.now.utc
+              end
+
+              def resolve!(strategy)
+                @resolved            = true
+                @resolution_strategy = strategy
+                self
+              end
+
+              def to_h
+                {
+                  id:                  id,
+                  belief_a_id:         belief_a_id,
+                  belief_b_id:         belief_b_id,
+                  domain:              domain,
+                  magnitude:           magnitude,
+                  contradiction_type:  contradiction_type,
+                  resolved:            resolved,
+                  resolution_strategy: resolution_strategy,
+                  timestamp:           timestamp
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/dissonance/helpers/dissonance_model.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Dissonance
+          module Helpers
+            class DissonanceModel
+              include Constants
+
+              attr_reader :beliefs, :events, :stress
+
+              def initialize
+                @beliefs = {}
+                @events  = {}
+                @stress  = STRESS_FLOOR
+              end
+
+              def add_belief(domain:, content:, confidence: 0.7, importance: :moderate)
+                prune_beliefs if @beliefs.size >= MAX_BELIEFS
+
+                belief = Belief.new(domain: domain, content: content,
+                                    confidence: confidence, importance: importance)
+                @beliefs[belief.id] = belief
+
+                new_events = detect_contradictions_for(belief)
+                new_events.each { |ev| @events[ev.id] = ev }
+
+                { belief: belief, new_dissonance_events: new_events }
+              end
+
+              def detect_contradictions
+                new_events = []
+                belief_list = @beliefs.values
+
+                belief_list.each_with_index do |bel_a, idx|
+                  belief_list[(idx + 1)..].each do |bel_b|
+                    next unless bel_a.contradicts?(bel_b)
+                    next if contradiction_tracked?(bel_a.id, bel_b.id)
+
+                    ev = build_event(bel_a, bel_b)
+                    @events[ev.id] = ev
+                    new_events << ev
+                  end
+                end
+
+                new_events
+              end
+
+              def resolve(event_id, strategy:)
+                event = @events[event_id]
+                return nil unless event
+                return nil if event.resolved
+                return nil unless RESOLUTION_STRATEGIES.include?(strategy)
+
+                event.resolve!(strategy)
+                relief = compute_relief(strategy)
+                @stress = (@stress - relief).clamp(STRESS_FLOOR, STRESS_CEILING)
+                event
+              end
+
+              def stress_level
+                @stress
+              end
+
+              def domain_stress(domain)
+                unresolved = unresolved_events.select { |ev| ev.domain == domain }
+                return STRESS_FLOOR if unresolved.empty?
+
+                raw = unresolved.sum(&:magnitude) / MAX_DISSONANCE_EVENTS.to_f
+                raw.clamp(STRESS_FLOOR, STRESS_CEILING)
+              end
+
+              def unresolved_events
+                @events.values.reject(&:resolved)
+              end
+
+              def decay
+                unresolved = unresolved_events
+                if unresolved.any?
+                  increment = DECAY_RATE * unresolved.size
+                  @stress   = (@stress + increment).clamp(STRESS_FLOOR, STRESS_CEILING)
+                else
+                  @stress = (@stress - DECAY_RATE).clamp(STRESS_FLOOR, STRESS_CEILING)
+                end
+                @stress
+              end
+
+              def to_h
+                {
+                  beliefs:          @beliefs.values.map(&:to_h),
+                  events:           @events.values.map(&:to_h),
+                  stress:           @stress,
+                  unresolved_count: unresolved_events.size,
+                  total_beliefs:    @beliefs.size,
+                  total_events:     @events.size
+                }
+              end
+
+              private
+
+              def detect_contradictions_for(new_belief)
+                new_events = []
+
+                @beliefs.each_value do |existing|
+                  next if existing.id == new_belief.id
+                  next unless new_belief.contradicts?(existing)
+                  next if contradiction_tracked?(new_belief.id, existing.id)
+
+                  ev = build_event(new_belief, existing)
+                  new_events << ev
+                end
+
+                new_events
+              end
+
+              def build_event(bel_a, bel_b)
+                magnitude = compute_magnitude(bel_a, bel_b)
+                DissonanceEvent.new(
+                  belief_a_id:        bel_a.id,
+                  belief_b_id:        bel_b.id,
+                  domain:             bel_a.domain,
+                  magnitude:          magnitude,
+                  contradiction_type: :direct
+                )
+              end
+
+              def compute_magnitude(bel_a, bel_b)
+                weight_a       = IMPORTANCE_WEIGHTS.fetch(bel_a.importance, 0.5)
+                weight_b       = IMPORTANCE_WEIGHTS.fetch(bel_b.importance, 0.5)
+                avg_weight     = (weight_a + weight_b) / 2.0
+                avg_confidence = (bel_a.confidence + bel_b.confidence) / 2.0
+                (avg_weight * avg_confidence).clamp(0.0, 1.0)
+              end
+
+              def compute_relief(strategy)
+                base = RESOLUTION_RELIEF
+                strategy == :rationalization ? base * RATIONALIZATION_FACTOR : base
+              end
+
+              def contradiction_tracked?(id_a, id_b)
+                @events.values.any? do |ev|
+                  (ev.belief_a_id == id_a && ev.belief_b_id == id_b) ||
+                    (ev.belief_a_id == id_b && ev.belief_b_id == id_a)
+                end
+              end
+
+              def prune_beliefs
+                oldest = @beliefs.values.min_by(&:created_at)
+                @beliefs.delete(oldest.id) if oldest
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end