lex-agentic-defense 0.1.0

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Dissonance
+          module Runners
+            module Dissonance
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def add_belief(domain:, content:, confidence: 0.7, importance: :moderate, **)
+                unless Helpers::Constants::IMPORTANCE_WEIGHTS.key?(importance)
+                  return { success: false, error: :invalid_importance,
+                           valid: Helpers::Constants::IMPORTANCE_WEIGHTS.keys }
+                end
+
+                result  = dissonance_model.add_belief(domain: domain, content: content,
+                                                      confidence: confidence, importance: importance)
+                belief  = result[:belief]
+                new_evs = result[:new_dissonance_events]
+
+                Legion::Logging.debug "[dissonance] add_belief: id=#{belief.id[0..7]} domain=#{domain} importance=#{importance} new_events=#{new_evs.size}"
+
+                {
+                  success:               true,
+                  belief_id:             belief.id,
+                  domain:                domain,
+                  new_dissonance_events: new_evs.map(&:to_h),
+                  dissonance_triggered:  new_evs.any? { |ev| ev.magnitude >= Helpers::Constants::DISSONANCE_THRESHOLD }
+                }
+              end
+
+              def update_dissonance(**)
+                dissonance_model.detect_contradictions
+                new_stress = dissonance_model.decay
+                unresolved = dissonance_model.unresolved_events
+
+                Legion::Logging.debug "[dissonance] update: stress=#{new_stress.round(3)} unresolved=#{unresolved.size}"
+
+                {
+                  success:          true,
+                  stress:           new_stress,
+                  unresolved_count: unresolved.size,
+                  above_threshold:  unresolved.any? { |ev| ev.magnitude >= Helpers::Constants::DISSONANCE_THRESHOLD }
+                }
+              end
+
+              def resolve_dissonance(event_id:, strategy: :belief_revision, **)
+                unless Helpers::Constants::RESOLUTION_STRATEGIES.include?(strategy)
+                  return { success: false, error: :invalid_strategy,
+                           valid: Helpers::Constants::RESOLUTION_STRATEGIES }
+                end
+
+                event = dissonance_model.resolve(event_id, strategy: strategy)
+                if event
+                  Legion::Logging.debug "[dissonance] resolved: id=#{event_id[0..7]} strategy=#{strategy}"
+                  { success: true, resolved: true, strategy: strategy, event: event.to_h }
+                else
+                  Legion::Logging.debug "[dissonance] resolve failed: id=#{event_id[0..7]} not_found_or_already_resolved"
+                  { success: false, error: :not_found_or_already_resolved }
+                end
+              end
+
+              def dissonance_status(**)
+                model    = dissonance_model
+                snapshot = model.to_h
+
+                Legion::Logging.debug "[dissonance] status: stress=#{snapshot[:stress].round(3)} " \
+                                      "beliefs=#{snapshot[:total_beliefs]} unresolved=#{snapshot[:unresolved_count]}"
+
+                {
+                  success:          true,
+                  stress:           snapshot[:stress],
+                  total_beliefs:    snapshot[:total_beliefs],
+                  total_events:     snapshot[:total_events],
+                  unresolved_count: snapshot[:unresolved_count]
+                }
+              end
+
+              def domain_dissonance(domain:, **)
+                stress = dissonance_model.domain_stress(domain)
+                unresolved = dissonance_model.unresolved_events.select { |ev| ev.domain == domain }
+
+                Legion::Logging.debug "[dissonance] domain_dissonance: domain=#{domain} stress=#{stress.round(3)} unresolved=#{unresolved.size}"
+
+                {
+                  success:          true,
+                  domain:           domain,
+                  stress:           stress,
+                  unresolved_count: unresolved.size,
+                  events:           unresolved.map(&:to_h)
+                }
+              end
+
+              def beliefs_for(domain:, **)
+                beliefs = dissonance_model.beliefs.values.select { |b| b.domain == domain }
+
+                Legion::Logging.debug "[dissonance] beliefs_for: domain=#{domain} count=#{beliefs.size}"
+
+                {
+                  success: true,
+                  domain:  domain,
+                  count:   beliefs.size,
+                  beliefs: beliefs.map(&:to_h)
+                }
+              end
+
+              def unresolved(**)
+                events = dissonance_model.unresolved_events
+
+                Legion::Logging.debug "[dissonance] unresolved: count=#{events.size}"
+
+                {
+                  success: true,
+                  count:   events.size,
+                  events:  events.map(&:to_h)
+                }
+              end
+
+              def dissonance_stats(**)
+                model    = dissonance_model
+                snapshot = model.to_h
+
+                domains = model.beliefs.values.map(&:domain).uniq
+                domain_stresses = domains.to_h { |d| [d, model.domain_stress(d)] }
+
+                unresolved = model.unresolved_events
+                resolved   = model.events.values.select(&:resolved)
+
+                resolution_breakdown = Helpers::Constants::RESOLUTION_STRATEGIES.to_h do |s|
+                  [s, resolved.count { |ev| ev.resolution_strategy == s }]
+                end
+
+                Legion::Logging.debug "[dissonance] stats: beliefs=#{snapshot[:total_beliefs]} " \
+                                      "events=#{snapshot[:total_events]} stress=#{snapshot[:stress].round(3)}"
+
+                {
+                  success:              true,
+                  stress:               snapshot[:stress],
+                  total_beliefs:        snapshot[:total_beliefs],
+                  total_events:         snapshot[:total_events],
+                  unresolved_count:     unresolved.size,
+                  resolved_count:       resolved.size,
+                  domain_stresses:      domain_stresses,
+                  resolution_breakdown: resolution_breakdown,
+                  above_threshold:      unresolved.any? { |ev| ev.magnitude >= Helpers::Constants::DISSONANCE_THRESHOLD }
+                }
+              end
+
+              private
+
+              def dissonance_model
+                @dissonance_model ||= Helpers::DissonanceModel.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

