lex-agentic-attention 0.1.0

data/lib/legion/extensions/agentic/attention/relevance_theory/runners/relevance_theory.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module RelevanceTheory
+          module Runners
+            module RelevanceTheory
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def submit_relevance_input(content:, input_type:, context:, cognitive_effect: nil,
+                                         processing_effort: nil, effect_type: nil, source_id: nil, **)
+                input = engine.submit_input(
+                  content:           content,
+                  input_type:        input_type.to_sym,
+                  context:           context.to_sym,
+                  cognitive_effect:  cognitive_effect || Helpers::Constants::DEFAULT_EFFECT,
+                  processing_effort: processing_effort || Helpers::Constants::DEFAULT_EFFORT,
+                  effect_type:       (effect_type || :new_implication).to_sym,
+                  source_id:         source_id
+                )
+                Legion::Logging.debug "[relevance_theory] submit id=#{input.id[0..7]} " \
+                                      "type=#{input_type} relevance=#{input.normalized_relevance.round(3)}"
+                { success: true, input: input.to_h }
+              end
+
+              def assess_input_relevance(input_id:, **)
+                result = engine.assess_relevance(input_id: input_id)
+                Legion::Logging.debug "[relevance_theory] assess id=#{input_id[0..7]} " \
+                                      "relevance=#{result[:normalized]}"
+                result
+              end
+
+              def strengthen_relevance(input_id:, amount: 0.1, **)
+                result = engine.strengthen_input(input_id: input_id, amount: amount)
+                Legion::Logging.debug "[relevance_theory] strengthen id=#{input_id[0..7]}"
+                result
+              end
+
+              def weaken_relevance(input_id:, amount: 0.1, **)
+                result = engine.weaken_input(input_id: input_id, amount: amount)
+                Legion::Logging.debug "[relevance_theory] weaken id=#{input_id[0..7]}"
+                result
+              end
+
+              def worth_processing_report(**)
+                inputs = engine.worth_processing
+                Legion::Logging.debug "[relevance_theory] worth_processing count=#{inputs.size}"
+                { success: true, inputs: inputs.map(&:to_h), count: inputs.size }
+              end
+
+              def most_relevant_inputs(limit: 5, **)
+                inputs = engine.most_relevant(limit: limit)
+                Legion::Logging.debug "[relevance_theory] most_relevant count=#{inputs.size}"
+                { success: true, inputs: inputs.map(&:to_h), count: inputs.size }
+              end
+
+              def context_relevance_report(context:, **)
+                score = engine.context_relevance(context: context.to_sym)
+                Legion::Logging.debug '[relevance_theory] context_relevance ' \
+                                      "ctx=#{context} score=#{score.round(3)}"
+                { success: true, context: context, relevance: score.round(3) }
+              end
+
+              def attention_budget_report(**)
+                budget = engine.attention_budget
+                Legion::Logging.debug '[relevance_theory] attention_budget ' \
+                                      "ratio=#{budget[:processing_ratio]}"
+                { success: true }.merge(budget)
+              end
+
+              def update_relevance_theory(**)
+                engine.decay_all
+                pruned = engine.prune_irrelevant
+                Legion::Logging.debug "[relevance_theory] decay+prune pruned=#{pruned}"
+                { success: true, pruned: pruned }
+              end
+
+              def relevance_theory_stats(**)
+                stats = engine.to_h
+                Legion::Logging.debug "[relevance_theory] stats total=#{stats[:total_inputs]}"
+                { success: true }.merge(stats)
+              end
+
+              private
+
+              def engine
+                @engine ||= Helpers::RelevanceEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/relevance_theory/version.rb

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

