lex-agentic-affect 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32170727e3ada461fd6f49b646222d9389ce0c1d702348bfe99a9f592d5ed687
-  data.tar.gz: 2713926f3a67ed6dbef20d81401604e7d289219fe25c7daea397154b707022b0
+  metadata.gz: d3edfb8ca48c97428f04fd913693fcffb129c1ee5bb8779be2dbd61ffeeeeed6
+  data.tar.gz: 6443631b15f56be9897948a5149912af86d203e81cc893ad86fe6e8d258e2122
 SHA512:
-  metadata.gz: 572b2483316759d8924455d0c8a9b68cd40c3b7490a6051016da50249625808b22e59d20a830d9652a423a41f61b9ae06258984ede87ae387873a92cbc9f1cb0
-  data.tar.gz: 133f9e9c405cc107ca7cf67f179f8316bfff5aa4724181ece849d75d705c1e2981b03f253dbd60c27918bc86b06d852fba631615fe4c67f7e845c8426966246e
+  metadata.gz: d28e2998e7ae2f15c19754565e8bb2fa92b67d4a9727f9e9d232cbff5c39e235570da1aa2e306363a1cc6a15f7476794bdc12bcebe7690efb0e1cc5819bc3926
+  data.tar.gz: 8d6c801d3769cb4b10db6db28eb62e81726c8213981e1fb5d2c92b61e9b625c714c7ce48f39928315e22cd406601992a165ce9db053d1f9b356c3b081bc13b74

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.1.6] - 2026-03-30
+
+### Changed
+- update to rubocop-legion 0.1.7, resolve all offenses
+
 ## [0.1.5] - 2026-03-26
 
 ### Changed

data/Gemfile

@@ -3,3 +3,5 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'rubocop-legion', '~> 0.1', require: false

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

@@ -11,6 +11,7 @@ module Legion
       module Affect
         module Appraisal
           class Client
+            include Legion::Extensions::Helpers::Lex
             include Runners::Appraisal
           end
         end

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

@@ -7,76 +7,78 @@ module Legion
         module Appraisal
           module Runners
             module Appraisal
+              extend self
+
               def appraise_event(event:, primary:, secondary:, domain: nil, **)
-                Legion::Logging.debug("[lex-appraisal] appraise_event event=#{event} domain=#{domain}")
+                log.debug("[lex-appraisal] appraise_event event=#{event} domain=#{domain}")
                 record = engine.appraise(event: event, primary: primary, secondary: secondary, domain: domain)
                 { success: true, appraisal: record.to_h }
               rescue StandardError => e
