lex-agentic-memory 0.1.16 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53ea02bfdd236c2e64023525d767a238c9dfa28d96db8993cee882a2105bcccb
-  data.tar.gz: 442b45ad5cdacc49197156b364db727cdabbb0ebf2f30881f823b7b04f776871
+  metadata.gz: fb1bf71d34f865e24372a5bc7f5c8f47d692ec141de8bb40fe5c96269aa78fc9
+  data.tar.gz: bc392262705eddec3f4e122b1afb79a6e25da73b20497b508778a95dc6b01d61
 SHA512:
-  metadata.gz: f6c3ce2299ecd503a25069b865c7e68db33de87b90d4419879a45810119b92310f1816d140baf082014cf3bbcc920b9bc52342154db1c9db132b8ad6ba91fa0b
-  data.tar.gz: b2712151eae4cf64f51bfa92792210e4200b84c0c0caa71830d4361470fe6f38d04c2775d6cd1faba777180499fdef18120946d1e8a3b37e60262db7be241d2b
+  metadata.gz: 97ff50ebc6ae1c740d8041b808f2186e23d78dc055d498bd2eda2e527d46f8de85af5ddb2069553e6c9cbdfa5021ea09302713277352efe9c973bc449fd4a0fd
+  data.tar.gz: 5990cbe7a015dcfe0d702318d859592dc85245fc8b2dd3b589f6bc7af54bf40954e7b776a01b5fe6c7688fe51bcb06d0de1b1a8390684111386d4d9c92ee38d2

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.1.17] - 2026-03-30
+
+### Changed
+- update to rubocop-legion 0.1.7, resolve all offenses
+
 ## [0.1.16] - 2026-03-29
 
 ### Fixed

data/lex-agentic-memory.gemspec

@@ -35,5 +35,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'rspec', '~> 3.13'
   spec.add_development_dependency 'rubocop', '~> 1.60'
+  spec.add_development_dependency 'rubocop-legion', '~> 0.1'
   spec.add_development_dependency 'rubocop-rspec', '~> 2.26'
 end

data/lib/legion/extensions/agentic/memory/archaeology/actors/decay.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Memory
         module Archaeology
-          module Actors
+          module Actor
             class Decay < Legion::Extensions::Actors::Every
               def runner_class = Runners::CognitiveArchaeology
               def runner_function = 'decay_all'

data/lib/legion/extensions/agentic/memory/compression/actors/maintenance.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Memory
         module Compression
-          module Actors
+          module Actor
             class Maintenance < Legion::Extensions::Actors::Every
               def runner_class = Runners::CognitiveCompression
               def runner_function = 'compress_all'

data/lib/legion/extensions/agentic/memory/echo/actors/decay.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Memory
         module Echo
-          module Actors
+          module Actor
             class Decay < Legion::Extensions::Actors::Every
               def runner_class = Runners::CognitiveEcho
               def runner_function = 'decay_all'

data/lib/legion/extensions/agentic/memory/echo_chamber/actors/decay.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Memory
         module EchoChamber
-          module Actors
+          module Actor
             class Decay < Legion::Extensions::Actors::Every
               def runner_class = Runners::CognitiveEchoChamber
               def runner_function = 'decay_all'

data/lib/legion/extensions/agentic/memory/echo_chamber/runners/cognitive_echo_chamber.rb

@@ -21,7 +21,7 @@ module Legion
                   source_agent: source_agent,
                   amplitude:    amplitude
                 )
-                Legion::Logging.debug "[cognitive_echo_chamber] echo created id=#{echo.id} type=#{echo_type} domain=#{domain}"
+                log.debug("[cognitive_echo_chamber] echo created id=#{echo.id} type=#{echo_type} domain=#{domain}")
                 { success: true, echo: echo.to_h }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -32,7 +32,7 @@ module Legion
 
                 eng     = engine || default_engine
                 chamber = eng.create_chamber(label: label, domain: domain, wall_thickness: wall_thickness)
