lex-agentic-inference 0.1.1 → 0.1.3

data/lib/legion/extensions/agentic/inference/perceptual_inference/runners/perceptual_inference.rb

@@ -11,31 +11,31 @@ module Legion
 
               def register_percept_hypothesis(content:, modality:, domain: :general, prior: Helpers::DEFAULT_PRIOR, **)
                 hypothesis = field.register_hypothesis(content: content, modality: modality, domain: domain, prior: prior)
-                Legion::Logging.debug "[perceptual_inference] registered hypothesis modality=#{modality} id=#{hypothesis.id[0..7]}"
+                log.debug "[perceptual_inference] registered hypothesis modality=#{modality} id=#{hypothesis.id[0..7]}"
                 { success: true, hypothesis_id: hypothesis.id, modality: modality, prior: hypothesis.prior }
               rescue ArgumentError => e
-                Legion::Logging.warn "[perceptual_inference] register failed: #{e.message}"
+                log.warn "[perceptual_inference] register failed: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def present_perceptual_evidence(modality:, content:, strength: 0.5, **)
                 count = field.present_evidence(modality: modality, content: content, strength: strength)
-                Legion::Logging.debug "[perceptual_inference] evidence presented modality=#{modality} strength=#{strength} updated=#{count}"
+                log.debug "[perceptual_inference] evidence presented modality=#{modality} strength=#{strength} updated=#{count}"
                 { success: true, modality: modality, hypotheses_updated: count, rivalry: field.rivalry?(modality: modality) }
               rescue ArgumentError => e
-                Legion::Logging.warn "[perceptual_inference] evidence failed: #{e.message}"
+                log.warn "[perceptual_inference] evidence failed: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def select_percept(modality:, **)
                 winner = field.select_percept(modality: modality)
                 if winner
-                  Legion::Logging.info "[perceptual_inference] percept selected modality=#{modality} " \
-                                       "posterior=#{winner.posterior.round(3)} label=#{winner.percept_label}"
+                  log.info "[perceptual_inference] percept selected modality=#{modality} " \
+                           "posterior=#{winner.posterior.round(3)} label=#{winner.percept_label}"
                   { success: true, selected: true, hypothesis: winner.to_h }
                 else
                   rivalry = field.rivalry?(modality: modality)
-                  Legion::Logging.debug "[perceptual_inference] no percept selected modality=#{modality} rivalry=#{rivalry}"
+                  log.debug "[perceptual_inference] no percept selected modality=#{modality} rivalry=#{rivalry}"
                   { success: true, selected: false, rivalry: rivalry }
                 end
               rescue ArgumentError => e
@@ -46,7 +46,7 @@ module Legion
                 rival = field.rivalry?(modality: modality)
                 candidates = field.hypotheses_for(modality)
                 top_two    = candidates.select { |h| %i[active selected].include?(h.state) }.max_by(2, &:posterior)
-                Legion::Logging.debug "[perceptual_inference] rivalry check modality=#{modality} rival=#{rival}"
+                log.debug "[perceptual_inference] rivalry check modality=#{modality} rival=#{rival}"
                 { success: true, rivalry: rival, modality: modality, top_hypotheses: top_two.map(&:to_h) }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -65,7 +65,7 @@ module Legion
 
               def adapt_perception(modality:, correct_hypothesis_id:, **)
                 field.adapt_priors(modality: modality, correct_hypothesis_id: correct_hypothesis_id)
-                Legion::Logging.info "[perceptual_inference] priors adapted modality=#{modality} correct=#{correct_hypothesis_id[0..7]}"
+                log.info "[perceptual_inference] priors adapted modality=#{modality} correct=#{correct_hypothesis_id[0..7]}"
                 { success: true, modality: modality, correct_hypothesis_id: correct_hypothesis_id }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -73,20 +73,20 @@ module Legion
 
               def suppress_percept(hypothesis_id:, **)
                 suppressed = field.suppress_hypothesis(hypothesis_id: hypothesis_id)
-                Legion::Logging.debug "[perceptual_inference] suppress hypothesis_id=#{hypothesis_id[0..7]} result=#{suppressed}"
+                log.debug "[perceptual_inference] suppress hypothesis_id=#{hypothesis_id[0..7]} result=#{suppressed}"
                 { success: true, suppressed: suppressed, hypothesis_id: hypothesis_id }
               end
 
               def perceptual_ambiguity(**)
                 level = field.ambiguity_level
                 label = ambiguity_label(level)