-                Legion::Logging.error("[lex-appraisal] appraise_event error: #{e.message}")
+                log.error("[lex-appraisal] appraise_event error: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def reappraise_event(appraisal_id:, new_primary:, new_secondary:, **)
-                Legion::Logging.debug("[lex-appraisal] reappraise_event id=#{appraisal_id}")
+                log.debug("[lex-appraisal] reappraise_event id=#{appraisal_id}")
                 record = engine.reappraise(appraisal_id: appraisal_id, new_primary: new_primary,
                                            new_secondary: new_secondary)
                 return { success: false, error: 'appraisal not found' } unless record
 
                 { success: true, appraisal: record.to_h }
               rescue StandardError => e
-                Legion::Logging.error("[lex-appraisal] reappraise_event error: #{e.message}")
+                log.error("[lex-appraisal] reappraise_event error: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def select_coping_strategy(appraisal_id:, coping_type:, **)
-                Legion::Logging.debug("[lex-appraisal] select_coping appraisal_id=#{appraisal_id}")
+                log.debug("[lex-appraisal] select_coping appraisal_id=#{appraisal_id}")
                 record = engine.select_coping(appraisal_id: appraisal_id, coping_type: coping_type)
                 return { success: false, error: 'appraisal not found' } unless record
 
                 { success: true, appraisal: record.to_h }
               rescue StandardError => e
-                Legion::Logging.error("[lex-appraisal] select_coping error: #{e.message}")
+                log.error("[lex-appraisal] select_coping error: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def add_coping_strategy(name:, coping_type:, effectiveness:, **)
-                Legion::Logging.debug("[lex-appraisal] add_coping_strategy name=#{name}")
+                log.debug("[lex-appraisal] add_coping_strategy name=#{name}")
                 added = engine.add_coping_strategy(name: name, coping_type: coping_type, effectiveness: effectiveness)
                 { success: added, name: name, coping_type: coping_type }
               rescue StandardError => e
-                Legion::Logging.error("[lex-appraisal] add_coping_strategy error: #{e.message}")
+                log.error("[lex-appraisal] add_coping_strategy error: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def evaluate_coping(appraisal_id:, **)
-                Legion::Logging.debug("[lex-appraisal] evaluate_coping id=#{appraisal_id}")
+                log.debug("[lex-appraisal] evaluate_coping id=#{appraisal_id}")
                 result = engine.evaluate_coping(appraisal_id: appraisal_id)
                 { success: true }.merge(result)
               rescue StandardError => e
-                Legion::Logging.error("[lex-appraisal] evaluate_coping error: #{e.message}")
+                log.error("[lex-appraisal] evaluate_coping error: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def emotional_pattern(**)
-                Legion::Logging.debug('[lex-appraisal] emotional_pattern')
+                log.debug('[lex-appraisal] emotional_pattern')
                 pattern = engine.emotional_pattern
                 { success: true, pattern: pattern }
               rescue StandardError => e
-                Legion::Logging.error("[lex-appraisal] emotional_pattern error: #{e.message}")
+                log.error("[lex-appraisal] emotional_pattern error: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def update_appraisal(**)
-                Legion::Logging.debug('[lex-appraisal] update_appraisal (decay cycle)')
+                log.debug('[lex-appraisal] update_appraisal (decay cycle)')
                 engine.decay_all
                 { success: true }
               rescue StandardError => e
-                Legion::Logging.error("[lex-appraisal] update_appraisal error: #{e.message}")
+                log.error("[lex-appraisal] update_appraisal error: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def appraisal_stats(**)
-                Legion::Logging.debug('[lex-appraisal] appraisal_stats')
+                log.debug('[lex-appraisal] appraisal_stats')
                 data = engine.to_h
                 unresolved = engine.unresolved.size
                 {
@@ -87,7 +89,7 @@ module Legion
                   pattern:      engine.emotional_pattern
                 }
               rescue StandardError => e
-                Legion::Logging.error("[lex-appraisal] appraisal_stats error: #{e.message}")
+                log.error("[lex-appraisal] appraisal_stats error: #{e.message}")
                 { success: false, error: e.message }
               end
 

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

@@ -6,6 +6,7 @@ module Legion
       module Affect
         module CognitiveEmpathy
           class Client
+            include Legion::Extensions::Helpers::Lex
             include Runners::CognitiveEmpathy
 
             def initialize(engine: nil)

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

@@ -81,7 +81,9 @@ module Legion
               end
 
               def accuracy_label(accuracy)
-                ACCURACY_LABELS.each { |range, lbl| return lbl if range.cover?(accuracy) }
+                ACCURACY_LABELS.each do |range, lbl|
+                  return lbl if range.cover?(accuracy) # rubocop:disable Legion/Extension/RunnerReturnHash
+                end
                 :blind
               end
             end

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

@@ -11,6 +11,7 @@ module Legion
       module Affect
         module Contagion
           class Client
+            include Legion::Extensions::Helpers::Lex
             include Runners::CognitiveContagion
 
             def initialize(**)

data/lib/legion/extensions/agentic/affect/contagion/runners/cognitive_contagion.rb

@@ -7,20 +7,20 @@ module Legion
         module Contagion
           module Runners
             module CognitiveContagion
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_meme(label:, contagion_type: :cognitive, virulence: nil, **)
                 v      = virulence || Helpers::Constants::DEFAULT_VIRULENCE
                 result = engine.create_meme(label: label, contagion_type: contagion_type, virulence: v)
 
                 if result.is_a?(Hash) && result[:error]
-                  Legion::Logging.warn "[cognitive_contagion] create_meme failed: #{result[:error]}"
-                  return result
+                  log.warn("[cognitive_contagion] create_meme failed: #{result[:error]}")
+                  return result # rubocop:disable Legion/Extension/RunnerReturnHash
                 end
 
-                Legion::Logging.info "[cognitive_contagion] meme created: id=#{result.id} label=#{label} " \
-                                     "virulence=#{result.virulence} type=#{contagion_type}"
+                log.info("[cognitive_contagion] meme created: id=#{result.id} label=#{label} " \
+                         "virulence=#{result.virulence} type=#{contagion_type}")
                 result.to_h
               end
 
@@ -29,11 +29,11 @@ module Legion
                 result = engine.register_agent(agent_id: agent_id, resistance: r)
 
                 if result.is_a?(Hash) && result[:error]
-                  Legion::Logging.warn "[cognitive_contagion] register_agent failed: #{result[:error]}"
-                  return result
+                  log.warn("[cognitive_contagion] register_agent failed: #{result[:error]}")
+                  return result # rubocop:disable Legion/Extension/RunnerReturnHash
                 end
 
-                Legion::Logging.debug "[cognitive_contagion] agent registered: id=#{agent_id} resistance=#{r}"
+                log.debug("[cognitive_contagion] agent registered: id=#{agent_id} resistance=#{r}")
                 result
               end
 
@@ -43,15 +43,15 @@ module Legion
                   source_agent_id: source_agent_id,
                   target_agent_id: target_agent_id
                 )
-                Legion::Logging.debug "[cognitive_contagion] transmission: meme=#{meme_id} " \
-                                      "#{source_agent_id}->#{target_agent_id} transmitted=#{result[:transmitted]}"
+                log.debug("[cognitive_contagion] transmission: meme=#{meme_id} " \
+                          "#{source_agent_id}->#{target_agent_id} transmitted=#{result[:transmitted]}")
                 result
               end
 
               def recover_agent(meme_id:, agent_id:, **)
                 result = engine.recover_agent(meme_id: meme_id, agent_id: agent_id)
-                Legion::Logging.debug "[cognitive_contagion] recover: meme=#{meme_id} agent=#{agent_id} " \
-                                      "result=#{result[:result]}"
+                log.debug("[cognitive_contagion] recover: meme=#{meme_id} agent=#{agent_id} " \
+                          "result=#{result[:result]}")
                 result
               end
 
@@ -60,51 +60,51 @@ module Legion
                 return { infected: false, reason: :meme_not_found } unless meme
 
                 result = meme.infect!(agent_id: agent_id)
-                Legion::Logging.debug "[cognitive_contagion] infect_agent: meme=#{meme_id} agent=#{agent_id} result=#{result}"
+                log.debug("[cognitive_contagion] infect_agent: meme=#{meme_id} agent=#{agent_id} result=#{result}")
                 { infected: result == :infected, agent_id: agent_id, meme_id: meme_id, result: result }
               end
 
               def immunize_agent(meme_id:, agent_id:, **)
                 result = engine.immunize_agent(meme_id: meme_id, agent_id: agent_id)
-                Legion::Logging.debug "[cognitive_contagion] immunize: meme=#{meme_id} agent=#{agent_id}"
+                log.debug("[cognitive_contagion] immunize: meme=#{meme_id} agent=#{agent_id}")
                 result
               end
 
               def spread_step(meme_id:, **)
                 result = engine.spread_step(meme_id: meme_id)
-                Legion::Logging.info "[cognitive_contagion] spread_step: meme=#{meme_id} " \
-                                     "transmissions=#{result[:transmissions]} recoveries=#{result[:recoveries]}"
+                log.info("[cognitive_contagion] spread_step: meme=#{meme_id} " \
+                         "transmissions=#{result[:transmissions]} recoveries=#{result[:recoveries]}")
                 result
               end
 
               def epidemic_report(meme_id:, **)
                 result = engine.epidemic_report(meme_id: meme_id)
-                Legion::Logging.debug "[cognitive_contagion] epidemic_report: meme=#{meme_id} " \
-                                      "infected=#{result[:infected]} virulence_label=#{result[:virulence_label]}"
+                log.debug("[cognitive_contagion] epidemic_report: meme=#{meme_id} " \
+                          "infected=#{result[:infected]} virulence_label=#{result[:virulence_label]}")
                 result
               end
 
               def most_viral(limit: 5, **)
                 results = engine.most_viral(limit: limit)
-                Legion::Logging.debug "[cognitive_contagion] most_viral: limit=#{limit} count=#{results.size}"
+                log.debug("[cognitive_contagion] most_viral: limit=#{limit} count=#{results.size}")
                 { memes: results, count: results.size }
               end
 
               def agent_status(agent_id:, meme_id:, **)
                 result = engine.agent_status(agent_id: agent_id, meme_id: meme_id)
-                Legion::Logging.debug "[cognitive_contagion] agent_status: agent=#{agent_id} " \
-                                      "meme=#{meme_id} status=#{result[:status]}"
+                log.debug("[cognitive_contagion] agent_status: agent=#{agent_id} " \
+                          "meme=#{meme_id} status=#{result[:status]}")
                 result
               end
 
               def susceptible_agents(meme_id:, **)
                 agents = engine.susceptible_agents(meme_id: meme_id)
-                Legion::Logging.debug "[cognitive_contagion] susceptible_agents: meme=#{meme_id} count=#{agents.size}"
+                log.debug("[cognitive_contagion] susceptible_agents: meme=#{meme_id} count=#{agents.size}")
                 { agents: agents, count: agents.size, meme_id: meme_id }
               end
 
               def contagion_status(**)
-                Legion::Logging.debug '[cognitive_contagion] contagion_status requested'
+                log.debug('[cognitive_contagion] contagion_status requested')
                 summary = engine.to_h.slice(:meme_count, :agent_count)
                 summary.merge(contagion_types: Helpers::Constants::CONTAGION_TYPES,
                               max_agents:      Helpers::Constants::MAX_AGENTS,

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

@@ -11,6 +11,7 @@ module Legion
       module Affect
         module Defusion
           class Client
+            include Legion::Extensions::Helpers::Lex
             include Runners::CognitiveDefusion
 
             def initialize(engine: nil)

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

@@ -7,16 +7,16 @@ module Legion
         module Defusion
           module Runners
             module CognitiveDefusion
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               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]}"
+                log.debug("[cognitive_defusion] registered thought type=#{thought_type} " \
+                          "belief=#{belief_strength.round(2)} id=#{result[:thought_id]}")
                 { success: true, **result }
               end
 
@@ -25,8 +25,8 @@ module Legion
                 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)}"
+                log.debug("[cognitive_defusion] defusion applied technique=#{technique} " \
+                          "reduction=#{result[:reduction]&.round(4)} fusion=#{result[:after]&.round(4)}")
                 result
               end
 
@@ -35,8 +35,8 @@ module Legion
                 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)}"
+                log.debug("[cognitive_defusion] all techniques applied thought_id=#{thought_id} " \
+                          "final_fusion=#{result[:final_fusion]&.round(4)}")
                 { success: true, **result }
               end
 
@@ -45,8 +45,8 @@ module Legion
                 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]}"
