lex-agentic-affect 0.1.5 → 0.1.6

data/lib/legion/extensions/agentic/affect/regulation/runners/emotional_regulation.rb

@@ -7,8 +7,8 @@ module Legion
         module Regulation
           module Runners
             module EmotionalRegulation
-              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)
 
               # Apply emotion regulation. Auto-selects strategy when none is provided.
               def regulate_emotion(emotion_magnitude:, emotion_valence: :neutral, strategy: nil, **)
@@ -23,10 +23,10 @@ module Legion
                   strategy:          chosen
                 )
 
-                Legion::Logging.debug "[emotional_regulation] regulate: strategy=#{chosen} " \
-                                      "magnitude=#{emotion_magnitude.round(2)} -> " \
-                                      "#{result[:regulated_magnitude].round(2)} " \
-                                      "cost=#{result[:cost].round(3)} success=#{result[:success]}"
+                log.debug("[emotional_regulation] regulate: strategy=#{chosen} " \
+                          "magnitude=#{emotion_magnitude.round(2)} -> " \
+                          "#{result[:regulated_magnitude].round(2)} " \
+                          "cost=#{result[:cost].round(3)} success=#{result[:success]}")
 
                 { success: true }.merge(result)
               end
@@ -39,8 +39,8 @@ module Legion
                   context:           context
                 )
 
-                Legion::Logging.debug "[emotional_regulation] recommend: magnitude=#{emotion_magnitude.round(2)} " \
-                                      "context=#{context} recommended=#{result[:recommended]}"
+                log.debug("[emotional_regulation] recommend: magnitude=#{emotion_magnitude.round(2)} " \
+                          "context=#{context} recommended=#{result[:recommended]}")
 
                 { success: true }.merge(result)
               end
@@ -51,7 +51,7 @@ module Legion
                 ability = regulation_model.overall_regulation_ability
                 label   = regulation_model.regulation_label
 
-                Legion::Logging.debug "[emotional_regulation] decay tick: ability=#{ability.round(3)} label=#{label}"
+                log.debug("[emotional_regulation] decay tick: ability=#{ability.round(3)} label=#{label}")
 
                 { success: true, overall_ability: ability, regulation_label: label }
               end
@@ -62,7 +62,7 @@ module Legion
                   [strategy, regulation_model.skill_for(strategy)]
                 end
 