-                Legion::Logging.debug "[cognitive_echo_chamber] chamber created id=#{chamber.id} label=#{label}"
+                log.debug("[cognitive_echo_chamber] chamber created id=#{chamber.id} label=#{label}")
                 { success: true, chamber: chamber.to_h }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -43,14 +43,14 @@ module Legion
                 echo = eng.amplify_echo(echo_id: echo_id, rate: rate)
                 return { success: false, error: 'echo not found' } unless echo
 
-                Legion::Logging.debug "[cognitive_echo_chamber] amplified echo=#{echo_id} amplitude=#{echo.amplitude}"
+                log.debug("[cognitive_echo_chamber] amplified echo=#{echo_id} amplitude=#{echo.amplitude}")
                 { success: true, echo: echo.to_h }
               end
 
               def disrupt(chamber_id:, force:, engine: nil, **)
                 eng    = engine || default_engine
                 result = eng.disrupt_chamber(chamber_id: chamber_id, force: force)
-                Legion::Logging.debug "[cognitive_echo_chamber] disrupt chamber=#{chamber_id} success=#{result[:success]}"
+                log.debug("[cognitive_echo_chamber] disrupt chamber=#{chamber_id} success=#{result[:success]}")
                 result
               end
 

data/lib/legion/extensions/agentic/memory/episodic/runners/episodic_buffer.rb

@@ -10,7 +10,7 @@ module Legion
               def create_episode(**)
                 store = default_store
                 episode = store.create_episode
-                Legion::Logging.debug "[episodic_buffer] created episode id=#{episode.id[0..7]}"
+                log.debug("[episodic_buffer] created episode id=#{episode.id[0..7]}")
                 { success: true, episode_id: episode.id, created_at: episode.created_at }
               end
 
@@ -28,10 +28,10 @@ module Legion
                 )
 
                 if result[:added]
-                  Legion::Logging.debug "[episodic_buffer] add_binding ep=#{episode_id[0..7]} mod=#{modality}"
+                  log.debug("[episodic_buffer] add_binding ep=#{episode_id[0..7]} mod=#{modality}")
                   { success: true, episode_id: episode_id, binding_id: result[:binding_id] }
                 else
-                  Legion::Logging.debug "[episodic_buffer] add_binding failed ep=#{episode_id[0..7]} r=#{result[:reason]}"
+                  log.debug("[episodic_buffer] add_binding failed ep=#{episode_id[0..7]} r=#{result[:reason]}")
                   { success: false, episode_id: episode_id, reason: result[:reason] }
                 end
               end
@@ -39,56 +39,56 @@ module Legion
               def attend_episode(episode_id:, **)
                 store  = default_store
                 result = store.attend_episode(episode_id: episode_id)
-                Legion::Logging.debug "[episodic_buffer] attend ep=#{episode_id[0..7]} success=#{result[:success]}"
+                log.debug("[episodic_buffer] attend ep=#{episode_id[0..7]} success=#{result[:success]}")
                 result.merge(success: result[:success])
               end
 
               def rehearse_episode(episode_id:, **)
                 store  = default_store
                 result = store.rehearse_episode(episode_id: episode_id)
-                Legion::Logging.debug "[episodic_buffer] rehearse ep=#{episode_id[0..7]} success=#{result[:success]}"
+                log.debug("[episodic_buffer] rehearse ep=#{episode_id[0..7]} success=#{result[:success]}")
                 result.merge(success: result[:success])
               end
 
               def check_integration(episode_id:, **)
                 store  = default_store
                 result = store.integrate(episode_id: episode_id)
-                Legion::Logging.debug "[episodic_buffer] check_integration ep=#{episode_id[0..7]} ok=#{result[:integrated]}"
+                log.debug("[episodic_buffer] check_integration ep=#{episode_id[0..7]} ok=#{result[:integrated]}")
                 result.merge(success: true)
               end
 
               def retrieve_by_modality(modality:, **)
                 store    = default_store
                 episodes = store.retrieve_by_modality(modality: modality.to_sym)
