lex-salience 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2c9ffd1698dd5b992b73679b28677974b343656d2131df48d5f893eb08ef1312
+  data.tar.gz: a792f5c3144f2fd7af78423326620246b8a89ee48bbc17762c2b5b83abb218da
+SHA512:
+  metadata.gz: 9566aac35355ff3119937b074d1afead3440df0625ae4128b0de8030b5e0820b23b6feb8734900ce23db8f18d0aa27b4194a64f54001a14f845aa2a46c71550f
+  data.tar.gz: 04aa1f807506a0514d19ca87b1edbc6fd9a3c2a8ddbb7b54ca32ab5f47cba61283658c89fa4aab123eb2b8a9a72f17444abf1634462bb23f943528873512f2a5

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    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

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

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

data/lib/legion/extensions/salience.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/salience/version'
+require 'legion/extensions/salience/helpers/constants'
+require 'legion/extensions/salience/helpers/signal_integrator'
+require 'legion/extensions/salience/helpers/salience_map'
+require 'legion/extensions/salience/runners/salience'
+require 'legion/extensions/salience/client'
+
+module Legion
+  module Extensions
+    module Salience
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: lex-salience
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Unified salience network for brain-modeled agentic AI — integrates signals
+  from all cognitive subsystems
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/salience.rb
+- lib/legion/extensions/salience/client.rb
+- lib/legion/extensions/salience/helpers/constants.rb
+- lib/legion/extensions/salience/helpers/salience_map.rb
+- lib/legion/extensions/salience/helpers/signal_integrator.rb
+- lib/legion/extensions/salience/runners/salience.rb
+- lib/legion/extensions/salience/version.rb
+homepage: https://github.com/LegionIO/lex-salience
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-salience
+  source_code_uri: https://github.com/LegionIO/lex-salience
+  documentation_uri: https://github.com/LegionIO/lex-salience
+  changelog_uri: https://github.com/LegionIO/lex-salience
+  bug_tracker_uri: https://github.com/LegionIO/lex-salience/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Salience
+test_files: []