+                log.debug("[cognitive_defusion] thought visited count=#{result[:visit_count]} " \
+                          "ruminating=#{result[:ruminating]}")
                 { success: true, **result }
               end
 
@@ -56,36 +56,36 @@ module Legion
                 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)}"
+                log.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}"
+                log.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}"
+                log.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}"
+                log.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}"
+                log.debug("[cognitive_defusion] most fused count=#{thoughts.size}")
                 { success: true, count: thoughts.size, thoughts: thoughts }
               end
 
@@ -94,22 +94,22 @@ module Legion
                 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]}"
+                log.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)}"
+                log.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'
+                log.debug('[cognitive_defusion] state queried')
                 { success: true, **eng.to_h }
               end
 

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

@@ -8,7 +8,7 @@ module Legion
       module Affect
         module Emotion
           module Actor
-            class MomentumDecay < Legion::Extensions::Actors::Every
+            class MomentumDecay < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
               def runner_class
                 Legion::Extensions::Agentic::Affect::Emotion::Runners::Gut
               end

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

@@ -12,6 +12,7 @@ module Legion
       module Affect
         module Emotion
           class Client
+            include Legion::Extensions::Helpers::Lex
             include Runners::Valence
             include Runners::Gut
 

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

@@ -7,8 +7,8 @@ module Legion
         module Emotion
           module Runners
             module Gut
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def gut_instinct(valences:, memory_signals: [], confidence_threshold: 0.5, **)
                 return { signal: :neutral, confidence: 0.0, basis: :insufficient_data } if valences.empty?
