lex-agentic-affect 0.1.0

data/lib/legion/extensions/agentic/affect/defusion/runners/cognitive_defusion.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Defusion
+          module Runners
+            module CognitiveDefusion
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def register_thought(content:, thought_type:, belief_strength: 0.5, engine: nil, **)
+                eng    = engine || defusion_engine
+                result = eng.register_thought(content: content, thought_type: thought_type, belief_strength: belief_strength)
+                return { success: false, **result } if result[:error]
+
+                Legion::Logging.debug "[cognitive_defusion] registered thought type=#{thought_type} " \
+                                      "belief=#{belief_strength.round(2)} id=#{result[:thought_id]}"
+                { success: true, **result }
+              end
+
+              def apply_defusion(thought_id:, technique:, engine: nil, **)
+                eng    = engine || defusion_engine
+                result = eng.apply_defusion(thought_id: thought_id, technique: technique)
+                return { success: false, **result } if result[:error]
+
+                Legion::Logging.debug "[cognitive_defusion] defusion applied technique=#{technique} " \
+                                      "reduction=#{result[:reduction]&.round(4)} fusion=#{result[:after]&.round(4)}"
+                result
+              end
+
+              def apply_all_techniques(thought_id:, engine: nil, **)
+                eng    = engine || defusion_engine
+                result = eng.apply_all_techniques(thought_id: thought_id)
+                return { success: false, **result } if result[:error]
+
+                Legion::Logging.debug "[cognitive_defusion] all techniques applied thought_id=#{thought_id} " \
+                                      "final_fusion=#{result[:final_fusion]&.round(4)}"
+                { success: true, **result }
+              end
+
+              def visit_thought(thought_id:, engine: nil, **)
+                eng    = engine || defusion_engine
+                result = eng.visit_thought(thought_id: thought_id)
+                return { success: false, **result } if result[:error]
+
+                Legion::Logging.debug "[cognitive_defusion] thought visited count=#{result[:visit_count]} " \
+                                      "ruminating=#{result[:ruminating]}"
+                { success: true, **result }
+              end
+
+              def fuse_thought(thought_id:, engine: nil, **)
+                eng = engine || defusion_engine
+                thought = eng.thoughts[thought_id]
+                return { success: false, error: :thought_not_found } unless thought
+
+                result = thought.fuse!
+                Legion::Logging.debug "[cognitive_defusion] thought fused before=#{result[:before].round(4)} " \
+                                      "after=#{result[:after].round(4)}"
+                { success: true, thought_id: thought_id, before: result[:before], after: result[:after], enmeshed: thought.enmeshed? }
+              end
+
+              def enmeshed_thoughts(engine: nil, **)
+                eng      = engine || defusion_engine
+                thoughts = eng.enmeshed_thoughts.map(&:to_h)
+                Legion::Logging.debug "[cognitive_defusion] enmeshed thoughts count=#{thoughts.size}"
+                { success: true, count: thoughts.size, thoughts: thoughts }
+              end
+
+              def defused_thoughts(engine: nil, **)
+                eng      = engine || defusion_engine
+                thoughts = eng.defused_thoughts.map(&:to_h)
+                Legion::Logging.debug "[cognitive_defusion] defused thoughts count=#{thoughts.size}"
+                { success: true, count: thoughts.size, thoughts: thoughts }
+              end
+
+              def ruminating_thoughts(engine: nil, **)
+                eng      = engine || defusion_engine
+                thoughts = eng.ruminating_thoughts.map(&:to_h)
+                Legion::Logging.debug "[cognitive_defusion] ruminating thoughts count=#{thoughts.size}"
+                { success: true, count: thoughts.size, thoughts: thoughts }
+              end
+
+              def most_fused(limit: 5, engine: nil, **)
+                eng      = engine || defusion_engine
+                thoughts = eng.most_fused(limit: limit).map(&:to_h)
+                Legion::Logging.debug "[cognitive_defusion] most fused count=#{thoughts.size}"
+                { success: true, count: thoughts.size, thoughts: thoughts }
+              end
+
+              def recommend_technique(thought_id:, engine: nil, **)
+                eng    = engine || defusion_engine
+                result = eng.recommend_technique(thought_id: thought_id)
+                return { success: false, **result } if result[:error]
+
+                Legion::Logging.debug "[cognitive_defusion] technique recommended=#{result[:technique]} " \
+                                      "for type=#{result[:thought_type]}"
+                { success: true, **result }
+              end
+
+              def defusion_report(engine: nil, **)
+                eng    = engine || defusion_engine
+                report = eng.defusion_report
+                Legion::Logging.debug "[cognitive_defusion] report: total=#{report[:total_thoughts]} " \
+                                      "enmeshed=#{report[:enmeshed_count]} avg_fusion=#{report[:average_fusion].round(4)}"
+                { success: true, **report }
+              end
+
+              def defusion_state(engine: nil, **)
+                eng = engine || defusion_engine
+                Legion::Logging.debug '[cognitive_defusion] state queried'
+                { success: true, **eng.to_h }
+              end
+
+              private
+
+              def defusion_engine
+                @defusion_engine ||= Helpers::DefusionEngine.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/defusion/version'
+require 'legion/extensions/agentic/affect/defusion/helpers/constants'
+require 'legion/extensions/agentic/affect/defusion/helpers/thought'
+require 'legion/extensions/agentic/affect/defusion/helpers/defusion_engine'
+require 'legion/extensions/agentic/affect/defusion/runners/cognitive_defusion'
+require 'legion/extensions/agentic/affect/defusion/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Defusion
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/emotion/actors/momentum_decay.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Emotion
+          module Actor
+            class MomentumDecay < Legion::Extensions::Actors::Every
+              def runner_class
+                Legion::Extensions::Agentic::Affect::Emotion::Runners::Gut
+              end
+
+              def runner_function
+                'decay_momentum'
+              end
+
+              def time
+                60
+              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/affect/emotion/client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/affect/emotion/helpers/valence'
+require 'legion/extensions/agentic/affect/emotion/helpers/baseline'
+require 'legion/extensions/agentic/affect/emotion/helpers/momentum'
+require 'legion/extensions/agentic/affect/emotion/runners/valence'
+require 'legion/extensions/agentic/affect/emotion/runners/gut'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Emotion
+          class Client
+            include Runners::Valence
+            include Runners::Gut
+
+            def initialize(**)
+              @emotion_baseline = Helpers::Baseline.new
+              @emotion_momentum = Helpers::Momentum.new
+              @domain_counts = Hash.new(0)
+            end
+
+            def track_domain(domain)
+              @domain_counts[domain] += 1
+            end
+
+            private
+
+            attr_reader :emotion_baseline, :emotion_momentum
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/emotion/helpers/baseline.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Emotion
+          module Helpers
+            class Baseline
+              ALPHA = 0.05       # slow adaptation to prevent adversarial manipulation
+              MIN_STDDEV = 0.1   # prevents division issues when baseline is stable
+              INITIAL_MEAN = 0.5
+              INITIAL_STDDEV = 0.25
+
+              attr_reader :dimensions
+
+              def initialize
+                @dimensions = Valence::DIMENSIONS.to_h do |dim|
+                  [dim, { mean: INITIAL_MEAN, stddev: INITIAL_STDDEV, count: 0 }]
+                end
+              end
+
+              def normalize(raw_score, dimension)
+                baseline = @dimensions[dimension]
+                return Valence.clamp(raw_score) unless baseline
+
+                normalized = (raw_score - baseline[:mean]) / [baseline[:stddev], MIN_STDDEV].max
+                Valence.clamp(normalized)
+              end
+
+              def update(dimension, raw_score)
+                baseline = @dimensions[dimension]
+                return unless baseline
+
+                baseline[:count] += 1
+                old_mean = baseline[:mean]
+                baseline[:mean] = (ALPHA * raw_score) + ((1.0 - ALPHA) * old_mean)
+                # Online stddev update (Welford-like with EMA)
+                deviation = (raw_score - baseline[:mean]).abs
+                baseline[:stddev] = (ALPHA * deviation) + ((1.0 - ALPHA) * baseline[:stddev])
+              end
+
+              def get(dimension)
+                @dimensions[dimension]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/emotion/helpers/momentum.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Emotion
+          module Helpers
+            class Momentum
+              attr_reader :valence_ema, :arousal_ema, :stability, :history
+
+              def initialize
+                @valence_ema = Valence.new_valence
+                @arousal_ema = 0.0
+                @stability = 1.0
+                @history = []
+              end
+
+              def update(current_valence, current_arousal)
+                alpha = Valence::MOMENTUM_ALPHA
+
+                previous_aggregate = Valence.magnitude(@valence_ema)
+                current_aggregate = Valence.magnitude(current_valence)
+
+                @valence_ema = Valence::DIMENSIONS.to_h do |dim|
+                  [dim, (alpha * current_valence[dim]) + ((1.0 - alpha) * @valence_ema[dim])]
+                end
+
+                @arousal_ema = (alpha * current_arousal) + ((1.0 - alpha) * @arousal_ema)
+                @stability = Valence.clamp(1.0 - (current_aggregate - previous_aggregate).abs)
+
+                @history << { valence: current_valence, arousal: current_arousal, timestamp: Time.now.utc }
+                @history.shift while @history.size > 100
+
+                { valence_ema: @valence_ema, arousal_ema: @arousal_ema, stability: @stability }
+              end
+
+              def emotional_state
+                {
+                  valence_ema:  @valence_ema,
+                  arousal_ema:  @arousal_ema,
+                  stability:    @stability,
+                  history_size: @history.size
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/emotion/helpers/valence.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Emotion
+          module Helpers
+            module Valence
+              DIMENSIONS = %i[urgency importance novelty familiarity].freeze
+              MAX_MAGNITUDE = Math.sqrt(4.0) # all 4 dimensions at 1.0
+
+              # Attention modulation weights (from spec Section 6.1)
+              URGENCY_ATTENTION_WEIGHT    = 0.4
+              IMPORTANCE_ATTENTION_WEIGHT = 0.35
+              NOVELTY_ATTENTION_WEIGHT    = 0.25
+              ATTENTION_MULTIPLIER        = 0.3
+
+              # Momentum
+              MOMENTUM_ALPHA = 0.3
+
+              # Source urgency map (spec Section 3.2)
+              SOURCE_URGENCY = {
+                firmware_violation: 1.0,
+                human_direct:       0.9,
+                mesh_priority:      0.7,
+                scheduled:          0.4,
+                ambient:            0.1
+              }.freeze
+
+              # Familiarity saturation (spec Section 3.5)
+              FAMILIARITY_SATURATION = 100
+
+              module_function
+
+              def new_valence(urgency: 0.0, importance: 0.0, novelty: 0.0, familiarity: 0.0)
+                {
+                  urgency:     clamp(urgency),
+                  importance:  clamp(importance),
+                  novelty:     clamp(novelty),
+                  familiarity: clamp(familiarity)
+                }
+              end
+
+              def magnitude(valence)
+                Math.sqrt(
+                  (valence[:urgency]**2) +
+                  (valence[:importance]**2) +
+                  (valence[:novelty]**2) +
+                  (valence[:familiarity]**2)
+                )
+              end
+
+              def dominant_dimension(valence)
+                DIMENSIONS.max_by { |d| valence[d] }
+              end
+
+              def aggregate(valences)
+                return new_valence if valences.empty?
+
+                sums = Hash.new(0.0)
+                valences.each do |v|
+                  DIMENSIONS.each { |d| sums[d] += v[d] }
+                end
+                n = valences.size.to_f
+                new_valence(**DIMENSIONS.to_h { |d| [d, sums[d] / n] })
+              end
+
+              def compute_arousal(valences)
+                return 0.0 if valences.empty?
+
+                total = valences.sum { |v| magnitude(v) }
+                clamp(total / (valences.size * MAX_MAGNITUDE))
+              end
+
+              def modulate_salience(base_salience, valence)
+                boost = ((valence[:urgency] * URGENCY_ATTENTION_WEIGHT) +
+                         (valence[:importance] * IMPORTANCE_ATTENTION_WEIGHT) +
+                         (valence[:novelty] * NOVELTY_ATTENTION_WEIGHT)) * ATTENTION_MULTIPLIER
+                clamp(base_salience + boost)
+              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/affect/emotion/runners/gut.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Emotion
+          module Runners
+            module Gut
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def gut_instinct(valences:, memory_signals: [], confidence_threshold: 0.5, **)
+                return { signal: :neutral, confidence: 0.0, basis: :insufficient_data } if valences.empty?
+
+                arousal = Helpers::Valence.compute_arousal(valences)
+                aggregate = Helpers::Valence.aggregate(valences)
+                dominant = Helpers::Valence.dominant_dimension(aggregate)
+
+                signal = determine_signal(aggregate, arousal)
+                confidence = compute_confidence(valences, memory_signals)
+
+                Legion::Logging.debug "[emotion] gut instinct: signal=#{signal} confidence=#{confidence.round(2)} " \
+                                      "arousal=#{arousal.round(2)} dominant=#{dominant} reliable=#{confidence >= confidence_threshold}"
+
+                result = {
+                  signal:     signal,
+                  confidence: confidence,
+                  arousal:    arousal,
+                  dominant:   dominant,
+                  aggregate:  aggregate,
+                  reliable:   confidence >= confidence_threshold
+                }
+
+                # Update momentum if available
+                emotion_momentum.update(aggregate, arousal) if respond_to?(:emotion_momentum, true)
+
+                result
+              end
+
+              def decay_momentum(**)
+                neutral = { urgency: 0.5, importance: 0.5, novelty: 0.5, familiarity: 0.5 }
+                momentum = emotion_momentum
+                momentum.update(neutral, 0.5)
+                stability = momentum.stability
+
+                Legion::Logging.debug "[emotion] momentum decay: stability=#{stability.round(2)}"
+
+                { decayed: true, stability: stability }
+              end
+
+              def emotional_state(**)
+                momentum = emotion_momentum
+                state = momentum.emotional_state
+                Legion::Logging.debug "[emotion] state query: stability=#{state[:stability]&.round(2)}"
+                {
+                  momentum: state,
+                  baseline: emotion_baseline.dimensions
+                }
+              end
+
+              private
+
+              def emotion_momentum
+                @emotion_momentum ||= Helpers::Momentum.new
+              end
+
+              def determine_signal(aggregate, arousal)
+                if aggregate[:urgency] > 0.7 && aggregate[:importance] > 0.7
+                  :alarm
+                elsif arousal > 0.7
+                  :heightened
+                elsif aggregate[:novelty] > 0.7 && aggregate[:familiarity] < 0.3
+                  :explore
+                elsif aggregate[:importance] > 0.6
+                  :attend
+                elsif arousal < 0.2
+                  :calm
+                else
+                  :neutral
+                end
+              end
+
+              def compute_confidence(valences, memory_signals)
+                return 0.0 if valences.empty?
+
+                magnitudes = valences.map { |v| Helpers::Valence.magnitude(v) }
+                mean_mag = magnitudes.sum / magnitudes.size
+                variance = magnitudes.sum { |m| (m - mean_mag)**2 } / magnitudes.size
+
+                consensus = Helpers::Valence.clamp(1.0 - Math.sqrt(variance))
+                evidence = Helpers::Valence.clamp(memory_signals.size / 10.0)
+
+                (consensus * 0.6) + (evidence * 0.4)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/emotion/runners/valence.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        module Emotion
+          module Runners
+            module Valence
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def evaluate_valence(signal:, source_type: :ambient, deadline: nil, domain: nil, **)
+                baseline = emotion_baseline
+
+                urgency_raw = compute_urgency(signal, source_type, deadline)
+                importance_raw = compute_importance(signal, domain)
+                novelty_raw = compute_novelty(signal)
+                familiarity_raw = compute_familiarity(domain)
+
+                valence = Helpers::Valence.new_valence(
+                  urgency:     baseline.normalize(urgency_raw, :urgency),
+                  importance:  baseline.normalize(importance_raw, :importance),
+                  novelty:     baseline.normalize(novelty_raw, :novelty),
+                  familiarity: baseline.normalize(familiarity_raw, :familiarity)
+                )
+
+                # Update baselines with raw scores
+                Helpers::Valence::DIMENSIONS.each do |dim|
+                  raw = { urgency: urgency_raw, importance: importance_raw,
+                          novelty: novelty_raw, familiarity: familiarity_raw }[dim]
+                  baseline.update(dim, raw)
+                end
+
+                magnitude = Helpers::Valence.magnitude(valence)
+                dominant = Helpers::Valence.dominant_dimension(valence)
+                Legion::Logging.debug "[emotion] valence: source=#{source_type} magnitude=#{magnitude.round(2)} dominant=#{dominant} " \
+                                      "u=#{valence[:urgency].round(2)} i=#{valence[:importance].round(2)} " \
+                                      "n=#{valence[:novelty].round(2)} f=#{valence[:familiarity].round(2)}"
+
+                {
+                  valence:            valence,
+                  magnitude:          magnitude,
+                  dominant_dimension: dominant
+                }
+              end
+
+              def aggregate_valences(valences:, **)
+                aggregated = Helpers::Valence.aggregate(valences)
+                arousal = Helpers::Valence.compute_arousal(valences)
+                dominant = Helpers::Valence.dominant_dimension(aggregated)
+
+                Legion::Logging.debug "[emotion] aggregate: count=#{valences.size} arousal=#{arousal.round(2)} dominant=#{dominant}"
+                {
+                  aggregate: aggregated,
+                  arousal:   arousal,
+                  dominant:  dominant,
+                  count:     valences.size
+                }
+              end
+
+              def modulate_attention(base_salience:, valence:, **)
+                modulated = Helpers::Valence.modulate_salience(base_salience, valence)
+                boost = modulated - base_salience
+                Legion::Logging.debug "[emotion] attention modulation: base=#{base_salience.round(2)} modulated=#{modulated.round(2)} boost=#{boost.round(2)}"
+                { original: base_salience, modulated: modulated, boost: boost }
+              end
+
+              def compute_arousal(valences:, **)
+                arousal = Helpers::Valence.compute_arousal(valences)
+                Legion::Logging.debug "[emotion] arousal=#{arousal.round(2)} from #{valences.size} valences"
+                { arousal: arousal }
+              end
+
+              private
+
+              def emotion_baseline
+                @emotion_baseline ||= Helpers::Baseline.new
+              end
+
+              def compute_urgency(signal, source_type, deadline)
+                deadline_urgency = 0.0
+                if deadline
+                  remaining = [(deadline - Time.now.utc).to_f, 0.0].max
+                  max_window = 86_400.0 # 24 hours
+                  deadline_urgency = Helpers::Valence.clamp(1.0 - (remaining / max_window))
+                end
+
+                source_urgency = Helpers::Valence::SOURCE_URGENCY.fetch(source_type, 0.1)
+
+                pattern_urgency = signal.is_a?(Hash) ? (signal[:urgency_hint] || 0.0) : 0.0
+
+                (deadline_urgency * 0.5) + (source_urgency * 0.3) + (pattern_urgency * 0.2)
+              end
+
+              def compute_importance(signal, _domain)
+                domain_weight = signal.is_a?(Hash) ? (signal[:domain_weight] || 0.5) : 0.5
+                impact_scope = signal.is_a?(Hash) ? (signal[:impact_scope] || 0.3) : 0.3
+                reversibility = signal.is_a?(Hash) ? (signal[:reversibility] || 0.5) : 0.5
+                outcome_severity = signal.is_a?(Hash) ? (signal[:outcome_severity] || 0.3) : 0.3
+
+                (domain_weight * 0.3) + (impact_scope * 0.2) +
+                  ((1.0 - reversibility) * 0.25) + (outcome_severity * 0.25)
+              end
+
+              def compute_novelty(signal)
+                signal.is_a?(Hash) ? (signal[:novelty_score] || 0.5) : 0.5
+              end
+
+              def compute_familiarity(domain)
+                signal_count = @domain_counts&.fetch(domain, 0) || 0
+                Helpers::Valence.clamp(signal_count.to_f / Helpers::Valence::FAMILIARITY_SATURATION)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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