data/lib/legion/extensions/agentic/defense/epistemic_vigilance/actors/update.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module EpistemicVigilance
+          module Actor
+            class Update < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Defense::EpistemicVigilance::Runners::EpistemicVigilance
+              end
+
+              def runner_function
+                'update_epistemic_vigilance'
+              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/epistemic_vigilance/client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/defense/epistemic_vigilance/helpers/constants'
+require 'legion/extensions/agentic/defense/epistemic_vigilance/helpers/claim'
+require 'legion/extensions/agentic/defense/epistemic_vigilance/helpers/source'
+require 'legion/extensions/agentic/defense/epistemic_vigilance/helpers/vigilance_engine'
+require 'legion/extensions/agentic/defense/epistemic_vigilance/runners/epistemic_vigilance'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module EpistemicVigilance
+          class Client
+            include Runners::EpistemicVigilance
+
+            private
+
+            def engine
+              @engine ||= Helpers::VigilanceEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module EpistemicVigilance
+          module Helpers
+            class Claim
+              include Constants
+
+              attr_reader :id, :content, :source_id, :domain, :created_at,
+                          :evidence_for, :evidence_against, :verdict
+              attr_accessor :confidence
+
+              def initialize(content:, source_id:, domain:, confidence: 0.5)
+                @id               = SecureRandom.uuid
+                @content          = content
+                @source_id        = source_id
+                @domain           = domain
+                @confidence       = confidence.clamp(0.0, 1.0)
+                @verdict          = :suspended
+                @evidence_for     = 0
+                @evidence_against = 0
+                @created_at       = Time.now.utc
+              end
+
+              def support!
+                @evidence_for += 1
+                @confidence   = (@confidence + 0.05).clamp(0.0, 1.0)
+              end
+
+              def challenge!
+                @evidence_against += 1
+                @confidence       = (@confidence - 0.08).clamp(0.0, 1.0)
+              end
+
+              def credibility_ratio
+                @evidence_for / (@evidence_for + @evidence_against + 1.0)
+              end
+
+              def contested?
+                @evidence_against.positive? && credibility_ratio < 0.6
+              end
+
+              def well_supported?
+                @evidence_for >= 3 && credibility_ratio > 0.7
+              end
+
+              def adjudicate!(verdict:)
+                @verdict = verdict
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  content:           @content,
+                  source_id:         @source_id,
+                  domain:            @domain,
+                  confidence:        @confidence,
+                  verdict:           @verdict,
+                  evidence_for:      @evidence_for,
+                  evidence_against:  @evidence_against,
+                  credibility_ratio: credibility_ratio,
+                  contested:         contested?,
+                  well_supported:    well_supported?,
+                  created_at:        @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module EpistemicVigilance
+          module Helpers
+            class Client
+              include Runners::EpistemicVigilance
+
+              private
+
+              def engine
+                @engine ||= VigilanceEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module EpistemicVigilance
+          module Helpers
+            module Constants
+              VIGILANCE_LEVELS = %i[trusting cautious skeptical hostile].freeze
+              VIGILANCE_THRESHOLDS = { trusting: 0.8, cautious: 0.6, skeptical: 0.3, hostile: 0.0 }.freeze
+              CLAIM_VERDICTS = %i[accepted provisionally_accepted suspended rejected].freeze
+              SOURCE_RELIABILITY_LABELS = {
+                (0.8..)     => :highly_reliable,
+                (0.6...0.8) => :reliable,
+                (0.4...0.6) => :uncertain,
+                (0.2...0.4) => :unreliable,
+                (..0.2)     => :deceptive
+              }.freeze
+
+              MAX_CLAIMS               = 200
+              MAX_SOURCES              = 100
+              MAX_HISTORY              = 500
+              DEFAULT_SOURCE_RELIABILITY = 0.5
+              RELIABILITY_BOOST        = 0.05
+              RELIABILITY_PENALTY      = 0.1
+              CONSISTENCY_WEIGHT       = 0.3
+              SOURCE_WEIGHT            = 0.4
+              COHERENCE_WEIGHT         = 0.3
+              DECAY_RATE               = 0.01
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module EpistemicVigilance
+          module Helpers
+            class Source
+              include Constants
+
+              attr_reader :id, :name, :domain, :claims_made, :claims_verified, :claims_refuted
+              attr_accessor :reliability
+
+              def initialize(name:, domain:)
+                @id              = SecureRandom.uuid
+                @name            = name
+                @domain          = domain
+                @reliability     = DEFAULT_SOURCE_RELIABILITY
+                @claims_made     = 0
+                @claims_verified = 0
+                @claims_refuted  = 0
+              end
+
+              def record_verified!
+                @claims_verified += 1
+                @reliability = (@reliability + RELIABILITY_BOOST).clamp(0.0, 1.0)
+              end
+
+              def record_refuted!
+                @claims_refuted += 1
+                @reliability = (@reliability - RELIABILITY_PENALTY).clamp(0.0, 1.0)
+              end
+
+              def reliability_label
+                SOURCE_RELIABILITY_LABELS.find { |range, _label| range.include?(@reliability) }&.last || :uncertain
+              end
+
+              def track_record
+                @claims_verified / (@claims_verified + @claims_refuted + 1.0)
+              end
+
+              def to_h
+                {
+                  id:                @id,
+                  name:              @name,
+                  domain:            @domain,
+                  reliability:       @reliability,
+                  reliability_label: reliability_label,
+                  claims_made:       @claims_made,
+                  claims_verified:   @claims_verified,
+                  claims_refuted:    @claims_refuted,
+                  track_record:      track_record
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module EpistemicVigilance
+          module Helpers
+            class VigilanceEngine
+              include Constants
+
+              def initialize
+                @sources = {}
+                @claims  = {}
+              end
+
+              def register_source(name:, domain:)
+                source = Source.new(name: name, domain: domain)
+                @sources[source.id] = source
+                source.to_h
+              end
+
+              def submit_claim(content:, source_id:, domain:, initial_confidence: 0.5)
+                source = @sources[source_id]
+                return { error: :source_not_found } unless source
+
+                claim = Claim.new(content: content, source_id: source_id, domain: domain,
+                                  confidence: initial_confidence)
+                source.instance_variable_set(:@claims_made, source.claims_made + 1)
+                @claims[claim.id] = claim
+                assessment = assess_claim(claim_id: claim.id)
+                { claim: claim.to_h, assessment: assessment }
+              end
+
+              def assess_claim(claim_id:)
+                claim = @claims[claim_id]
+                return { error: :claim_not_found } unless claim
+
+                source        = @sources[claim.source_id]
+                source_score  = build_source_score(source)
+                consist_score = claim.credibility_ratio * CONSISTENCY_WEIGHT
+                coher_score   = domain_coherence_score(claim.domain, exclude_id: claim_id)
+                total         = source_score + consist_score + coher_score
+                verdict       = recommended_verdict(total)
+
+                {
+                  claim_id:            claim_id,
+                  source_score:        source_score,
+                  consistency_score:   consist_score,
+                  coherence_score:     coher_score,
+                  total_score:         total,
+                  recommended_verdict: verdict
+                }
+              end
+
+              def support_claim(claim_id:)
+                claim  = @claims[claim_id]
+                source = claim && @sources[claim.source_id]
+                return { error: :claim_not_found } unless claim
+
+                claim.support!
+                source&.record_verified!
+                { claim_id: claim_id, confidence: claim.confidence, evidence_for: claim.evidence_for }
+              end
+
+              def challenge_claim(claim_id:)
+                claim  = @claims[claim_id]
+                source = claim && @sources[claim.source_id]
+                return { error: :claim_not_found } unless claim
+
+                claim.challenge!
+                source&.record_refuted!
+                { claim_id: claim_id, confidence: claim.confidence, evidence_against: claim.evidence_against }
+              end
+
+              def adjudicate_claim(claim_id:, verdict:)
+                claim  = @claims[claim_id]
+                source = claim && @sources[claim.source_id]
+                return { error: :claim_not_found } unless claim
+
+                claim.adjudicate!(verdict: verdict)
+                update_source_on_adjudication(source, verdict)
+                { claim_id: claim_id, verdict: verdict }
+              end
+
+              def source_reliability(source_id:)
+                source = @sources[source_id]
+                return { error: :source_not_found } unless source
+
+                { source_id: source_id, reliability: source.reliability, label: source.reliability_label }
+              end
+
+              def contested_claims
+                @claims.values.select(&:contested?).map(&:to_h)
+              end
+
+              def claims_by_source(source_id:)
+                @claims.values.select { |c| c.source_id == source_id }.map(&:to_h)
+              end
+
+              def claims_by_domain(domain:)
+                @claims.values.select { |c| c.domain == domain }.map(&:to_h)
+              end
+
+              def domain_vigilance_level(domain:)
+                domain_claims = @claims.values.select { |c| c.domain == domain }
+                return :skeptical if domain_claims.empty?
+
+                avg = domain_claims.sum(&:confidence) / domain_claims.size.to_f
+                level_for_score(avg)
+              end
+
+              def decay_all
+                @claims.each_value do |claim|
+                  claim.confidence = (claim.confidence - DECAY_RATE).clamp(0.0, 1.0)
+                end
+                { decayed: @claims.size }
+              end
+
+              def prune_rejected
+                before = @claims.size
+                @claims.reject! { |_, c| c.verdict == :rejected && c.confidence < 0.1 }
+                { pruned: before - @claims.size, remaining: @claims.size }
+              end
+
+              def to_h
+                {
+                  sources_count: @sources.size,
+                  claims_count:  @claims.size,
+                  contested:     contested_claims.size,
+                  by_verdict:    verdict_counts
+                }
+              end
+
+              private
+
+              def build_source_score(source)
+                return DEFAULT_SOURCE_RELIABILITY * SOURCE_WEIGHT unless source
+
+                source.reliability * SOURCE_WEIGHT
+              end
+
+              def domain_coherence_score(domain, exclude_id:)
+                peers = @claims.values.reject { |c| c.id == exclude_id }.select { |c| c.domain == domain }
+                return 0.0 if peers.empty?
+
+                avg = peers.sum(&:confidence) / peers.size.to_f
+                avg * COHERENCE_WEIGHT
+              end
+
+              def recommended_verdict(total_score)
+                if total_score >= VIGILANCE_THRESHOLDS[:trusting]
+                  :accepted
+                elsif total_score >= VIGILANCE_THRESHOLDS[:cautious]
+                  :provisionally_accepted
+                elsif total_score >= VIGILANCE_THRESHOLDS[:skeptical]
+                  :suspended
+                else
+                  :rejected
+                end
+              end
+
+              def level_for_score(score)
+                if score >= VIGILANCE_THRESHOLDS[:trusting]
+                  :trusting
+                elsif score >= VIGILANCE_THRESHOLDS[:cautious]
+                  :cautious
+                elsif score >= VIGILANCE_THRESHOLDS[:skeptical]
+                  :skeptical
+                else
+                  :hostile
+                end
+              end
+
+              def update_source_on_adjudication(source, verdict)
+                return unless source
+
+                case verdict
+                when :accepted then source.record_verified!
+                when :rejected then source.record_refuted!
+                end
+              end
+
+              def verdict_counts
+                CLAIM_VERDICTS.to_h do |v|
+                  [v, @claims.values.count { |c| c.verdict == v }]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end