data/lib/legion/extensions/agentic/attention/relevance_theory.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'relevance_theory/version'
+require_relative 'relevance_theory/helpers/constants'
+require_relative 'relevance_theory/helpers/cognitive_input'
+require_relative 'relevance_theory/helpers/relevance_engine'
+require_relative 'relevance_theory/runners/relevance_theory'
+require_relative 'relevance_theory/helpers/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module RelevanceTheory
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/salience/client.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Salience
+          class Client
+            include Runners::Salience
+
+            attr_reader :salience_map
+
+            def initialize(salience_map: nil, **)
+              @salience_map = salience_map || Helpers::SalienceMap.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/salience/helpers/constants.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Salience
+          module Helpers
+            module Constants
+              SALIENCE_SOURCES = %i[emotion mood attention curiosity homeostasis trust empathy volition].freeze
+
+              SOURCE_WEIGHTS = {
+                emotion:     0.20,
+                mood:        0.10,
+                attention:   0.15,
+                curiosity:   0.15,
+                homeostasis: 0.15,
+                trust:       0.10,
+                empathy:     0.05,
+                volition:    0.10
+              }.freeze
+
+              URGENCY_LEVELS = %i[critical high moderate low background].freeze
+
+              URGENCY_THRESHOLDS = {
+                critical:   0.9,
+                high:       0.7,
+                moderate:   0.4,
+                low:        0.2,
+                background: 0.0
+              }.freeze
+
+              MAX_SALIENCE_ITEMS  = 10
+              SALIENCE_DECAY_RATE = 0.05
+              INTEGRATION_ALPHA   = 0.3
+              NOVELTY_BOOST       = 0.2
+              CONFLICT_AMPLIFIER  = 1.5
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/salience/helpers/salience_map.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Salience
+          module Helpers
+            class SalienceMap
+              attr_reader :current_map, :baseline, :history
+
+              MAX_HISTORY   = 50
+              TREND_WINDOW  = 5
+              TREND_DELTA   = 0.02
+
+              def initialize
+                @current_map   = {}
+                @baseline      = 0.0
+                @history       = []
+                @novel_sources = {}
+              end
+
+              def update(integrated_signals)
+                @current_map = integrated_signals.transform_values { |v| v[:weighted] }
+                apply_novelty_boost(integrated_signals)
+                overall = overall_salience
+                @baseline = (Constants::INTEGRATION_ALPHA * overall) + ((1.0 - Constants::INTEGRATION_ALPHA) * @baseline)
+                snapshot = {
+                  timestamp:    Time.now.utc.to_f,
+                  overall:      overall,
+                  urgency:      urgency_level,
+                  dominant:     dominant_source,
+                  map_snapshot: @current_map.dup
+                }
+                @history << snapshot
+                @history.shift while @history.size > MAX_HISTORY
+                snapshot
+              end
+
+              def overall_salience
+                @current_map.values.sum.round(6)
+              end
+
+              def urgency_level
+                score = overall_salience
+                Constants::URGENCY_LEVELS.find do |level|
+                  score >= Constants::URGENCY_THRESHOLDS[level]
+                end || :background
+              end
+
+              def dominant_source
+                return nil if @current_map.empty?
+
+                @current_map.max_by { |_k, v| v }&.first
+              end
+
+              def above_baseline?
+                overall_salience > @baseline
+              end
+
+              def conflict_signals
+                values = @current_map.values
+                return [] if values.size < 2
+
+                pairs = []
+                keys  = @current_map.keys
+                keys.each_with_index do |key_a, i|
+                  keys[(i + 1)..].each do |key_b|
+                    diff = (@current_map[key_a] - @current_map[key_b]).abs
+                    pairs << [key_a, key_b] if diff > 0.3
+                  end
+                end
+                pairs
+              end
+
+              def salience_trend
+                return :stable if @history.size < 2
+
+                window   = @history.last([TREND_WINDOW, @history.size].min).map { |h| h[:overall] }
+                delta    = window.last - window.first
+                if delta > TREND_DELTA
+                  :rising
+                elsif delta < -TREND_DELTA
+                  :falling
+                else
+                  :stable
+                end
+              end
+
+              def to_h
+                {
+                  current_map:    @current_map,
+                  overall:        overall_salience,
+                  baseline:       @baseline,
+                  urgency:        urgency_level,
+                  dominant:       dominant_source,
+                  above_baseline: above_baseline?,
+                  conflicts:      conflict_signals,
+                  trend:          salience_trend,
+                  history_size:   @history.size
+                }
+              end
+
+              private
+
+              def apply_novelty_boost(integrated_signals)
+                integrated_signals.each_key do |source|
+                  next if @novel_sources.key?(source)
+
+                  @novel_sources[source] = true
+                  current = @current_map[source] || 0.0
+                  boosted = [current + Constants::NOVELTY_BOOST, 1.0].min
+                  @current_map[source] = boosted
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/salience/helpers/signal_integrator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Salience
+          module Helpers
+            module SignalIntegrator
+              module_function
+
+              def integrate(tick_results: {})
+                Constants::SALIENCE_SOURCES.each_with_object({}) do |source, result|
+                  data   = tick_results.fetch(source, {}) || {}
+                  raw    = extract_raw(source, data)
+                  weight = Constants::SOURCE_WEIGHTS.fetch(source, 0.0)
+
+                  result[source] = {
+                    raw_salience: raw,
+                    weighted:     (raw * weight).round(6),
+                    signal_data:  data
+                  }
+                end
+              end
+
+              def extract_raw(source, data)
+                case source
+                when :emotion     then extract_emotion(data)
+                when :mood        then extract_mood(data)
+                when :attention   then extract_attention(data)
+                when :curiosity   then extract_curiosity(data)
+                when :homeostasis then extract_homeostasis(data)
+                when :trust       then extract_trust(data)
+                when :empathy     then extract_empathy(data)
+                when :volition    then extract_volition(data)
+                else 0.0
+                end
+              end
+
+              def extract_emotion(data)
+                arousal      = (data[:arousal] || 0.0).to_f
+                gut_strength = (data[:gut_strength] || 0.0).to_f
+                clamp([arousal, gut_strength].max)
+              end
+
+              def extract_mood(data)
+                stability = (data[:stability] || 1.0).to_f
+                clamp(1.0 - stability)
+              end
+
+              def extract_attention(data)
+                spotlight_count = (data[:spotlight_count] || 0).to_f
+                total           = [(data[:total] || 0).to_f, 1.0].max
+                clamp(spotlight_count / total)
+              end
+
+              def extract_curiosity(data)
+                top_salience = (data[:top_salience] || 0.0).to_f
+                clamp(top_salience)
+              end
+
+              def extract_homeostasis(data)
+                worst_deviation = (data[:worst_deviation] || 0.0).to_f
+                clamp(worst_deviation)
+              end
+
+              def extract_trust(data)
+                violation_count = (data[:violation_count] || 0).to_f
+                clamp(violation_count * 0.3)
+              end
+
+              EMPATHY_CLIMATE_SCORES = {
+                adversarial: 1.0,
+                tense:       0.5,
+                neutral:     0.1,
+                harmonious:  0.0
+              }.freeze
+
+              def extract_empathy(data)
+                EMPATHY_CLIMATE_SCORES.fetch(data[:climate], 0.0)
+              end
+
+              def extract_volition(data)
+                intention_salience = (data[:intention_salience] || 0.0).to_f
+                clamp(intention_salience)
+              end
+
+              def clamp(value, min = 0.0, max = 1.0)
+                value.clamp(min, max)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/salience/runners/salience.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Salience
+          module Runners
+            module Salience
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def compute_salience(tick_results: {}, **)
+                integrated = Helpers::SignalIntegrator.integrate(tick_results: tick_results)
+                salience_map.update(integrated)
+
+                Legion::Logging.debug "[salience] compute: overall=#{salience_map.overall_salience.round(3)} " \
+                                      "urgency=#{salience_map.urgency_level} dominant=#{salience_map.dominant_source}"
+
+                {
+                  overall:         salience_map.overall_salience,
+                  urgency:         salience_map.urgency_level,
+                  dominant_source: salience_map.dominant_source,
+                  above_baseline:  salience_map.above_baseline?,
+                  conflicts:       salience_map.conflict_signals,
+                  sources:         integrated,
+                  trend:           salience_map.salience_trend
+                }
+              end
+
+              def salience_status(**)
+                Legion::Logging.debug "[salience] status: urgency=#{salience_map.urgency_level} trend=#{salience_map.salience_trend}"
+                {
+                  overall:        salience_map.overall_salience,
+                  urgency:        salience_map.urgency_level,
+                  dominant:       salience_map.dominant_source,
+                  baseline:       salience_map.baseline,
+                  trend:          salience_map.salience_trend,
+                  above_baseline: salience_map.above_baseline?
+                }
+              end
+
+              def salience_for(source:, **)
+                data = salience_map.current_map[source]
+                Legion::Logging.debug "[salience] salience_for: source=#{source} salience=#{data || 0.0}"
+                { source: source, salience: data || 0.0, urgency: salience_map.urgency_level }
+              end
+
+              def salience_history(limit: 10, **)
+                { entries: salience_map.history.last(limit) }
+              end
+
+              def salience_stats(**)
+                {
+                  overall:        salience_map.overall_salience,
+                  baseline:       salience_map.baseline,
+                  urgency:        salience_map.urgency_level,
+                  dominant:       salience_map.dominant_source,
+                  history_size:   salience_map.history.size,
+                  conflict_count: salience_map.conflict_signals.size,
+                  trend:          salience_map.salience_trend
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/salience/version.rb

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

data/lib/legion/extensions/agentic/attention/salience.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/salience/version'
+require 'legion/extensions/agentic/attention/salience/helpers/constants'
+require 'legion/extensions/agentic/attention/salience/helpers/signal_integrator'
+require 'legion/extensions/agentic/attention/salience/helpers/salience_map'
+require 'legion/extensions/agentic/attention/salience/runners/salience'
+require 'legion/extensions/agentic/attention/salience/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Salience
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/attention/schema/actors/decay.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Schema
+          module Actor
+            class Decay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Attention::Schema::Runners::AttentionSchema
+              end
+
+              def runner_function
+                'decay_schema'
+              end
+
+              def time
+                30
+              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/attention/schema/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/attention/schema/helpers/constants'
+require 'legion/extensions/agentic/attention/schema/helpers/schema_item'
+require 'legion/extensions/agentic/attention/schema/helpers/attention_schema_model'
+require 'legion/extensions/agentic/attention/schema/runners/attention_schema'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Attention
+        module Schema
+          class Client
+            include Runners::AttentionSchema
+
+            def initialize(schema_model: nil, **)
+              @schema_model = schema_model || Helpers::AttentionSchemaModel.new
+            end
+
+            private
+
+            attr_reader :schema_model
+          end
+        end
+      end
+    end
+  end
+end