lex-agentic-affect 0.1.0

data/lib/legion/extensions/agentic/affect/resilience/helpers/resilience_model.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Resilience
+          module Helpers
+            class ResilienceModel
+              attr_reader :dimensions, :growth_bonus, :history
+
+              def initialize
+                @dimensions = Constants::DIMENSIONS.keys.to_h { |d| [d, 0.5] }
+                @growth_bonus = 0.0
+                @history = []
+              end
+
+              def update_from_tracker(tracker)
+                update_elasticity(tracker)
+                update_robustness(tracker)
+                update_adaptability(tracker)
+                update_growth(tracker)
+
+                record_snapshot
+              end
+
+              def composite_score
+                total = 0.0
+                Constants::DIMENSIONS.each do |dim, config|
+                  total += (@dimensions[dim] + (dim == :growth ? @growth_bonus : 0.0)) * config[:weight]
+                end
+                total.clamp(0.0, 1.0)
+              end
+
+              def classification
+                score = composite_score
+                if score >= Constants::ANTIFRAGILITY_THRESHOLD
+                  :antifragile
+                elsif score >= 0.5
+                  :resilient
+                elsif score >= Constants::FRAGILITY_THRESHOLD
+                  :fragile
+                else
+                  :brittle
+                end
+              end
+
+              def dimension_detail(name)
+                return nil unless @dimensions.key?(name)
+
+                {
+                  name:    name,
+                  value:   @dimensions[name].round(4),
+                  config:  Constants::DIMENSIONS[name],
+                  trend:   dimension_trend(name),
+                  healthy: @dimensions[name] >= 0.5
+                }
+              end
+
+              def trend
+                return :insufficient_data if @history.size < 5
+
+                recent = @history.last(10)
+                scores = recent.map { |h| h[:composite] }
+                first_half = scores[0...(scores.size / 2)]
+                second_half = scores[(scores.size / 2)..]
+                diff = mean(second_half) - mean(first_half)
+
+                if diff > 0.03
+                  :strengthening
+                elsif diff < -0.03
+                  :weakening
+                else
+                  :stable
+                end
+              end
+
+              def to_h
+                {
+                  dimensions:   @dimensions.transform_values { |v| v.round(4) },
+                  growth_bonus: @growth_bonus.round(4),
+                  composite:    composite_score.round(4),
+                  class:        classification,
+                  trend:        trend
+                }
+              end
+
+              private
+
+              def update_elasticity(tracker)
+                speed = tracker.average_recovery_speed
+                signal = if speed.zero?
+                           0.5
+                         elsif speed <= 1.0
+                           0.7 + ((1.0 - speed) * 0.3)
+                         else
+                           [0.3, 0.7 - ((speed - 1.0) * 0.2)].max
+                         end
+                @dimensions[:elasticity] = ema(@dimensions[:elasticity], signal, Constants::RESILIENCE_ALPHA)
+              end
+
+              def update_robustness(tracker)
+                worst = tracker.worst_health
+                @dimensions[:robustness] = ema(@dimensions[:robustness], worst, Constants::RESILIENCE_ALPHA)
+              end
+
+              def update_adaptability(tracker)
+                rate = tracker.recovery_rate
+                signal = tracker.total_adversities.zero? ? 0.5 : rate
+                @dimensions[:adaptability] = ema(@dimensions[:adaptability], signal, Constants::RESILIENCE_ALPHA)
+              end
+
+              def update_growth(tracker)
+                if tracker.consecutive_recoveries >= Constants::GROWTH_TRIGGER
+                  @growth_bonus = [@growth_bonus + Constants::GROWTH_INCREMENT, Constants::MAX_GROWTH_BONUS].min
+                end
+
+                growth_signal = tracker.total_adversities.zero? ? 0.5 : 0.5 + @growth_bonus
+                @dimensions[:growth] = ema(@dimensions[:growth], growth_signal, Constants::RESILIENCE_ALPHA)
+              end
+
+              def dimension_trend(name)
+                return :insufficient_data if @history.size < 5
+
+                recent = @history.last(10)
+                values = recent.map { |h| h[:dimensions][name] }
+                first_half = values[0...(values.size / 2)]
+                second_half = values[(values.size / 2)..]
+                diff = mean(second_half) - mean(first_half)
+
+                if diff > 0.02
+                  :improving
+                elsif diff < -0.02
+                  :declining
+                else
+                  :stable
+                end
+              end
+
+              def ema(current, observed, alpha)
+                (current * (1.0 - alpha)) + (observed * alpha)
+              end
+
+              def mean(values)
+                return 0.0 if values.empty?
+
+                values.sum / values.size.to_f
+              end
+
+              def record_snapshot
+                @history << {
+                  dimensions: @dimensions.dup,
+                  composite:  composite_score,
+                  class:      classification,
+                  at:         Time.now.utc
+                }
+                @history.shift while @history.size > Constants::MAX_RESILIENCE_HISTORY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/resilience/runners/resilience.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Resilience
+          module Runners
+            module Resilience
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def update_resilience(tick_results: {}, **)
+                detect_adversities(tick_results)
+                recovery = adversity_tracker.tick_recovery
+                resilience_model.update_from_tracker(adversity_tracker)
+
+                Legion::Logging.debug "[resilience] active=#{recovery[:active_count]} " \
+                                      "resolved=#{recovery[:resolved_count]} " \
+                                      "composite=#{resilience_model.composite_score.round(3)}"
+
+                {
+                  active_adversities: recovery[:active_count],
+                  resolved_this_tick: recovery[:resolved_count],
+                  worst_health:       recovery[:worst_health],
+                  composite_score:    resilience_model.composite_score.round(4),
+                  classification:     resilience_model.classification,
+                  growth_bonus:       resilience_model.growth_bonus.round(4)
+                }
+              end
+
+              def register_adversity(type:, severity:, context: {}, **)
+                adversity = adversity_tracker.register(type: type, severity: severity, context: context)
+                return { success: false, error: 'invalid type or severity' } unless adversity
+
+                Legion::Logging.info "[resilience] adversity registered: type=#{type} severity=#{severity}"
+                { success: true, adversity: adversity }
+              end
+
+              def resilience_status(**)
+                model_state = resilience_model.to_h
+                Legion::Logging.debug "[resilience] status: #{model_state[:class]} score=#{model_state[:composite]}"
+
+                model_state.merge(
+                  active_adversities:     adversity_tracker.active_adversities.size,
+                  total_adversities:      adversity_tracker.total_adversities,
+                  consecutive_recoveries: adversity_tracker.consecutive_recoveries,
+                  recovery_rate:          adversity_tracker.recovery_rate.round(4)
+                )
+              end
+
+              def adversity_report(**)
+                Legion::Logging.debug '[resilience] adversity report'
+
+                {
+                  active:    adversity_tracker.active_adversities,
+                  by_type:   adversity_tracker.active_by_type,
+                  total:     adversity_tracker.total_adversities,
+                  worst:     adversity_tracker.worst_health.round(4),
+                  avg_speed: adversity_tracker.average_recovery_speed.round(4)
+                }
+              end
+
+              def dimension_detail(dimension:, **)
+                detail = resilience_model.dimension_detail(dimension.to_sym)
+                return { error: "unknown dimension: #{dimension}" } unless detail
+
+                Legion::Logging.debug "[resilience] dimension #{dimension}: #{detail[:value]}"
+                detail
+              end
+
+              def resilience_stats(**)
+                Legion::Logging.debug '[resilience] stats'
+
+                {
+                  composite:              resilience_model.composite_score.round(4),
+                  classification:         resilience_model.classification,
+                  dimensions:             resilience_model.dimensions.transform_values { |v| v.round(4) },
+                  growth_bonus:           resilience_model.growth_bonus.round(4),
+                  trend:                  resilience_model.trend,
+                  total_adversities:      adversity_tracker.total_adversities,
+                  active_adversities:     adversity_tracker.active_adversities.size,
+                  recovery_rate:          adversity_tracker.recovery_rate.round(4),
+                  consecutive_recoveries: adversity_tracker.consecutive_recoveries,
+                  history_size:           resilience_model.history.size
+                }
+              end
+
+              private
+
+              def adversity_tracker
+                @adversity_tracker ||= Helpers::AdversityTracker.new
+              end
+
+              def resilience_model
+                @resilience_model ||= Helpers::ResilienceModel.new
+              end
+
+              def detect_adversities(tick_results)
+                detect_prediction_adversity(tick_results)
+                detect_trust_adversity(tick_results)
+                detect_conflict_adversity(tick_results)
+                detect_energy_adversity(tick_results)
+                detect_emotional_adversity(tick_results)
+              end
+
+              def detect_prediction_adversity(tick_results)
+                error_rate = tick_results.dig(:prediction_engine, :error_rate)
+                return unless error_rate && error_rate > 0.7
+
+                severity = error_rate > 0.9 ? :major : :moderate
+                adversity_tracker.register(type: :prediction_failure, severity: severity)
+              end
+
+              def detect_trust_adversity(tick_results)
+                violation = tick_results.dig(:trust, :violation)
+                return unless violation
+
+                adversity_tracker.register(type: :trust_violation, severity: :major)
+              end
+
+              def detect_conflict_adversity(tick_results)
+                conflict_severity = tick_results.dig(:conflict, :severity)
+                return unless conflict_severity && conflict_severity >= 3
+
+                severity = conflict_severity >= 4 ? :severe : :moderate
+                adversity_tracker.register(type: :conflict_escalation, severity: severity)
+              end
+
+              def detect_energy_adversity(tick_results)
+                energy = tick_results.dig(:fatigue, :energy)
+                return unless energy && energy < 0.2
+
+                severity = energy < 0.1 ? :major : :moderate
+                adversity_tracker.register(type: :resource_depletion, severity: severity)
+              end
+
+              def detect_emotional_adversity(tick_results)
+                arousal = tick_results.dig(:emotional_evaluation, :arousal)
+                return unless arousal && arousal > 0.9
+
+                adversity_tracker.register(type: :emotional_shock, severity: :moderate)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/resilience/version.rb

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