-                Legion::Logging.debug "[episodic_buffer] retrieve_by_modality mod=#{modality} count=#{episodes.size}"
+                log.debug("[episodic_buffer] retrieve_by_modality mod=#{modality} count=#{episodes.size}")
                 { success: true, modality: modality, count: episodes.size, episodes: episodes.map(&:to_h) }
               end
 
               def retrieve_multimodal(**)
                 store    = default_store
                 episodes = store.retrieve_multimodal
-                Legion::Logging.debug "[episodic_buffer] retrieve_multimodal count=#{episodes.size}"
+                log.debug("[episodic_buffer] retrieve_multimodal count=#{episodes.size}")
                 { success: true, count: episodes.size, episodes: episodes.map(&:to_h) }
               end
 
               def most_coherent(limit: 5, **)
                 store    = default_store
                 episodes = store.most_coherent(limit: limit)
-                Legion::Logging.debug "[episodic_buffer] most_coherent limit=#{limit} returned=#{episodes.size}"
+                log.debug("[episodic_buffer] most_coherent limit=#{limit} returned=#{episodes.size}")
                 { success: true, count: episodes.size, episodes: episodes.map(&:to_h) }
               end
 
               def update_episodic_buffer(**)
                 store  = default_store
                 result = store.tick
-                Legion::Logging.debug "[episodic_buffer] tick decayed=#{result[:decayed]} expired=#{result[:expired]}"
+                log.debug("[episodic_buffer] tick decayed=#{result[:decayed]} expired=#{result[:expired]}")
                 { success: true }.merge(result)
               end
 
               def episodic_buffer_stats(**)
                 store = default_store
                 stats = store.to_h
-                Legion::Logging.debug "[episodic_buffer] stats episodes=#{stats[:episode_count]}"
+                log.debug("[episodic_buffer] stats episodes=#{stats[:episode_count]}")
                 { success: true }.merge(stats)
               end
 

data/lib/legion/extensions/agentic/memory/hologram/runners/cognitive_hologram.rb

@@ -7,8 +7,8 @@ module Legion
         module Hologram
           module Runners
             module CognitiveHologram
-              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(domain: :general, content: '', engine: nil, **)
                 raise ArgumentError, 'content cannot be empty' if content.to_s.strip.empty?
@@ -16,11 +16,11 @@ module Legion
                 target_engine = engine || default_engine
                 hologram = target_engine.create_hologram(domain: domain, content: content)
 
-                Legion::Logging.debug "[cognitive_hologram] created hologram: domain=#{domain} id=#{hologram.id}"
+                log.debug("[cognitive_hologram] created hologram: domain=#{domain} id=#{hologram.id}")
 
                 { success: true, hologram: hologram.to_h }
               rescue StandardError => e
