lex-agentic-defense 0.1.0

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module EpistemicVigilance
+          module Runners
+            module EpistemicVigilance
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def register_epistemic_source(name:, domain:, **)
+                result = engine.register_source(name: name, domain: domain)
+                Legion::Logging.info "[epistemic_vigilance] registered source name=#{name} domain=#{domain} id=#{result[:id]}"
+                result
+              end
+
+              def submit_epistemic_claim(content:, source_id:, domain:, initial_confidence: 0.5, **)
+                result = engine.submit_claim(content: content, source_id: source_id, domain: domain,
+                                             initial_confidence: initial_confidence)
+                Legion::Logging.debug "[epistemic_vigilance] claim submitted domain=#{domain} verdict=#{result.dig(:assessment, :recommended_verdict)}"
+                result
+              end
+
+              def assess_epistemic_claim(claim_id:, **)
+                result = engine.assess_claim(claim_id: claim_id)
+                Legion::Logging.debug "[epistemic_vigilance] assess claim_id=#{claim_id} total=#{result[:total_score]&.round(3)}"
+                result
+              end
+
+              def support_epistemic_claim(claim_id:, **)
+                result = engine.support_claim(claim_id: claim_id)
+                Legion::Logging.debug "[epistemic_vigilance] support claim_id=#{claim_id} confidence=#{result[:confidence]&.round(3)}"
+                result
+              end
+
+              def challenge_epistemic_claim(claim_id:, **)
+                result = engine.challenge_claim(claim_id: claim_id)
+                Legion::Logging.debug "[epistemic_vigilance] challenge claim_id=#{claim_id} confidence=#{result[:confidence]&.round(3)}"
+                result
+              end
+
+              def adjudicate_epistemic_claim(claim_id:, verdict:, **)
+                result = engine.adjudicate_claim(claim_id: claim_id, verdict: verdict)
+                Legion::Logging.info "[epistemic_vigilance] adjudicate claim_id=#{claim_id} verdict=#{verdict}"
+                result
+              end
+
+              def source_reliability_report(source_id:, **)
+                result = engine.source_reliability(source_id: source_id)
+                Legion::Logging.debug "[epistemic_vigilance] source reliability source_id=#{source_id} label=#{result[:label]}"
+                result
+              end
+
+              def contested_claims_report(**)
+                claims = engine.contested_claims
+                Legion::Logging.debug "[epistemic_vigilance] contested claims count=#{claims.size}"
+                { contested: claims, count: claims.size }
+              end
+
+              def domain_vigilance_report(domain:, **)
+                level = engine.domain_vigilance_level(domain: domain)
+                claims = engine.claims_by_domain(domain: domain)
+                Legion::Logging.debug "[epistemic_vigilance] domain=#{domain} vigilance_level=#{level} claims=#{claims.size}"
+                { domain: domain, vigilance_level: level, claims: claims, count: claims.size }
+              end
+
+              def update_epistemic_vigilance(**)
+                decay_result = engine.decay_all
+                prune_result = engine.prune_rejected
+                Legion::Logging.debug "[epistemic_vigilance] decay+prune decayed=#{decay_result[:decayed]} pruned=#{prune_result[:pruned]}"
+                { decay: decay_result, prune: prune_result }
+              end
+
+              def epistemic_vigilance_stats(**)
+                engine.to_h
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::VigilanceEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Erosion
+          class Client
+            include Runners::CognitiveErosion
+
+            def initialize(engine: nil, **)
+              @default_engine = engine || Helpers::ErosionEngine.new
+            end
+
+            private
+
+            attr_reader :default_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/erosion/helpers/channel.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Erosion
+          module Helpers
+            class Channel
+              attr_reader :channel_id, :formation_id, :agent, :depth, :width,
+                          :flow_rate, :created_at, :updated_at, :last_active_at
+
+              def initialize(formation_id:, agent:, depth: 0.0, width: 0.1, flow_rate: 0.0, **)
+                raise ArgumentError, "invalid agent: #{agent}" unless Constants::EROSION_AGENTS.include?(agent)
+
+                @channel_id     = SecureRandom.uuid
+                @formation_id   = formation_id
+                @agent          = agent
+                @depth          = depth.clamp(0.0, 1.0).round(10)
+                @width          = width.clamp(0.0, 1.0).round(10)
+                @flow_rate      = flow_rate.clamp(0.0, 1.0).round(10)
+                @created_at     = Time.now.utc
+                @updated_at     = Time.now.utc
+                @last_active_at = nil
+              end
+
+              def deepen!(force)
+                force = force.clamp(0.0, 1.0)
+                @depth          = (@depth + force).clamp(0.0, 1.0).round(10)
+                @flow_rate      = [@flow_rate + (force * 0.1), 1.0].min.round(10)
+                @last_active_at = Time.now.utc
+                @updated_at     = Time.now.utc
+                { depth: @depth, flow_rate: @flow_rate }
+              end
+
+              def widen!(amount = 0.05)
+                amount  = amount.clamp(0.0, 1.0)
+                @width  = (@width + amount).clamp(0.0, 1.0).round(10)
+                @updated_at = Time.now.utc
+                { width: @width }
+              end
+
+              def dormant?
+                return true if @last_active_at.nil?
+
+                (Time.now.utc - @last_active_at) > 3600
+              end
+
+              def active?
+                !dormant?
+              end
+
+              def depth_label
+                Constants::CHANNEL_DEPTH_LABELS.each do |range, label|
+                  return label if range.cover?(@depth)
+                end
+                :surface_scratch
+              end
+
+              def to_h
+                {
+                  channel_id:     @channel_id,
+                  formation_id:   @formation_id,
+                  agent:          @agent,
+                  depth:          @depth,
+                  width:          @width,
+                  flow_rate:      @flow_rate,
+                  depth_label:    depth_label,
+                  dormant:        dormant?,
+                  active:         active?,
+                  created_at:     @created_at,
+                  updated_at:     @updated_at,
+                  last_active_at: @last_active_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Erosion
+          module Helpers
+            module Constants
+              MATERIAL_TYPES = %i[granite sandstone limestone chalk clay].freeze
+
+              EROSION_AGENTS = %i[water wind ice pressure chemical].freeze
+
+              RESISTANCE = {
+                granite:   0.9,
+                sandstone: 0.5,
+                limestone: 0.4,
+                chalk:     0.2,
+                clay:      0.1
+              }.freeze
+
+              MAX_FORMATIONS = 200
+
+              CHANNEL_DEPTH_LABELS = {
+                (0.0...0.1) => :surface_scratch,
+                (0.1...0.3) => :shallow_groove,
+                (0.3...0.5) => :carved_channel,
+                (0.5...0.7) => :deep_channel,
+                (0.7...0.9) => :ravine,
+                (0.9..1.0)  => :canyon
+              }.freeze
+
+              FORMATION_LABELS = {
+                (0.9..1.0)  => :pristine,
+                (0.7...0.9) => :intact,
+                (0.5...0.7) => :weathered,
+                (0.3...0.5) => :eroded,
+                (0.1...0.3) => :crumbling,
+                (0.0...0.1) => :ruins
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/erosion/helpers/erosion_engine.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Erosion
+          module Helpers
+            class ErosionEngine
+              def initialize
+                @formations = {}
+                @channels   = {}
+              end
+
+              def create_formation(material_type:, domain:, content:, resistance: nil, **)
+                return { success: false, error: :max_formations_reached } if @formations.size >= Constants::MAX_FORMATIONS
+                return { success: false, error: :invalid_material_type } unless Constants::MATERIAL_TYPES.include?(material_type)
+
+                formation = Formation.new(
+                  material_type: material_type,
+                  domain:        domain,
+                  content:       content,
+                  resistance:    resistance
+                )
+                @formations[formation.formation_id] = formation
+                { success: true, formation_id: formation.formation_id, formation: formation.to_h }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def erode(formation_id:, agent:, force:, **)
+                formation = @formations[formation_id]
+                return { success: false, error: :formation_not_found } unless formation
+                return { success: false, error: :invalid_agent } unless Constants::EROSION_AGENTS.include?(agent)
+
+                result = formation.erode!(agent, force)
+                channel = carve_channel(formation_id: formation_id, agent: agent, force: force)
+
+                { success: true, formation_id: formation_id, erosion: result, channel: channel }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def carve_channel(formation_id:, agent:, force: 0.1, **)
+                existing = find_channel(formation_id, agent)
+                if existing
+                  existing.deepen!(force.clamp(0.0, 1.0))
+                  existing.widen! if existing.depth >= 0.3
+                  existing.to_h
+                else
+                  channel = Channel.new(formation_id: formation_id, agent: agent)
+                  channel.deepen!(force.clamp(0.0, 1.0))
+                  @channels[channel.channel_id] = channel
+                  channel.to_h
+                end
+              end
+
+              def weather_all!(force: 0.05, agent: :wind, **)
+                results = @formations.map do |id, formation|
+                  erosion = formation.erode!(agent, force)
+                  ch      = carve_channel(formation_id: id, agent: agent, force: force)
+                  { formation_id: id, erosion: erosion, channel: ch }
+                end
+                { success: true, weathered: results.size, results: results }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def deepest_channels(limit: 5, **)
+                limit = limit.clamp(1, @channels.size.positive? ? @channels.size : 1)
+                sorted = @channels.values.sort_by { |c| -c.depth }
+                sorted.first(limit).map(&:to_h)
+              end
+
+              def most_eroded(limit: 5, **)
+                limit = limit.clamp(1, @formations.size.positive? ? @formations.size : 1)
+                sorted = @formations.values.sort_by(&:erosion_depth).reverse
+                sorted.first(limit).map(&:to_h)
+              end
+
+              def erosion_report(**)
+                {
+                  success:           true,
+                  total_formations:  @formations.size,
+                  total_channels:    @channels.size,
+                  canyons:           @formations.values.count(&:canyon?),
+                  weathered:         @formations.values.count(&:weathered?),
+                  pristine:          @formations.values.count(&:pristine?),
+                  average_depth:     average_depth,
+                  average_integrity: average_integrity,
+                  deepest_channels:  deepest_channels(limit: 3),
+                  most_eroded:       most_eroded(limit: 3)
+                }
+              end
+
+              def get_formation(formation_id)
+                formation = @formations[formation_id]
+                return { found: false } unless formation
+
+                { found: true, formation: formation.to_h }
+              end
+
+              def formation_count
+                @formations.size
+              end
+
+              def channel_count
+                @channels.size
+              end
+
+              private
+
+              def average_depth
+                return 0.0 if @formations.empty?
+
+                (@formations.values.sum(&:erosion_depth) / @formations.size.to_f).round(10)
+              end
+
+              def average_integrity
+                return 1.0 if @formations.empty?
+
+                (@formations.values.sum(&:integrity) / @formations.size.to_f).round(10)
+              end
+
+              def find_channel(formation_id, agent)
+                @channels.values.find { |c| c.formation_id == formation_id && c.agent == agent }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/erosion/helpers/formation.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Erosion
+          module Helpers
+            class Formation
+              attr_reader :formation_id, :material_type, :domain, :content,
+                          :resistance, :integrity, :erosion_depth, :created_at, :updated_at
+
+              def initialize(material_type:, domain:, content:, resistance: nil, **)
+                raise ArgumentError, "invalid material_type: #{material_type}" unless Constants::MATERIAL_TYPES.include?(material_type)
+
+                @formation_id = SecureRandom.uuid
+                @material_type = material_type
+                @domain        = domain
+                @content       = content
+                @resistance    = resistance || Constants::RESISTANCE.fetch(material_type)
+                @integrity     = 1.0
+                @erosion_depth = 0.0
+                @created_at    = Time.now.utc
+                @updated_at    = Time.now.utc
+              end
+
+              def erode!(agent, force)
+                raise ArgumentError, "invalid agent: #{agent}" unless Constants::EROSION_AGENTS.include?(agent)
+
+                force = force.clamp(0.0, 1.0)
+                effective_force = (force * (1.0 - @resistance)).round(10)
+
+                @integrity     = (@integrity - effective_force).clamp(0.0, 1.0).round(10)
+                @erosion_depth = (@erosion_depth + effective_force).clamp(0.0, 1.0).round(10)
+                @updated_at    = Time.now.utc
+
+                { agent: agent, force: force, effective_force: effective_force, integrity: @integrity, erosion_depth: @erosion_depth }
+              end
+
+              def resist!(amount = nil)
+                amount ||= @resistance * 0.1
+                amount = amount.clamp(0.0, 1.0)
+                @integrity  = (@integrity + amount).clamp(0.0, 1.0).round(10)
+                @updated_at = Time.now.utc
+                { integrity: @integrity, recovered: amount }
+              end
+
+              def weathered?
+                @integrity < 0.7
+              end
+
+              def canyon?
+                @erosion_depth >= 0.7
+              end
+
+              def pristine?
+                @integrity >= 0.9
+              end
+
+              def integrity_label
+                Constants::FORMATION_LABELS.each do |range, label|
+                  return label if range.cover?(@integrity)
+                end
+                :ruins
+              end
+
+              def depth_label
+                Constants::CHANNEL_DEPTH_LABELS.each do |range, label|
+                  return label if range.cover?(@erosion_depth)
+                end
+                :surface_scratch
+              end
+
+              def to_h
+                {
+                  formation_id:    @formation_id,
+                  material_type:   @material_type,
+                  domain:          @domain,
+                  content:         @content,
+                  resistance:      @resistance,
+                  integrity:       @integrity,
+                  erosion_depth:   @erosion_depth,
+                  integrity_label: integrity_label,
+                  depth_label:     depth_label,
+                  weathered:       weathered?,
+                  canyon:          canyon?,
+                  pristine:        pristine?,
+                  created_at:      @created_at,
+                  updated_at:      @updated_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/defense/erosion/runners/cognitive_erosion.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Erosion
+          module Runners
+            module CognitiveErosion
+              extend self
+
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def create_formation(material_type:, domain:, content:, resistance: nil, engine: nil, **)
+                eng = engine || default_engine
+                result = eng.create_formation(
+                  material_type: material_type,
+                  domain:        domain,
+                  content:       content,
+                  resistance:    resistance
+                )
+                Legion::Logging.debug "[cognitive_erosion] formation created: #{result[:formation_id]}" if result[:success]
+                result
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_erosion] create_formation failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def erode(formation_id:, agent:, force:, engine: nil, **)
+                eng = engine || default_engine
+                result = eng.erode(formation_id: formation_id, agent: agent, force: force)
+                Legion::Logging.debug "[cognitive_erosion] eroded #{formation_id[0..7]} agent=#{agent} force=#{force.round(3)}" if result[:success]
+                result
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_erosion] erode failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def weather_all(force: 0.05, agent: :wind, engine: nil, **)
+                eng = engine || default_engine
+                result = eng.weather_all!(force: force, agent: agent)
+                Legion::Logging.debug "[cognitive_erosion] weather_all: #{result[:weathered]} formations weathered" if result[:success]
+                result
+              rescue ArgumentError => e
+                Legion::Logging.warn "[cognitive_erosion] weather_all failed: #{e.message}"
+                { success: false, error: e.message }
+              end
+
+              def deepest_channels(limit: 5, engine: nil, **)
+                eng = engine || default_engine
+                channels = eng.deepest_channels(limit: limit)
+                { success: true, channels: channels, count: channels.size }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def most_eroded(limit: 5, engine: nil, **)
+                eng = engine || default_engine
+                formations = eng.most_eroded(limit: limit)
+                { success: true, formations: formations, count: formations.size }
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def erosion_report(engine: nil, **)
+                eng = engine || default_engine
+                result = eng.erosion_report
+                Legion::Logging.debug "[cognitive_erosion] report: formations=#{result[:total_formations]} " \
+                                      "channels=#{result[:total_channels]} canyons=#{result[:canyons]}"
+                result
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              def get_formation(formation_id:, engine: nil, **)
+                eng = engine || default_engine
+                eng.get_formation(formation_id)
+              rescue ArgumentError => e
+                { success: false, error: e.message }
+              end
+
+              private
+
+              def default_engine
+                @default_engine ||= Helpers::ErosionEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'erosion/version'
+require_relative 'erosion/helpers/constants'
+require_relative 'erosion/helpers/formation'
+require_relative 'erosion/helpers/channel'
+require_relative 'erosion/helpers/erosion_engine'
+require_relative 'erosion/runners/cognitive_erosion'
+require_relative 'erosion/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Defense
+        module Erosion
+        end
+      end
+    end
+  end
+end