@@ -20,8 +20,8 @@ module Legion
                 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}"
+                log.debug("[emotion] gut instinct: signal=#{signal} confidence=#{confidence.round(2)} " \
+                          "arousal=#{arousal.round(2)} dominant=#{dominant} reliable=#{confidence >= confidence_threshold}")
 
                 result = {
                   signal:     signal,
@@ -44,7 +44,7 @@ module Legion
                 momentum.update(neutral, 0.5)
                 stability = momentum.stability
 
-                Legion::Logging.debug "[emotion] momentum decay: stability=#{stability.round(2)}"
+                log.debug("[emotion] momentum decay: stability=#{stability.round(2)}")
 
                 { decayed: true, stability: stability }
               end
@@ -52,7 +52,7 @@ module Legion
               def emotional_state(**)
                 momentum = emotion_momentum
                 state = momentum.emotional_state
-                Legion::Logging.debug "[emotion] state query: stability=#{state[:stability]&.round(2)}"
+                log.debug("[emotion] state query: stability=#{state[:stability]&.round(2)}")
                 {
                   momentum: state,
                   baseline: emotion_baseline.dimensions
@@ -82,7 +82,7 @@ module Legion
               end
 
               def compute_confidence(valences, memory_signals)
-                return 0.0 if valences.empty?
+                return 0.0 if valences.empty? # rubocop:disable Legion/Extension/RunnerReturnHash
 
                 magnitudes = valences.map { |v| Helpers::Valence.magnitude(v) }
                 mean_mag = magnitudes.sum / magnitudes.size

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

@@ -7,8 +7,8 @@ module Legion
         module Emotion
           module Runners
             module Valence
-              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
-                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def evaluate_valence(signal:, source_type: :ambient, deadline: nil, domain: nil, **)
                 baseline = emotion_baseline
@@ -34,9 +34,9 @@ module Legion
 
                 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)}"