-                Legion::Logging.debug "[emotional_regulation] profile query: overall=#{regulation_model.overall_regulation_ability.round(3)}"
+                log.debug("[emotional_regulation] profile query: overall=#{regulation_model.overall_regulation_ability.round(3)}")
 
                 {
                   success:      true,
@@ -76,7 +76,7 @@ module Legion
               # Return recent regulation events.
               def regulation_history(count: 20, **)
                 events = regulation_model.regulation_history.last(count)
-                Legion::Logging.debug "[emotional_regulation] history: requested=#{count} returned=#{events.size}"
+                log.debug("[emotional_regulation] history: requested=#{count} returned=#{events.size}")
                 { success: true, events: events, count: events.size }
               end
 
@@ -100,7 +100,7 @@ module Legion
                   [strategy, { count: events.size, successes: events.count { |e| e[:success] } }]
                 end
 
-                Legion::Logging.debug "[emotional_regulation] stats: total=#{total} success_rate=#{(successes.to_f / total).round(2)}"
+                log.debug("[emotional_regulation] stats: total=#{total} success_rate=#{(successes.to_f / total).round(2)}")
 
                 {
                   success:            true,

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

@@ -11,6 +11,7 @@ module Legion
       module Affect
         module Resilience
           class Client
+            include Legion::Extensions::Helpers::Lex
             include Runners::Resilience
 
             attr_reader :adversity_tracker, :resilience_model

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

@@ -7,17 +7,17 @@ module Legion
         module Resilience
           module Runners
             module Resilience
-              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 update_resilience(tick_results: {}, **)
                 detect_adversities(tick_results)
                 recovery = adversity_tracker.tick_recovery
                 resilience_model.update_from_tracker(adversity_tracker)
 
-                Legion::Logging.debug "[resilience] active=#{recovery[:active_count]} " \
-                                      "resolved=#{recovery[:resolved_count]} " \
-                                      "composite=#{resilience_model.composite_score.round(3)}"
+                log.debug("[resilience] active=#{recovery[:active_count]} " \
+                          "resolved=#{recovery[:resolved_count]} " \
+                          "composite=#{resilience_model.composite_score.round(3)}")
 
                 {
                   active_adversities: recovery[:active_count],
@@ -33,13 +33,13 @@ module Legion
                 adversity = adversity_tracker.register(type: type, severity: severity, context: context)
                 return { success: false, error: 'invalid type or severity' } unless adversity
 
-                Legion::Logging.info "[resilience] adversity registered: type=#{type} severity=#{severity}"
+                log.info("[resilience] adversity registered: type=#{type} severity=#{severity}")
                 { success: true, adversity: adversity }
               end
 
               def resilience_status(**)
                 model_state = resilience_model.to_h
-                Legion::Logging.debug "[resilience] status: #{model_state[:class]} score=#{model_state[:composite]}"
+                log.debug("[resilience] status: #{model_state[:class]} score=#{model_state[:composite]}")
 
                 model_state.merge(
                   active_adversities:     adversity_tracker.active_adversities.size,
@@ -50,7 +50,7 @@ module Legion
               end
 
               def adversity_report(**)
-                Legion::Logging.debug '[resilience] adversity report'
+                log.debug('[resilience] adversity report')
 
                 {
                   active:    adversity_tracker.active_adversities,
@@ -65,12 +65,12 @@ module Legion
                 detail = resilience_model.dimension_detail(dimension.to_sym)
                 return { error: "unknown dimension: #{dimension}" } unless detail
 
-                Legion::Logging.debug "[resilience] dimension #{dimension}: #{detail[:value]}"
+                log.debug("[resilience] dimension #{dimension}: #{detail[:value]}")
                 detail
               end
 
               def resilience_stats(**)
-                Legion::Logging.debug '[resilience] stats'
+                log.debug('[resilience] stats')
 
                 {
                   composite:              resilience_model.composite_score.round(4),

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

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

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

@@ -43,7 +43,7 @@ module Legion
 
               def adjust_vigilance(amount:)
                 @vigilance = (@vigilance + amount).clamp(0.0, 1.0)
-                Legion::Logging.debug "[cognitive_resonance] vigilance adjusted to #{@vigilance.round(3)}"
+                Legion::Logging.debug("[cognitive_resonance] vigilance adjusted to #{@vigilance.round(3)}") # rubocop:disable Legion/HelperMigration/DirectLogging
                 @vigilance
               end
 
@@ -73,8 +73,10 @@ module Legion
               def resonate_with(match, normalized)
                 category = @categories[match[:id]]
                 category.update_prototype!(input: normalized)
-                Legion::Logging.debug "[cognitive_resonance] resonance with category #{match[:id][0..7]} " \
-                                      "quality=#{match[:quality].round(3)} vigilance=#{@vigilance.round(3)}"
+                # rubocop:disable Legion/HelperMigration/DirectLogging
+                Legion::Logging.debug("[cognitive_resonance] resonance with category #{match[:id][0..7]} " \
+                                      "quality=#{match[:quality].round(3)} vigilance=#{@vigilance.round(3)}")
+                # rubocop:enable Legion/HelperMigration/DirectLogging
                 {
                   outcome:     :resonance,
                   category_id: match[:id],
@@ -88,8 +90,10 @@ module Legion
                 prune_if_full!
                 category = Category.new(prototype: normalized)
                 @categories[category.id] = category
-                Legion::Logging.debug "[cognitive_resonance] new category #{category.id[0..7]} " \
-                                      "total=#{@categories.size} vigilance=#{@vigilance.round(3)}"
+                # rubocop:disable Legion/HelperMigration/DirectLogging
+                Legion::Logging.debug("[cognitive_resonance] new category #{category.id[0..7]} " \
+                                      "total=#{@categories.size} vigilance=#{@vigilance.round(3)}")
+                # rubocop:enable Legion/HelperMigration/DirectLogging
                 {
                   outcome:     :new_category,
                   category_id: category.id,
@@ -104,7 +108,7 @@ module Legion
 
                 oldest_id = @categories.min_by { |_, cat| cat.last_matched_at || Time.at(0) }.first
                 @categories.delete(oldest_id)
-                Legion::Logging.debug "[cognitive_resonance] pruned oldest category #{oldest_id[0..7]}"
+                Legion::Logging.debug("[cognitive_resonance] pruned oldest category #{oldest_id[0..7]}") # rubocop:disable Legion/HelperMigration/DirectLogging
               end
             end
           end

data/lib/legion/extensions/agentic/affect/resonance/runners/cognitive_resonance.rb

@@ -7,16 +7,16 @@ module Legion
         module Resonance
           module Runners
             module CognitiveResonance
-              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 present_input(input:, engine: nil, **)
                 resonance_engine = engine || default_engine
                 return { success: false, error: :empty_input } if input.nil? || input.empty?
 
                 result = resonance_engine.present_input(input: input)
-                Legion::Logging.debug "[cognitive_resonance] present_input outcome=#{result[:outcome]} " \
-                                      "category=#{result[:category_id][0..7]}"
+                log.debug("[cognitive_resonance] present_input outcome=#{result[:outcome]} " \
+                          "category=#{result[:category_id][0..7]}")
                 { success: true }.merge(result)
               end
 
@@ -29,8 +29,8 @@ module Legion
 
                 if match
                   quality_label = Helpers::Constants.match_label(match[:quality])
-                  Legion::Logging.debug "[cognitive_resonance] classify category=#{match[:id][0..7]} " \
-                                        "quality=#{match[:quality].round(3)} label=#{quality_label}"
+                  log.debug("[cognitive_resonance] classify category=#{match[:id][0..7]} " \
+                            "quality=#{match[:quality].round(3)} label=#{quality_label}")
                   {
                     success:     true,
                     found:       true,
@@ -39,7 +39,7 @@ module Legion
                     label:       quality_label
                   }
                 else
-                  Legion::Logging.debug '[cognitive_resonance] classify found=false (no categories)'
+                  log.debug('[cognitive_resonance] classify found=false (no categories)')
                   { success: true, found: false, category_id: nil, quality: 0.0, label: :none }
                 end
               end
@@ -50,7 +50,7 @@ module Legion
                 new_vigilance    = resonance_engine.adjust_vigilance(amount: clamped_amount)
                 vigilance_label  = Helpers::Constants.vigilance_label(new_vigilance)
 
-                Legion::Logging.debug "[cognitive_resonance] vigilance=#{new_vigilance.round(3)} label=#{vigilance_label}"
+                log.debug("[cognitive_resonance] vigilance=#{new_vigilance.round(3)} label=#{vigilance_label}")
                 {
                   success:         true,
                   vigilance:       new_vigilance,
@@ -62,21 +62,21 @@ module Legion
               def resonance_report(engine: nil, **)
                 resonance_engine = engine || default_engine
                 report = resonance_engine.resonance_report
-                Legion::Logging.debug "[cognitive_resonance] report categories=#{report[:category_count]} " \
-                                      "vigilance=#{report[:vigilance].round(3)}"
+                log.debug("[cognitive_resonance] report categories=#{report[:category_count]} " \
+                          "vigilance=#{report[:vigilance].round(3)}")
                 { success: true }.merge(report)
               end
 
               def category_count(engine: nil, **)
                 resonance_engine = engine || default_engine
                 count = resonance_engine.category_count
-                Legion::Logging.debug "[cognitive_resonance] category_count=#{count}"
+                log.debug("[cognitive_resonance] category_count=#{count}")
                 { success: true, count: count }
               end
 
               def reset_engine(**)
                 @default_engine = nil
-                Legion::Logging.debug '[cognitive_resonance] engine reset'
+                log.debug('[cognitive_resonance] engine reset')
                 { success: true, reset: true }
               end
 

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

@@ -11,6 +11,7 @@ module Legion
       module Affect
         module Reward
           class Client
+            include Legion::Extensions::Helpers::Lex
             include Runners::Reward
 
             attr_reader :reward_store

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

@@ -7,14 +7,14 @@ module Legion
         module Reward
           module Runners
             module Reward
-              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 compute_reward(tick_results: {}, **)
                 result = reward_store.process_tick(tick_results)
 
-                Legion::Logging.debug "[reward] reward=#{result[:reward]} rpe=#{result[:rpe]} " \
-                                      "class=#{result[:rpe_class]} learning=#{result[:learning_signal]}"
+                log.debug("[reward] reward=#{result[:reward]} rpe=#{result[:rpe]} " \
+                          "class=#{result[:rpe_class]} learning=#{result[:learning_signal]}")
 
                 result
               end
@@ -23,21 +23,21 @@ module Legion
                 sig = reward_store.signal
                 health = reward_store.health_assessment
 
-                Legion::Logging.debug "[reward] status: avg=#{sig.running_average.round(3)} " \
-                                      "predicted=#{sig.predicted_reward.round(3)} health=#{health[:status]}"
+                log.debug("[reward] status: avg=#{sig.running_average.round(3)} " \
+                          "predicted=#{sig.predicted_reward.round(3)} health=#{health[:status]}")
 
                 sig.to_h.merge(health: health)
               end
 
               def reward_for(domain:, **)
                 report = reward_store.domain_report(domain)
-                Legion::Logging.debug "[reward] domain=#{domain} avg=#{report[:average].round(3)} trend=#{report[:trend]}"
+                log.debug("[reward] domain=#{domain} avg=#{report[:average].round(3)} trend=#{report[:trend]}")
                 report
               end
 
               def reward_history(limit: 20, **)
                 recent = reward_store.signal.recent_rewards(limit)
-                Legion::Logging.debug "[reward] history: #{recent.size} entries"
+                log.debug("[reward] history: #{recent.size} entries")
 
                 {
                   history:           recent,
@@ -48,7 +48,7 @@ module Legion
 
               def domain_rewards(**)
                 averages = reward_store.all_domain_averages
-                Legion::Logging.debug "[reward] domains: #{averages.size} tracked"
+                log.debug("[reward] domains: #{averages.size} tracked")
 
                 {
                   domains:      averages,
@@ -62,7 +62,7 @@ module Legion
                 sig = reward_store.signal
                 health = reward_store.health_assessment
 
-                Legion::Logging.debug '[reward] stats'
+                log.debug('[reward] stats')
 
                 {
                   running_average:   sig.running_average.round(4),

data/lib/legion/extensions/agentic/affect/somatic_marker/actors/decay.rb

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

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

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

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

@@ -7,51 +7,51 @@ module Legion
         module SomaticMarker
           module Runners
             module SomaticMarker
-              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_marker(action:, domain:, valence:, source: :experience, **)
                 marker = store.register_marker(action: action, domain: domain, valence: valence, source: source)
-                Legion::Logging.debug "[somatic_marker] register: action=#{action} domain=#{domain} " \
-                                      "valence=#{valence.round(3)} source=#{source} id=#{marker.id}"
+                log.debug("[somatic_marker] register: action=#{action} domain=#{domain} " \
+                          "valence=#{valence.round(3)} source=#{source} id=#{marker.id}")
                 { success: true, marker: marker.to_h }
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] register failed: #{e.message}"
+                log.error("[somatic_marker] register failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def evaluate_option(action:, domain:, **)
                 result = store.evaluate_option(action: action, domain: domain)
-                Legion::Logging.debug "[somatic_marker] evaluate: action=#{action} domain=#{domain} " \
-                                      "signal=#{result[:signal]} valence=#{result[:valence].round(3)}"
+                log.debug("[somatic_marker] evaluate: action=#{action} domain=#{domain} " \
+                          "signal=#{result[:signal]} valence=#{result[:valence].round(3)}")
                 { success: true }.merge(result)
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] evaluate failed: #{e.message}"
+                log.error("[somatic_marker] evaluate failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def make_decision(options:, domain:, **)
                 result = store.decide(options: options, domain: domain)
-                Legion::Logging.debug "[somatic_marker] decide: domain=#{domain} options=#{options.size} " \
-                                      "top=#{result[:ranked].first&.fetch(:action)}"
+                log.debug("[somatic_marker] decide: domain=#{domain} options=#{options.size} " \
+                          "top=#{result[:ranked].first&.fetch(:action)}")
                 { success: true, decision: result }
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] decide failed: #{e.message}"
+                log.error("[somatic_marker] decide failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def reinforce(marker_id:, outcome_valence:, **)
                 marker = store.reinforce_marker(marker_id: marker_id, outcome_valence: outcome_valence)
                 unless marker
-                  Legion::Logging.debug "[somatic_marker] reinforce: marker_id=#{marker_id} not found"
+                  log.debug("[somatic_marker] reinforce: marker_id=#{marker_id} not found")
                   return { success: false, error: 'marker not found' }
                 end
 
-                Legion::Logging.debug "[somatic_marker] reinforce: id=#{marker_id} " \
-                                      "outcome=#{outcome_valence.round(3)} new_valence=#{marker.valence.round(3)}"
+                log.debug("[somatic_marker] reinforce: id=#{marker_id} " \
+                          "outcome=#{outcome_valence.round(3)} new_valence=#{marker.valence.round(3)}")
                 { success: true, marker: marker.to_h }
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] reinforce failed: #{e.message}"
+                log.error("[somatic_marker] reinforce failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
@@ -62,59 +62,59 @@ module Legion
                   comfort:    comfort,
                   gut_signal: gut_signal
                 )
-                Legion::Logging.debug "[somatic_marker] body_update: composite=#{state.composite_valence.round(3)} " \
-                                      "stressed=#{state.stressed?}"
+                log.debug("[somatic_marker] body_update: composite=#{state.composite_valence.round(3)} " \
+                          "stressed=#{state.stressed?}")
                 { success: true, body_state: state.to_h }
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] body update failed: #{e.message}"
+                log.error("[somatic_marker] body update failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def body_state(**)
                 state = store.body_state
-                Legion::Logging.debug "[somatic_marker] body_state: composite=#{state.composite_valence.round(3)}"
+                log.debug("[somatic_marker] body_state: composite=#{state.composite_valence.round(3)}")
                 { success: true, body_state: state.to_h }
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] body_state failed: #{e.message}"
+                log.error("[somatic_marker] body_state failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def markers_for_action(action:, domain:, **)
                 markers = store.markers_for(action: action, domain: domain)
-                Legion::Logging.debug "[somatic_marker] markers_for: action=#{action} domain=#{domain} " \
-                                      "count=#{markers.size}"
+                log.debug("[somatic_marker] markers_for: action=#{action} domain=#{domain} " \
+                          "count=#{markers.size}")
                 { success: true, markers: markers.map(&:to_h), count: markers.size }
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] markers_for_action failed: #{e.message}"
+                log.error("[somatic_marker] markers_for_action failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def recent_decisions(limit: 10, **)
                 decisions = store.decision_history(limit: limit)
-                Legion::Logging.debug "[somatic_marker] recent_decisions: limit=#{limit} count=#{decisions.size}"
+                log.debug("[somatic_marker] recent_decisions: limit=#{limit} count=#{decisions.size}")
                 { success: true, decisions: decisions, count: decisions.size }
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] recent_decisions failed: #{e.message}"
+                log.error("[somatic_marker] recent_decisions failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def update_somatic_markers(**)
                 result = store.decay_all
-                Legion::Logging.debug "[somatic_marker] decay: remaining=#{result[:markers_decayed]} " \
-                                      "removed=#{result[:markers_removed]}"
+                log.debug("[somatic_marker] decay: remaining=#{result[:markers_decayed]} " \
+                          "removed=#{result[:markers_removed]}")
                 { success: true }.merge(result)
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] decay failed: #{e.message}"
+                log.error("[somatic_marker] decay failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
               def somatic_marker_stats(**)
                 stats = store.to_h
-                Legion::Logging.debug "[somatic_marker] stats: markers=#{stats[:marker_count]} " \
-                                      "decisions=#{stats[:decision_count]}"
+                log.debug("[somatic_marker] stats: markers=#{stats[:marker_count]} " \
+                          "decisions=#{stats[:decision_count]}")
                 { success: true }.merge(stats)
               rescue StandardError => e
-                Legion::Logging.error "[somatic_marker] stats failed: #{e.message}"
+                log.error("[somatic_marker] stats failed: #{e.message}")
                 { success: false, error: e.message }
               end
 

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Affect
-        VERSION = '0.1.5'
+        VERSION = '0.1.6'
       end
     end
   end

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

@@ -23,7 +23,7 @@ module Legion
   module Extensions
     module Agentic
       module Affect
-        extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+        extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core, false
 
         def self.remote_invocable?
           false

data/spec/legion/extensions/agentic/affect/somatic_marker/helpers/marker_store_spec.rb

@@ -107,7 +107,7 @@ RSpec.describe Legion::Extensions::Agentic::Affect::SomaticMarker::Helpers::Mark
 
     it 'caps options at MAX_OPTIONS_PER_DECISION' do
       max = Legion::Extensions::Agentic::Affect::SomaticMarker::Helpers::Constants::MAX_OPTIONS_PER_DECISION
-      options = (max + 5).times.map { |i| :"option_#{i}" }
+      options = Array.new(max + 5) { |i| :"option_#{i}" }
       result = store.decide(options: options, domain: :ops)
       expect(result[:ranked].size).to eq(max)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-affect
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Esity