-                Legion::Logging.error "[cognitive_hologram] create failed: #{e.message}"
+                log.error("[cognitive_hologram] create failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
@@ -29,14 +29,14 @@ module Legion
                 fragments = target_engine.fragment_hologram(hologram_id: hologram_id, count: count)
 
                 unless fragments
-                  Legion::Logging.warn "[cognitive_hologram] fragment: hologram not found id=#{hologram_id}"
+                  log.warn("[cognitive_hologram] fragment: hologram not found id=#{hologram_id}")
                   return { success: false, reason: :hologram_not_found }
                 end
 
-                Legion::Logging.debug "[cognitive_hologram] fragmented hologram id=#{hologram_id} count=#{fragments.size}"
+                log.debug("[cognitive_hologram] fragmented hologram id=#{hologram_id} count=#{fragments.size}")
                 { success: true, fragment_count: fragments.size, fragments: fragments.map(&:to_h) }
               rescue StandardError => e
-                Legion::Logging.error "[cognitive_hologram] fragment failed: #{e.message}"
+                log.error("[cognitive_hologram] fragment failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
@@ -47,12 +47,12 @@ module Legion
                   fragment_ids: fragment_ids
                 )
 
-                Legion::Logging.debug "[cognitive_hologram] reconstruct hologram=#{hologram_id} " \
-                                      "fragments=#{fragment_ids.size} success=#{result[:success]}"
+                log.debug("[cognitive_hologram] reconstruct hologram=#{hologram_id} " \
+                          "fragments=#{fragment_ids.size} success=#{result[:success]}")
 
                 result.merge(success: result[:success])
               rescue StandardError => e
-                Legion::Logging.error "[cognitive_hologram] reconstruct failed: #{e.message}"
+                log.error("[cognitive_hologram] reconstruct failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
@@ -60,10 +60,10 @@ module Legion
                 target_engine = engine || default_engine
                 holograms = target_engine.holograms.first(limit)
 
-                Legion::Logging.debug "[cognitive_hologram] list_holograms: count=#{holograms.size} limit=#{limit}"
+                log.debug("[cognitive_hologram] list_holograms: count=#{holograms.size} limit=#{limit}")
                 { success: true, holograms: holograms.map(&:to_h), count: holograms.size }
               rescue StandardError => e
-                Legion::Logging.error "[cognitive_hologram] list_holograms failed: #{e.message}"
+                log.error("[cognitive_hologram] list_holograms failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
@@ -74,12 +74,12 @@ module Legion
                   hologram_id_b: hologram_id_b
                 )
 
-                Legion::Logging.debug '[cognitive_hologram] interference_check: ' \
-                                      "a=#{hologram_id_a} b=#{hologram_id_b} score=#{result[:interference]}"
+                log.debug('[cognitive_hologram] interference_check: ' \
+                          "a=#{hologram_id_a} b=#{hologram_id_b} score=#{result[:interference]}")
 
                 result.merge(success: true)
               rescue StandardError => e
-                Legion::Logging.error "[cognitive_hologram] interference_check failed: #{e.message}"
+                log.error("[cognitive_hologram] interference_check failed: #{e.message}")
                 { success: false, error: e.message }
               end
 
@@ -87,12 +87,12 @@ module Legion
                 target_engine = engine || default_engine
                 report = target_engine.hologram_report
 
-                Legion::Logging.debug "[cognitive_hologram] status: total=#{report[:total_holograms]} " \
-                                      "avg_resolution=#{report[:average_resolution].round(2)}"
+                log.debug("[cognitive_hologram] status: total=#{report[:total_holograms]} " \
+                          "avg_resolution=#{report[:average_resolution].round(2)}")
 
                 { success: true, report: report }
               rescue StandardError => e
-                Legion::Logging.error "[cognitive_hologram] hologram_status failed: #{e.message}"
+                log.error("[cognitive_hologram] hologram_status failed: #{e.message}")
                 { success: false, error: e.message }
               end
 

data/lib/legion/extensions/agentic/memory/immune_memory/actors/decay.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Memory
         module ImmuneMemory
-          module Actors
+          module Actor
             class Decay < Legion::Extensions::Actors::Every
               def runner_class = Runners::CognitiveImmuneMemory
               def runner_function = 'decay_all'

data/lib/legion/extensions/agentic/memory/nostalgia/actors/maintenance.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Memory
         module Nostalgia
-          module Actors
+          module Actor
             class Maintenance < Legion::Extensions::Actors::Every
               def runner_class = Runners::Recall
               def runner_function = 'age_memories'

data/lib/legion/extensions/agentic/memory/nostalgia/helpers/nostalgia_engine.rb

@@ -31,7 +31,7 @@ module Legion
                 candidates = find_candidates(domain, trigger)
                 return [] if candidates.empty?
 
-                new_events = candidates.map do |memory|
+                new_events = candidates.filter_map do |memory|
                   intensity = compute_intensity(memory, intensity_hint)
                   next unless intensity >= Constants::TRIGGER_SENSITIVITY
 
@@ -44,7 +44,7 @@ module Legion
                   memory.warm!(intensity * 0.1)
                   @events << event
                   event
-                end.compact
+                end
 
                 @events.shift while @events.size > Constants::MAX_EVENTS
                 new_events

data/lib/legion/extensions/agentic/memory/nostalgia/runners/analysis.rb

@@ -7,13 +7,13 @@ module Legion
         module Nostalgia
           module Runners
             module Analysis
-              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 warmth_by_domain(engine: nil, **)
                 eng = engine || nostalgia_engine
                 by_domain = eng.warmth_by_domain
-                Legion::Logging.debug "[cognitive_nostalgia] warmth_by_domain: #{by_domain.size} domains"
+                log.debug("[cognitive_nostalgia] warmth_by_domain: #{by_domain.size} domains")
                 { success: true, warmth_by_domain: by_domain }
               end
 
@@ -21,7 +21,7 @@ module Legion
                 eng = engine || nostalgia_engine
                 index = eng.rosy_retrospection_index
                 label = Helpers::Constants.label_for(Helpers::Constants::RETROSPECTION_LABELS, index)
-                Legion::Logging.debug "[cognitive_nostalgia] rosy_retrospection_index=#{index.round(2)} label=#{label}"
+                log.debug("[cognitive_nostalgia] rosy_retrospection_index=#{index.round(2)} label=#{label}")
                 { success: true, index: index, label: label }
               end
 
@@ -29,21 +29,21 @@ module Legion
                 eng = engine || nostalgia_engine
                 proneness = eng.nostalgia_proneness
                 label = Helpers::Constants.label_for(Helpers::Constants::NOSTALGIA_LABELS, proneness)
-                Legion::Logging.debug "[cognitive_nostalgia] nostalgia_proneness=#{proneness.round(2)} label=#{label}"
+                log.debug("[cognitive_nostalgia] nostalgia_proneness=#{proneness.round(2)} label=#{label}")
                 { success: true, proneness: proneness, label: label }
               end
 
               def most_nostalgic_domains(engine: nil, **)
                 eng = engine || nostalgia_engine
                 domains = eng.most_nostalgic_domains
-                Legion::Logging.debug "[cognitive_nostalgia] most_nostalgic_domains: top=#{domains.first&.fetch(:domain, :none)}"
+                log.debug("[cognitive_nostalgia] most_nostalgic_domains: top=#{domains.first&.fetch(:domain, :none)}")
                 { success: true, domains: domains }
               end
 
               def bittersweet_memories(engine: nil, **)
                 eng = engine || nostalgia_engine
                 memories = eng.bittersweet_memories
-                Legion::Logging.debug "[cognitive_nostalgia] bittersweet_memories: count=#{memories.size}"
+                log.debug("[cognitive_nostalgia] bittersweet_memories: count=#{memories.size}")
                 { success: true, memories: memories, count: memories.size }
               end
 

data/lib/legion/extensions/agentic/memory/nostalgia/runners/recall.rb

@@ -7,8 +7,8 @@ module Legion
         module Nostalgia
           module Runners
             module Recall
-              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 store_memory(content:, domain: :unknown, warmth: Helpers::Constants::DEFAULT_WARMTH,
                                original_valence: 0.5, engine: nil, **)
@@ -19,21 +19,21 @@ module Legion
                   warmth:           warmth,
                   original_valence: original_valence
                 )
-                Legion::Logging.debug "[cognitive_nostalgia] stored memory id=#{memory.id} domain=#{memory.domain} warmth=#{memory.warmth.round(2)}"
+                log.debug("[cognitive_nostalgia] stored memory id=#{memory.id} domain=#{memory.domain} warmth=#{memory.warmth.round(2)}")
                 { success: true, memory: memory.to_h }
               end
 
               def trigger_nostalgia(trigger:, domain: nil, intensity_hint: nil, engine: nil, **)
                 eng = engine || nostalgia_engine
                 events = eng.trigger_nostalgia(trigger: trigger, domain: domain, intensity_hint: intensity_hint)
-                Legion::Logging.debug "[cognitive_nostalgia] triggered nostalgia: trigger=#{trigger} events=#{events.size}"
+                log.debug("[cognitive_nostalgia] triggered nostalgia: trigger=#{trigger} events=#{events.size}")
                 { success: true, events: events.map(&:to_h), count: events.size }
               end
 
               def age_memories(engine: nil, **)
                 eng = engine || nostalgia_engine
                 eng.age_all!
-                Legion::Logging.debug "[cognitive_nostalgia] aged #{eng.memories.size} memories"
+                log.debug("[cognitive_nostalgia] aged #{eng.memories.size} memories")
                 { success: true, memory_count: eng.memories.size }
               end
 
@@ -42,7 +42,7 @@ module Legion
                 report = eng.nostalgia_report
                 idx = report[:rosy_retrospection_index].round(2)
                 pro = report[:nostalgia_proneness].round(2)
-                Legion::Logging.debug "[cognitive_nostalgia] report: index=#{idx} proneness=#{pro}"
+                log.debug("[cognitive_nostalgia] report: index=#{idx} proneness=#{pro}")
                 { success: true, **report }
               end
 

data/lib/legion/extensions/agentic/memory/offloading/runners/cognitive_offloading.rb

@@ -7,17 +7,17 @@ module Legion
         module Offloading
           module Runners
             module CognitiveOffloading
-              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_store(name:, store_type:, engine: nil, **)
                 eng = engine || offloading_engine
                 store = eng.register_store(name: name, store_type: store_type)
                 if store
-                  Legion::Logging.info "[cognitive_offloading] registered store name=#{name} type=#{store_type} id=#{store.id}"
+                  log.info("[cognitive_offloading] registered store name=#{name} type=#{store_type} id=#{store.id}")
                   { success: true, store: store.to_h }
                 else
-                  Legion::Logging.warn '[cognitive_offloading] register_store failed: limit reached or invalid store_type'
+                  log.warn('[cognitive_offloading] register_store failed: limit reached or invalid store_type')
                   { success: false, reason: :limit_reached }
                 end
               end
@@ -26,10 +26,10 @@ module Legion
                 eng = engine || offloading_engine
                 item = eng.offload(content: content, item_type: item_type, importance: importance, store_id: store_id)
                 if item
-                  Legion::Logging.info "[cognitive_offloading] offloaded item=#{item.id} type=#{item_type} importance=#{importance.round(2)} store=#{store_id}"
+                  log.info("[cognitive_offloading] offloaded item=#{item.id} type=#{item_type} importance=#{importance.round(2)} store=#{store_id}")
                   { success: true, item: item.to_h }
                 else
-                  Legion::Logging.warn "[cognitive_offloading] offload failed: limit reached or store not found store_id=#{store_id}"
+                  log.warn("[cognitive_offloading] offload failed: limit reached or store not found store_id=#{store_id}")
                   { success: false, reason: :offload_failed }
                 end
               end
@@ -38,10 +38,10 @@ module Legion
                 eng = engine || offloading_engine
                 item = eng.retrieve(item_id: item_id)
                 if item
-                  Legion::Logging.debug "[cognitive_offloading] retrieved item=#{item_id} count=#{item.retrieved_count}"
+                  log.debug("[cognitive_offloading] retrieved item=#{item_id} count=#{item.retrieved_count}")
                   { success: true, item: item.to_h }
                 else
-                  Legion::Logging.warn "[cognitive_offloading] retrieve failed: item not found item_id=#{item_id}"
+                  log.warn("[cognitive_offloading] retrieve failed: item not found item_id=#{item_id}")
                   { success: false, reason: :not_found }
                 end
               end
@@ -52,7 +52,7 @@ module Legion
                 if item
                   store = eng.stores[item.store_id]
                   trust = store&.trust&.round(2)
-                  Legion::Logging.warn "[cognitive_offloading] retrieval failure item=#{item_id} store_trust=#{trust}"
+                  log.warn("[cognitive_offloading] retrieval failure item=#{item_id} store_trust=#{trust}")
                   { success: true, item_id: item_id, store_trust: trust }
                 else
                   { success: false, reason: :not_found }
@@ -62,21 +62,21 @@ module Legion
               def items_in_store(store_id:, engine: nil, **)
                 eng = engine || offloading_engine
                 items = eng.items_in_store(store_id: store_id)
-                Legion::Logging.debug "[cognitive_offloading] items_in_store store=#{store_id} count=#{items.size}"
+                log.debug("[cognitive_offloading] items_in_store store=#{store_id} count=#{items.size}")
                 { success: true, items: items.map(&:to_h), count: items.size }
               end
 
               def items_by_type(item_type:, engine: nil, **)
                 eng = engine || offloading_engine
                 items = eng.items_by_type(item_type: item_type)
-                Legion::Logging.debug "[cognitive_offloading] items_by_type type=#{item_type} count=#{items.size}"
+                log.debug("[cognitive_offloading] items_by_type type=#{item_type} count=#{items.size}")
                 { success: true, items: items.map(&:to_h), count: items.size }
               end
 
               def most_important_offloaded(limit: 10, engine: nil, **)
                 eng = engine || offloading_engine
                 items = eng.most_important_offloaded(limit: limit)
-                Legion::Logging.debug "[cognitive_offloading] most_important limit=#{limit} count=#{items.size}"
+                log.debug("[cognitive_offloading] most_important limit=#{limit} count=#{items.size}")
                 { success: true, items: items.map(&:to_h), count: items.size }
               end
 
@@ -84,7 +84,7 @@ module Legion
                 eng = engine || offloading_engine
                 report = eng.offloading_report
                 ratio = report[:offloading_ratio]
-                Legion::Logging.debug "[cognitive_offloading] status items=#{report[:total_items]} stores=#{report[:total_stores]} ratio=#{ratio}"
+                log.debug("[cognitive_offloading] status items=#{report[:total_items]} stores=#{report[:total_stores]} ratio=#{ratio}")
                 { success: true, report: report }
               end
 

data/lib/legion/extensions/agentic/memory/palimpsest/actors/decay.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Memory
         module Palimpsest
-          module Actors
+          module Actor
             class Decay < Legion::Extensions::Actors::Every
               def runner_class = Runners::CognitivePalimpsest
               def runner_function = 'decay_all_ghosts'

data/lib/legion/extensions/agentic/memory/reserve/actors/maintenance.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Memory
         module Reserve
-          module Actors
+          module Actor
             class Maintenance < Legion::Extensions::Actors::Every
               def runner_class = Runners::CognitiveReserve
               def runner_function = 'update_cognitive_reserve'

data/lib/legion/extensions/agentic/memory/semantic/runners/semantic_memory.rb

@@ -7,68 +7,68 @@ module Legion
         module Semantic
           module Runners
             module SemanticMemory
-              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 store_concept(name:, domain: :general, confidence: nil, properties: {}, **)
                 concept = knowledge_store.store(name: name, domain: domain, confidence: confidence, properties: properties)
-                Legion::Logging.debug "[semantic_memory] store: name=#{name} domain=#{domain} conf=#{concept.confidence.round(3)}"
+                log.debug("[semantic_memory] store: name=#{name} domain=#{domain} conf=#{concept.confidence.round(3)}")
                 { success: true, concept: concept.to_h }
               end
 
               def relate_concepts(source:, target:, type:, confidence: nil, **)
                 type_sym = type.to_sym
                 result = knowledge_store.relate(source: source, target: target, type: type_sym, confidence: confidence)
-                Legion::Logging.debug "[semantic_memory] relate: #{source} --#{type_sym}--> #{target}"
+                log.debug("[semantic_memory] relate: #{source} --#{type_sym}--> #{target}")
                 { success: true, source: source, target: target, type: type_sym, relation: result }
               end
 
               def retrieve_concept(name:, **)
                 concept = knowledge_store.retrieve(name: name)
                 if concept
-                  Legion::Logging.debug "[semantic_memory] retrieve: name=#{name} conf=#{concept.confidence.round(3)}"
+                  log.debug("[semantic_memory] retrieve: name=#{name} conf=#{concept.confidence.round(3)}")
                   { success: true, found: true, concept: concept.to_h }
                 else
-                  Legion::Logging.debug "[semantic_memory] retrieve: name=#{name} not_found"
+                  log.debug("[semantic_memory] retrieve: name=#{name} not_found")
                   { success: true, found: false, name: name }
                 end
               end
 
               def query_concept_relations(name:, type: nil, **)
                 relations = knowledge_store.query_relations(name: name, type: type&.to_sym)
-                Legion::Logging.debug "[semantic_memory] query_relations: name=#{name} type=#{type} count=#{relations.size}"
+                log.debug("[semantic_memory] query_relations: name=#{name} type=#{type} count=#{relations.size}")
                 { success: true, name: name, relations: relations, count: relations.size }
               end
 
               def check_category(concept:, category:, **)
                 result = knowledge_store.check_is_a(concept, category)
-                Legion::Logging.debug "[semantic_memory] check_category: #{concept} is_a #{category} = #{result}"
+                log.debug("[semantic_memory] check_category: #{concept} is_a #{category} = #{result}")
                 { success: true, concept: concept, category: category, is_member: result }
               end
 
               def find_instances(category:, **)
                 instances = knowledge_store.instances_of(category)
-                Legion::Logging.debug "[semantic_memory] instances_of: #{category} count=#{instances.size}"
+                log.debug("[semantic_memory] instances_of: #{category} count=#{instances.size}")
                 { success: true, category: category, instances: instances.map(&:name), count: instances.size }
               end
 
               def activate_spread(seed:, hops: nil, **)
                 hop_count = hops || Helpers::Constants::MAX_SPREAD_HOPS
                 activated = knowledge_store.spreading_activation(seed: seed, hops: hop_count)
-                Legion::Logging.debug "[semantic_memory] spread: seed=#{seed} hops=#{hop_count} activated=#{activated.size}"
+                log.debug("[semantic_memory] spread: seed=#{seed} hops=#{hop_count} activated=#{activated.size}")
                 { success: true, seed: seed, activated: activated, count: activated.size }
               end
 
               def concepts_in(domain:, **)
                 concepts = knowledge_store.concepts_in_domain(domain)
-                Legion::Logging.debug "[semantic_memory] domain_query: domain=#{domain} count=#{concepts.size}"
+                log.debug("[semantic_memory] domain_query: domain=#{domain} count=#{concepts.size}")
                 { success: true, domain: domain, concepts: concepts.map(&:name), count: concepts.size }
               end
 
               def update_semantic_memory(**)
                 knowledge_store.decay_all
-                Legion::Logging.debug "[semantic_memory] tick: concepts=#{knowledge_store.concept_count} " \
-                                      "relations=#{knowledge_store.relation_count}"
+                log.debug("[semantic_memory] tick: concepts=#{knowledge_store.concept_count} " \
+                          "relations=#{knowledge_store.relation_count}")
                 {
                   success:   true,
                   concepts:  knowledge_store.concept_count,