+                log.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,
@@ -50,7 +50,7 @@ module Legion
                 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}"
+                log.debug("[emotion] aggregate: count=#{valences.size} arousal=#{arousal.round(2)} dominant=#{dominant}")
                 {
                   aggregate: aggregated,
                   arousal:   arousal,
@@ -62,13 +62,13 @@ module Legion
               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)}"
+                log.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"
+                log.debug("[emotion] arousal=#{arousal.round(2)} from #{valences.size} valences")
                 { arousal: arousal }
               end
 
@@ -78,8 +78,8 @@ module Legion
                            outcome_severity: boost, novelty_score: 0.3 }
                 result = evaluate_valence(signal: signal, source_type: :mesh_priority)
 
-                Legion::Logging.info "[emotion] knowledge_vulnerability urgency raised: domains=#{Array(domains_at_risk).join(',')} " \
-                                     "severity=#{severity} boost=#{boost.round(2)} urgency=#{result[:valence][:urgency].round(2)}"
+                log.info("[emotion] knowledge_vulnerability urgency raised: domains=#{Array(domains_at_risk).join(',')} " \
+                         "severity=#{severity} boost=#{boost.round(2)} urgency=#{result[:valence][:urgency].round(2)}")
 
                 result.merge(event: :knowledge_vulnerability, domains_at_risk: Array(domains_at_risk), urgency_boost: boost)
               end

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

@@ -6,6 +6,7 @@ module Legion
       module Affect
         module Empathy
           class Client
+            include Legion::Extensions::Helpers::Lex
             include Runners::Empathy
 
             attr_reader :model_store