-                Legion::Logging.debug "[perceptual_inference] ambiguity=#{level.round(3)} label=#{label}"
+                log.debug "[perceptual_inference] ambiguity=#{level.round(3)} label=#{label}"
                 { success: true, ambiguity_level: level, label: label }
               end
 
               def update_perceptual_inference(**)
                 field.decay_all
-                Legion::Logging.debug "[perceptual_inference] decay cycle complete remaining=#{field.hypotheses.size}"
+                log.debug "[perceptual_inference] decay cycle complete remaining=#{field.hypotheses.size}"
                 { success: true, remaining_hypotheses: field.hypotheses.size }
               end
 

data/lib/legion/extensions/agentic/inference/prediction/runners/prediction.rb

@@ -29,8 +29,8 @@ module Legion
                 prediction_store.store(prediction)
 
                 actionable = prediction[:confidence] >= Helpers::Modes::PREDICTION_CONFIDENCE_MIN
-                Legion::Logging.debug "[prediction] new: mode=#{mode} confidence=#{prediction[:confidence].round(2)} " \
-                                      "actionable=#{actionable} id=#{prediction[:prediction_id][0..7]}"
+                log.debug "[prediction] new: mode=#{mode} confidence=#{prediction[:confidence].round(2)} " \
+                          "actionable=#{actionable} id=#{prediction[:prediction_id][0..7]}"
 
                 {
                   prediction_id: prediction[:prediction_id],
@@ -43,25 +43,25 @@ module Legion
               def resolve_prediction(prediction_id:, outcome:, actual: nil, **)
                 pred = prediction_store.resolve(prediction_id, outcome: outcome, actual: actual)
                 if pred
-                  Legion::Logging.info "[prediction] resolved #{prediction_id[0..7]} outcome=#{outcome}"
+                  log.info "[prediction] resolved #{prediction_id[0..7]} outcome=#{outcome}"
                   record_outcome_trace(pred, outcome)
                   { resolved: true, prediction_id: prediction_id, outcome: outcome }
                 else
-                  Legion::Logging.debug "[prediction] resolve failed: #{prediction_id[0..7]} not found"
+                  log.debug "[prediction] resolve failed: #{prediction_id[0..7]} not found"
                   { resolved: false, reason: :not_found }
                 end
               end
 
               def pending_predictions(**)
                 preds = prediction_store.pending
-                Legion::Logging.debug "[prediction] pending count=#{preds.size}"
+                log.debug "[prediction] pending count=#{preds.size}"
                 { predictions: preds, count: preds.size }
               end
 
               def prediction_accuracy(window: 100, **)
                 acc = prediction_store.accuracy(window: window)
                 total = prediction_store.outcomes.size
-                Legion::Logging.debug "[prediction] accuracy=#{acc.round(2)} total_outcomes=#{total}"
+                log.debug "[prediction] accuracy=#{acc.round(2)} total_outcomes=#{total}"
                 { accuracy: acc, total_outcomes: total }
               end
 
@@ -77,7 +77,7 @@ module Legion
                 end
 
                 remaining = prediction_store.pending.size
-                Legion::Logging.debug "[prediction] expire sweep: expired=#{expired_count} remaining=#{remaining}"
+                log.debug "[prediction] expire sweep: expired=#{expired_count} remaining=#{remaining}"
 
                 { expired_count: expired_count, remaining_pending: remaining }
               end
@@ -105,7 +105,7 @@ module Legion
               end
 
               def record_outcome_trace(prediction, outcome)
-                return unless defined?(Legion::Extensions::Memory::Runners::Traces)
+                return unless defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
 
                 trace_params = case outcome
                                when :correct
@@ -118,7 +118,7 @@ module Legion
                                  return
                                end
 
-                runner = Object.new.extend(Legion::Extensions::Memory::Runners::Traces)
+                runner = Object.new.extend(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
                 runner.store_trace(
                   type:                trace_params[:type],
                   content_payload:     "prediction #{outcome}: mode=#{prediction[:mode]} confidence=#{prediction[:confidence]}",
@@ -133,9 +133,9 @@ module Legion
                 store = runner.send(:default_store)
                 store.flush if store.respond_to?(:flush)
 
-                Legion::Logging.debug "[prediction] created #{trace_params[:type]} trace for #{outcome} prediction"
+                log.debug "[prediction] created #{trace_params[:type]} trace for #{outcome} prediction"
               rescue StandardError => e
-                Legion::Logging.warn "[prediction] failed to create outcome trace: #{e.message}"
+                log.warn "[prediction] failed to create outcome trace: #{e.message}"
               end
             end
           end

data/lib/legion/extensions/agentic/inference/predictive_coding/runners/predictive_coding.rb

@@ -14,15 +14,15 @@ module Legion
 
               def generate_prediction(domain:, context: {}, **)
                 prediction = generative_model.predict(domain: domain, context: context)
-                Legion::Logging.debug "[predictive_coding] generate_prediction domain=#{domain} " \
-                                      "predicted=#{prediction[:predicted]} confidence=#{prediction[:confidence].round(3)}"
+                log.debug "[predictive_coding] generate_prediction domain=#{domain} " \
+                          "predicted=#{prediction[:predicted]} confidence=#{prediction[:confidence].round(3)}"
                 { success: true, domain: domain, predicted: prediction[:predicted], confidence: prediction[:confidence] }
               end
 
               def report_outcome(domain:, predicted:, actual:, **)
                 error = generative_model.update(domain: domain, predicted: predicted, actual: actual)
-                Legion::Logging.debug "[predictive_coding] report_outcome domain=#{domain} " \
-                                      "error_magnitude=#{error.error_magnitude.round(3)} surprising=#{error.surprising?}"
+                log.debug "[predictive_coding] report_outcome domain=#{domain} " \
+                          "error_magnitude=#{error.error_magnitude.round(3)} surprising=#{error.surprising?}"
                 {
                   success:         true,
                   domain:          domain,
@@ -36,20 +36,20 @@ module Legion
 
               def precision_for(domain:, **)
                 value = generative_model.precision_for(domain: domain)
-                Legion::Logging.debug "[predictive_coding] precision_for domain=#{domain} precision=#{value.round(3)}"
+                log.debug "[predictive_coding] precision_for domain=#{domain} precision=#{value.round(3)}"
                 { success: true, domain: domain, precision: value }
               end
 
               def surprising_errors(**)
                 errors = generative_model.surprising_errors
-                Legion::Logging.debug "[predictive_coding] surprising_errors count=#{errors.size}"
+                log.debug "[predictive_coding] surprising_errors count=#{errors.size}"
                 { success: true, errors: errors.map(&:to_h), count: errors.size }
               end
 
               def free_energy_status(**)
                 fe    = generative_model.free_energy
                 level = generative_model.free_energy_level
-                Legion::Logging.debug "[predictive_coding] free_energy_status fe=#{fe.round(3)} level=#{level}"
+                log.debug "[predictive_coding] free_energy_status fe=#{fe.round(3)} level=#{level}"
                 {
                   success:     true,
                   free_energy: fe,
@@ -60,7 +60,7 @@ module Legion
 
               def active_inference_candidates(**)
                 candidates = generative_model.active_inference_candidates
-                Legion::Logging.debug "[predictive_coding] active_inference_candidates count=#{candidates.size}"
+                log.debug "[predictive_coding] active_inference_candidates count=#{candidates.size}"
                 { success: true, candidates: candidates, count: candidates.size }
               end
 
@@ -77,14 +77,14 @@ module Legion
 
                 prune_active_inferences
 
-                Legion::Logging.debug "[predictive_coding] register_active_inference domain=#{domain} id=#{inference_id[0..7]}"
+                log.debug "[predictive_coding] register_active_inference domain=#{domain} id=#{inference_id[0..7]}"
                 { success: true, inference_id: inference_id, domain: domain, status: :pending }
               end
 
               def resolve_active_inference(domain:, action:, actual_outcome:, inference_id: nil, **)
                 record = find_inference(domain, action, inference_id)
                 unless record
-                  Legion::Logging.debug "[predictive_coding] resolve_active_inference not found domain=#{domain}"
+                  log.debug "[predictive_coding] resolve_active_inference not found domain=#{domain}"
                   return { success: false, reason: :not_found }
                 end
 
@@ -100,8 +100,8 @@ module Legion
                 record[:resolved_at]      = Time.now.utc
                 record[:error_magnitude]  = error.error_magnitude
 
-                Legion::Logging.info "[predictive_coding] resolve_active_inference domain=#{domain} " \
-                                     "error=#{error.error_magnitude.round(3)} id=#{record[:inference_id][0..7]}"
+                log.info "[predictive_coding] resolve_active_inference domain=#{domain} " \
+                         "error=#{error.error_magnitude.round(3)} id=#{record[:inference_id][0..7]}"
 
                 {
                   success:         true,
@@ -115,7 +115,7 @@ module Legion
               def update_predictive_coding(**)
                 generative_model.decay_all
                 pruned = prune_resolved_inferences
-                Legion::Logging.debug "[predictive_coding] update_predictive_coding pruned_inferences=#{pruned}"
+                log.debug "[predictive_coding] update_predictive_coding pruned_inferences=#{pruned}"
                 { success: true, pruned_inferences: pruned }
               end
 

data/lib/legion/extensions/agentic/inference/predictive_processing/runners/predictive_processing.rb

@@ -14,7 +14,7 @@ module Legion
                 return { added: false, reason: :missing_domain } if domain.nil? || domain.to_s.strip.empty?
 
                 result = default_processor.add_model(domain: domain.to_sym)
-                Legion::Logging.debug "[predictive_processing] add_model domain=#{domain} added=#{result[:added]}"
+                log.debug "[predictive_processing] add_model domain=#{domain} added=#{result[:added]}"
                 result
               end
 
@@ -22,8 +22,8 @@ module Legion
                 return { predicted: false, reason: :missing_domain } if domain.nil?
 
                 prediction = default_processor.predict(domain: domain.to_sym, context: context)
-                Legion::Logging.debug "[predictive_processing] predict domain=#{domain} " \
-                                      "expected=#{prediction[:expected_value]&.round(3)}"
+                log.debug "[predictive_processing] predict domain=#{domain} " \
+                          "expected=#{prediction[:expected_value]&.round(3)}"
                 { predicted: true, domain: domain, prediction: prediction }
               end
 
@@ -43,7 +43,7 @@ module Legion
                 return { mode: nil, reason: :missing_domain } if domain.nil?
 
                 mode = default_processor.inference_mode(domain.to_sym)
-                Legion::Logging.debug "[predictive_processing] inference_mode domain=#{domain} mode=#{mode}"
+                log.debug "[predictive_processing] inference_mode domain=#{domain} mode=#{mode}"
                 { domain: domain, mode: mode }
               end
 
@@ -60,25 +60,25 @@ module Legion
 
               def models_needing_update(**)
                 needing = default_processor.models_needing_update
-                Legion::Logging.debug "[predictive_processing] models_needing_update count=#{needing.size}"
+                log.debug "[predictive_processing] models_needing_update count=#{needing.size}"
                 { count: needing.size, models: needing }
               end
 
               def active_inference_candidates(**)
                 candidates = default_processor.active_inference_candidates
-                Legion::Logging.debug "[predictive_processing] active_inference_candidates count=#{candidates.size}"
+                log.debug "[predictive_processing] active_inference_candidates count=#{candidates.size}"
                 { count: candidates.size, domains: candidates }
               end
 
               def update_predictive_processing(**)
                 default_processor.tick
-                Legion::Logging.debug '[predictive_processing] tick: precision decayed on all models'
+                log.debug '[predictive_processing] tick: precision decayed on all models'
                 { ticked: true, model_count: default_processor.models.size }
               end
 
               def predictive_processing_stats(**)
                 stats = default_processor.to_h
-                Legion::Logging.debug "[predictive_processing] stats global_fe=#{stats[:global_free_energy]&.round(3)}"
+                log.debug "[predictive_processing] stats global_fe=#{stats[:global_free_energy]&.round(3)}"
                 { success: true, stats: stats }
               end
 
@@ -91,9 +91,9 @@ module Legion
               def log_observe(domain, result)
                 return unless result[:observed]
 
-                Legion::Logging.debug "[predictive_processing] observe domain=#{domain} " \
-                                      "error=#{result[:prediction_error]&.round(3)} " \
-                                      "mode=#{result[:inference_mode]}"
+                log.debug "[predictive_processing] observe domain=#{domain} " \
+                          "error=#{result[:prediction_error]&.round(3)} " \
+                          "mode=#{result[:inference_mode]}"
               end
             end
           end

data/lib/legion/extensions/agentic/inference/reality_testing/helpers/reality_engine.rb

@@ -7,6 +7,8 @@ module Legion
         module RealityTesting
           module Helpers
             class RealityEngine
+              include Legion::Logging::Helper
+
               def initialize
                 @beliefs     = {}
                 @next_id     = 1
@@ -19,7 +21,7 @@ module Legion
                 @next_id += 1
                 belief = Belief.new(id: id, claim: claim, domain: domain, confidence: confidence)
                 @beliefs[id] = belief
-                Legion::Logging.debug "[reality_testing] create_belief id=#{id} domain=#{domain} confidence=#{confidence.round(2)}"
+                log.debug "[reality_testing] create_belief id=#{id} domain=#{domain} confidence=#{confidence.round(2)}"
                 { created: true, belief: belief.to_h }
               end
 
@@ -28,7 +30,7 @@ module Legion
                 return { tested: false, reason: :not_found } unless belief
 
                 belief.test_with_evidence!(evidence_type: evidence_type, weight: weight)
-                Legion::Logging.debug "[reality_testing] test_belief id=#{belief_id} evidence=#{evidence_type} confidence=#{belief.confidence.round(2)}"
+                log.debug "[reality_testing] test_belief id=#{belief_id} evidence=#{evidence_type} confidence=#{belief.confidence.round(2)}"
                 { tested: true, belief: belief.to_h }
               end
 
@@ -68,7 +70,7 @@ module Legion
                 before = @beliefs.size
                 @beliefs.delete_if { |_id, b| b.confidence < 0.1 }
                 pruned = before - @beliefs.size
-                Legion::Logging.debug "[reality_testing] prune_rejected pruned=#{pruned} remaining=#{@beliefs.size}"
+                log.debug "[reality_testing] prune_rejected pruned=#{pruned} remaining=#{@beliefs.size}"
                 pruned
               end
 

data/lib/legion/extensions/agentic/inference/reality_testing/runners/reality_testing.rb

@@ -13,7 +13,7 @@ module Legion
               def create_belief(claim:, domain: :general, confidence: nil, **)
                 conf   = confidence || Helpers::Constants::DEFAULT_CONFIDENCE
                 result = reality_engine.create_belief(claim: claim, domain: domain, confidence: conf)
-                Legion::Logging.info "[reality_testing] create_belief claim=#{claim[0, 60]} domain=#{domain}"
+                log.info "[reality_testing] create_belief claim=#{claim[0, 60]} domain=#{domain}"
                 result
               end
 
@@ -32,7 +32,7 @@ module Legion
 
               def beliefs_needing_testing(**)
                 beliefs = reality_engine.beliefs_needing_testing
-                Legion::Logging.debug "[reality_testing] needs_testing count=#{beliefs.size}"
+                log.debug "[reality_testing] needs_testing count=#{beliefs.size}"
                 { count: beliefs.size, beliefs: beliefs.map(&:to_h) }
               end
 
@@ -53,13 +53,13 @@ module Legion
 
               def overall_coherence(**)
                 coherence = reality_engine.overall_reality_coherence
-                Legion::Logging.debug "[reality_testing] coherence=#{coherence.round(3)}"
+                log.debug "[reality_testing] coherence=#{coherence.round(3)}"
                 { coherence: coherence.round(3) }
               end
 
               def decay_beliefs(**)
                 count = reality_engine.decay_all
-                Legion::Logging.debug "[reality_testing] decay_all count=#{count}"
+                log.debug "[reality_testing] decay_all count=#{count}"
                 { decayed: count }
               end
 

data/lib/legion/extensions/agentic/inference/schema/runners/schema.rb

@@ -14,8 +14,8 @@ module Legion
                 extract_prediction_outcomes(tick_results)
                 world_model.decay_all
 
-                Legion::Logging.debug "[schema] relations=#{world_model.relation_count} " \
-                                      "domains=#{world_model.domain_count} established=#{world_model.established_relations.size}"
+                log.debug "[schema] relations=#{world_model.relation_count} " \
+                          "domains=#{world_model.domain_count} established=#{world_model.established_relations.size}"
 
                 world_model.to_h
               end
@@ -25,7 +25,7 @@ module Legion
                 result = world_model.add_relation(cause: cause, effect: effect, relation_type: relation_sym, confidence: confidence)
                 return { success: false, error: 'invalid relation type' } unless result
 
-                Legion::Logging.info "[schema] learned: #{cause} #{relation_sym} #{effect} (#{result.confidence.round(2)})"
+                log.info "[schema] learned: #{cause} #{relation_sym} #{effect} (#{result.confidence.round(2)})"
                 { success: true, relation: result.to_h }
               end
 
@@ -33,19 +33,19 @@ module Legion
                 result = world_model.weaken_relation(cause: cause, effect: effect, relation_type: relation_type.to_sym)
                 return { success: false, error: 'relation not found' } unless result
 
-                Legion::Logging.debug "[schema] weakened: #{cause} #{relation_type} #{effect}"
+                log.debug "[schema] weakened: #{cause} #{relation_type} #{effect}"
                 { success: true, relation: result.to_h }
               end
 
               def explain(outcome:, **)
                 chain = world_model.explain(outcome)
-                Legion::Logging.debug "[schema] explanation for #{outcome}: #{chain.size} links"
+                log.debug "[schema] explanation for #{outcome}: #{chain.size} links"
                 { outcome: outcome, chain: chain, depth: chain.size }
               end
 
               def counterfactual(cause:, **)
                 affected = world_model.counterfactual(cause)
-                Legion::Logging.debug "[schema] counterfactual for #{cause}: #{affected.size} effects"
+                log.debug "[schema] counterfactual for #{cause}: #{affected.size} effects"
                 { cause: cause, affected: affected, impact: affected.size }
               end
 
@@ -61,12 +61,12 @@ module Legion
 
               def contradictions(**)
                 result = world_model.contradictions
-                Legion::Logging.debug "[schema] contradictions: #{result.size}"
+                log.debug "[schema] contradictions: #{result.size}"
                 { contradictions: result, count: result.size }
               end
 
               def schema_stats(**)
-                Legion::Logging.debug '[schema] stats'
+                log.debug '[schema] stats'
                 world_model.to_h.merge(
                   top_relations: world_model.established_relations.first(10).map(&:to_h)
                 )

data/lib/legion/extensions/agentic/inference/uncertainty_tolerance/runners/uncertainty_tolerance.rb

@@ -16,9 +16,9 @@ module Legion
                   domain:          domain,
                   certainty_level: certainty_level
                 )
-                Legion::Logging.debug "[uncertainty_tolerance] recorded decision: id=#{decision.id[0..7]} " \
-                                      "domain=#{domain} certainty=#{certainty_level.round(2)} " \
-                                      "type=#{decision.decision_type}"
+                log.debug "[uncertainty_tolerance] recorded decision: id=#{decision.id[0..7]} " \
+                          "domain=#{domain} certainty=#{certainty_level.round(2)} " \
+                          "type=#{decision.decision_type}"
                 {
                   decision_id:               decision.id,
                   domain:                    domain,
@@ -32,12 +32,12 @@ module Legion
               def resolve_uncertain_decision(decision_id:, outcome:, **)
                 decision = engine.resolve_decision(decision_id: decision_id, outcome: outcome)
                 unless decision
-                  Legion::Logging.debug "[uncertainty_tolerance] resolve failed: #{decision_id[0..7]} not found"
+                  log.debug "[uncertainty_tolerance] resolve failed: #{decision_id[0..7]} not found"
                   return { resolved: false, reason: :not_found }
                 end
 
-                Legion::Logging.info "[uncertainty_tolerance] resolved: id=#{decision_id[0..7]} " \
-                                     "outcome=#{outcome} tolerance=#{engine.current_tolerance.round(3)}"
+                log.info "[uncertainty_tolerance] resolved: id=#{decision_id[0..7]} " \
+                         "outcome=#{outcome} tolerance=#{engine.current_tolerance.round(3)}"
                 {
                   resolved:          true,
                   decision_id:       decision_id,
@@ -50,8 +50,8 @@ module Legion
               def should_act_assessment(certainty:, **)
                 act = engine.should_act?(certainty: certainty)
                 gap = (certainty - engine.current_tolerance).round(3)
-                Legion::Logging.debug "[uncertainty_tolerance] should_act? certainty=#{certainty.round(2)} " \
-                                      "tolerance=#{engine.current_tolerance.round(2)} act=#{act}"
+                log.debug "[uncertainty_tolerance] should_act? certainty=#{certainty.round(2)} " \
+                          "tolerance=#{engine.current_tolerance.round(2)} act=#{act}"
                 {
                   should_act:        act,
                   certainty:         certainty,
@@ -63,14 +63,14 @@ module Legion
 
               def uncertainty_profile(**)
                 profile = engine.to_h
-                Legion::Logging.debug "[uncertainty_tolerance] profile: tolerance=#{profile[:current_tolerance].round(3)} " \
-                                      "label=#{profile[:tolerance_label]} decisions=#{profile[:total_decisions]}"
+                log.debug "[uncertainty_tolerance] profile: tolerance=#{profile[:current_tolerance].round(3)} " \
+                          "label=#{profile[:tolerance_label]} decisions=#{profile[:total_decisions]}"
                 profile
               end
 
               def decisions_under_uncertainty_report(threshold: nil, **)
                 decisions = engine.decisions_under_uncertainty(threshold: threshold)
-                Legion::Logging.debug "[uncertainty_tolerance] under_uncertainty: count=#{decisions.size}"
+                log.debug "[uncertainty_tolerance] under_uncertainty: count=#{decisions.size}"
                 {
                   decisions: decisions.map(&:to_h),
                   count:     decisions.size,
@@ -80,7 +80,7 @@ module Legion
 
               def domain_tolerance_report(domain:, **)
                 avg = engine.domain_tolerance(domain: domain)
-                Legion::Logging.debug "[uncertainty_tolerance] domain_tolerance: domain=#{domain} avg=#{avg&.round(3)}"
+                log.debug "[uncertainty_tolerance] domain_tolerance: domain=#{domain} avg=#{avg&.round(3)}"
                 {
                   domain:            domain,
                   average_certainty: avg,
@@ -94,8 +94,8 @@ module Legion
                   Helpers::Constants::TOLERANCE_CEILING
                 )
                 engine.instance_variable_set(:@current_tolerance, clamped)
-                Legion::Logging.info "[uncertainty_tolerance] tolerance updated: #{clamped.round(3)} " \
-                                     "label=#{engine.tolerance_label}"
+                log.info "[uncertainty_tolerance] tolerance updated: #{clamped.round(3)} " \
+                         "label=#{engine.tolerance_label}"
                 {
                   updated:           true,
                   current_tolerance: clamped,

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Inference
-        VERSION = '0.1.1'
+        VERSION = '0.1.3'
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,41 +1,39 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
+require 'legion/logging'
+require 'legion/settings'
+require 'legion/cache/helper'
+require 'legion/crypt/helper'
+require 'legion/data/helper'
+require 'legion/json/helper'
+require 'legion/transport'
 
 module Legion
-  module Logging
-    def self.debug(_msg); end
-    def self.info(_msg); end
-    def self.warn(_msg); end
-    def self.error(_msg); end
-    def self.fatal(_msg); end
-  end
-
   module Extensions
-    module Core
-      def self.extended(_base); end
-    end
-
     module Helpers
       module Lex
-        def self.included(_base); end
+        include Legion::Logging::Helper
+        include Legion::Settings::Helper
+        include Legion::Cache::Helper
+        include Legion::Crypt::Helper
+        include Legion::Data::Helper
+        include Legion::JSON::Helper
+        include Legion::Transport::Helper
       end
     end
-  end
-end
 
-# rubocop:disable Lint/EmptyClass, Style/OneClassPerFile
-module Legion
-  module Extensions
     module Actors
-      class Every; end
-      class Once; end
+      class Every
+        include Helpers::Lex
+      end
+
+      class Subscription
+        include Helpers::Lex
+      end
     end
   end
 end
-$LOADED_FEATURES << 'legion/extensions/actors/every'
-$LOADED_FEATURES << 'legion/extensions/actors/once'
-# rubocop:enable Lint/EmptyClass, Style/OneClassPerFile
 
 require 'legion/extensions/agentic/inference'