data/lib/legion/extensions/agentic/affect/resilience.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/resilience/version'
+require 'legion/extensions/agentic/affect/resilience/helpers/constants'
+require 'legion/extensions/agentic/affect/resilience/helpers/adversity_tracker'
+require 'legion/extensions/agentic/affect/resilience/helpers/resilience_model'
+require 'legion/extensions/agentic/affect/resilience/runners/resilience'
+require 'legion/extensions/agentic/affect/resilience/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Resilience
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/resonance/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/resonance/helpers/constants'
+require 'legion/extensions/agentic/affect/resonance/helpers/category'
+require 'legion/extensions/agentic/affect/resonance/helpers/resonance_engine'
+require 'legion/extensions/agentic/affect/resonance/runners/cognitive_resonance'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Resonance
+          class Client
+            include Runners::CognitiveResonance
+
+            def initialize(**)
+              @default_engine = Helpers::ResonanceEngine.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/resonance/helpers/category.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Resonance
+          module Helpers
+            class Category
+              attr_reader :id, :prototype, :match_count, :last_matched_at
+
+              def initialize(prototype:)
+                @id              = SecureRandom.uuid
+                @prototype       = prototype.map { |v| v.to_f.clamp(0.0, 1.0) }
+                @match_count     = 0
+                @last_matched_at = nil
+              end
+
+              def match_quality(input:)
+                return 0.0 if @prototype.empty? || input.empty?
+
+                len          = [@prototype.size, input.size].min
+                proto_slice  = @prototype.first(len)
+                input_slice  = input.first(len).map { |v| v.to_f.clamp(0.0, 1.0) }
+                cosine_similarity(proto_slice, input_slice)
+              end
+
+              def update_prototype!(input:, learning_rate: Constants::DEFAULT_LEARNING_RATE)
+                rate = learning_rate.clamp(0.0, 1.0)
+                input_normalized = input.map { |v| v.to_f.clamp(0.0, 1.0) }
+
+                len = [@prototype.size, input_normalized.size].max
+                updated = Array.new(len) do |i|
+                  proto_val = @prototype[i] || 0.0
+                  input_val = input_normalized[i] || 0.0
+                  (proto_val + (rate * (input_val - proto_val))).round(10).clamp(0.0, 1.0)
+                end
+
+                @prototype = updated
+                @match_count += 1
+                @last_matched_at = Time.now.utc
+                self
+              end
+
+              private
+
+              def cosine_similarity(proto_slice, input_slice)
+                dot       = proto_slice.zip(input_slice).sum { |a, b| (a * b).round(10) }
+                mag_proto = Math.sqrt(proto_slice.sum { |v| (v**2).round(10) })
+                mag_input = Math.sqrt(input_slice.sum { |v| (v**2).round(10) })
+                return 0.0 if mag_proto.zero? || mag_input.zero?
+
+                (dot / (mag_proto * mag_input)).clamp(0.0, 1.0).round(10)
+              end
+
+              public
+
+              def to_h
+                {
+                  id:              @id,
+                  prototype:       @prototype,
+                  match_count:     @match_count,
+                  last_matched_at: @last_matched_at,
+                  dimensions:      @prototype.size
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/resonance/helpers/constants.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Resonance
+          module Helpers
+            module Constants
+              DEFAULT_VIGILANCE    = 0.7
+              MAX_CATEGORIES       = 200
+              RESONANCE_THRESHOLD  = 0.6
+              DEFAULT_LEARNING_RATE = 0.2
+
+              MATCH_LABELS = [
+                { range: (0.9..1.0), label: :perfect },
+                { range: (0.75..0.9), label: :strong },
+                { range: (0.6..0.75), label: :moderate },
+                { range: (0.4..0.6), label: :weak },
+                { range: (0.0..0.4), label: :mismatch }
+              ].freeze
+
+              VIGILANCE_LABELS = [
+                { range: (0.85..1.0), label: :fine },
+                { range: (0.65..0.85), label: :medium },
+                { range: (0.4..0.65), label: :coarse },
+                { range: (0.0..0.4), label: :very_coarse }
+              ].freeze
+
+              module_function
+
+              def match_label(quality)
+                entry = MATCH_LABELS.find { |e| e[:range].cover?(quality) }
+                entry ? entry[:label] : :mismatch
+              end
+
+              def vigilance_label(vigilance)
+                entry = VIGILANCE_LABELS.find { |e| e[:range].cover?(vigilance) }
+                entry ? entry[:label] : :very_coarse
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/resonance/helpers/resonance_engine.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Resonance
+          module Helpers
+            class ResonanceEngine
+              attr_reader :vigilance
+
+              def initialize(vigilance: Constants::DEFAULT_VIGILANCE)
+                @vigilance  = vigilance.clamp(0.0, 1.0)
+                @categories = {}
+              end
+
+              def present_input(input:)
+                normalized = input.map { |v| v.to_f.clamp(0.0, 1.0) }
+                match      = best_match(normalized)
+
+                if match && match[:quality] >= @vigilance
+                  resonate_with(match, normalized)
+                else
+                  create_category(normalized, prior_match: match)
+                end
+              end
+
+              def best_match(input)
+                return nil if @categories.empty?
+
+                normalized = input.map { |v| v.to_f.clamp(0.0, 1.0) }
+                best = nil
+
+                @categories.each_value do |category|
+                  quality = category.match_quality(input: normalized)
+                  next unless best.nil? || quality > best[:quality]
+
+                  best = { id: category.id, quality: quality }
+                end
+
+                best
+              end
+
+              def adjust_vigilance(amount:)
+                @vigilance = (@vigilance + amount).clamp(0.0, 1.0)
+                Legion::Logging.debug "[cognitive_resonance] vigilance adjusted to #{@vigilance.round(3)}"
+                @vigilance
+              end
+
+              def category_count
+                @categories.size
+              end
+
+              def resonance_report
+                vigilance_lbl = Constants.vigilance_label(@vigilance)
+                {
+                  category_count:  @categories.size,
+                  vigilance:       @vigilance,
+                  vigilance_label: vigilance_lbl,
+                  categories:      @categories.values.map(&:to_h)
+                }
+              end
+
+              def to_h
+                {
+                  vigilance:      @vigilance,
+                  category_count: @categories.size
+                }
+              end
+
+              private
+
+              def resonate_with(match, normalized)
+                category = @categories[match[:id]]
+                category.update_prototype!(input: normalized)
+                Legion::Logging.debug "[cognitive_resonance] resonance with category #{match[:id][0..7]} " \
+                                      "quality=#{match[:quality].round(3)} vigilance=#{@vigilance.round(3)}"
+                {
+                  outcome:     :resonance,
+                  category_id: match[:id],
+                  quality:     match[:quality],
+                  label:       Constants.match_label(match[:quality]),
+                  created:     false
+                }
+              end
+
+              def create_category(normalized, prior_match: nil)
+                prune_if_full!
+                category = Category.new(prototype: normalized)
+                @categories[category.id] = category
+                Legion::Logging.debug "[cognitive_resonance] new category #{category.id[0..7]} " \
+                                      "total=#{@categories.size} vigilance=#{@vigilance.round(3)}"
+                {
+                  outcome:     :new_category,
+                  category_id: category.id,
+                  quality:     prior_match ? prior_match[:quality] : 0.0,
+                  label:       :new,
+                  created:     true
+                }
+              end
+
+              def prune_if_full!
+                return unless @categories.size >= Constants::MAX_CATEGORIES
+
+                oldest_id = @categories.min_by { |_, cat| cat.last_matched_at || Time.at(0) }.first
+                @categories.delete(oldest_id)
+                Legion::Logging.debug "[cognitive_resonance] pruned oldest category #{oldest_id[0..7]}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end