legion-llm 0.6.8 → 0.6.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 426b32ea868afbd22ddbe70fb975c8b684b5afc306bd8e2efa820c5f01819fff
-  data.tar.gz: 31dec2079d806c124824eac38098bd5642391547dfa53b88b1b8e4c0f657a693
+  metadata.gz: 245c24519b2180958f4a214034612fc0635e53aa73ed54d84534319c8d2b6e6d
+  data.tar.gz: b28143d46d537c40bd912b70a24a12add3ba0dfacd161415b0c824b4d70cb9eb
 SHA512:
-  metadata.gz: 36d79c94a91d353e6cff51c4a23a082f8e21b7d886edca017f2cfa13d7d292495aa9375007d781a056e98dcffc1b1fda0290affbb88387dc028dacbb35ee1fb1
-  data.tar.gz: 4a0c36734d64cd7a86efa760d0fd932a542f52823cdb3096ffd099808274d77a0c8f7cc569abe1edc2ee0f3cf3f084a90ab040c88991bd9c4b842c612830ba4d
+  metadata.gz: 73279e263a95b388adc0a7831b288291d9c05ef4a1957f95cdae4434ebf5401b93197b73ae0a9c3d2cfed637758c597133d16e1f2935b0df17b726d57c7ac356
+  data.tar.gz: d5c3e9d471aaeb6cb3787e85fb15be6da95ed13d660c77414d75928f1720838bd7971d61d5b4b99539788c190bf2286bb4ce23feab82ceed0bf42037b8c8063e

data/.gitignore

@@ -17,3 +17,4 @@ legionio.key
 legion.log
 .DS_Store
 .worktrees/
+.claude/

data/.rubocop.yml

@@ -14,7 +14,7 @@ Layout/HashAlignment:
   EnforcedColonStyle: table
 
 Metrics/MethodLength:
-  Max: 50
+  Max: 60
 
 Metrics/ClassLength:
   Max: 1500
@@ -28,13 +28,13 @@ Metrics/BlockLength:
     - 'spec/**/*'
 
 Metrics/AbcSize:
-  Max: 60
+  Max: 85
 
 Metrics/CyclomaticComplexity:
-  Max: 15
+  Max: 35
 
 Metrics/PerceivedComplexity:
-  Max: 17
+  Max: 35
 
 Style/Documentation:
   Enabled: false

data/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 ## [Unreleased]
 
+## [0.6.14] - 2026-04-02
+
+### Fixed
+- Preserved fleet reply success and error state exactly as produced by the handler instead of forcing successful delivery metadata onto failures
+- Preserved full fleet chat request fidelity by replaying prior messages locally and forwarding provider/model context through fleet chat, embed, and structured execution paths (closes #48)
+
+## [0.6.13] - 2026-04-02
+
+### Fixed
+- Honored `llm.daemon.enabled` in `DaemonClient` so daemon-first behavior is fully disabled when operators turn the daemon off
+- Honored nested `llm.routing.health.*` settings when building the router health tracker so custom health windows and circuit-breaker thresholds take effect (closes #45)
+
+## [0.6.12] - 2026-04-02
+
+### Fixed
+- Fixed `Batch.flush` direct execution so grouped work preserves provider/model routing, executes the queued request, and bypasses scheduling deferral when draining the queue
+- Fixed deferred `ask_direct` execution so direct asks enqueue the original message and return the deferred result cleanly instead of crashing on a deferred hash (closes #44)
+
+## [0.6.11] - 2026-04-02
+
+### Fixed
+- Made response-cache spool overflow writes configurable via `llm.prompt_caching.response_cache.spool_dir` and updated the response-cache specs to use a hermetic temp directory instead of `~/.legionio`
+- Updated README public API examples to match `Legion::LLM.ask(message: ...)` and to distinguish session creation from pipeline-backed `Legion::LLM.chat(message:/messages:)` calls (closes #46)
+
+## [0.6.10] - 2026-04-02
+
+### Changed
+- Removed a redundant RuboCop block-length suppression in Sinatra route tool wiring after the `0.6.9` release cut
+
+### Fixed
+- Aligned streaming RubyLLM execution with the standard provider path so streamed requests now apply enriched system instructions and conversation breakpoints before provider execution, matching non-streaming prompt construction (closes #47)
+
+## [0.6.9] - 2026-04-02
+
+### Added
+- Additional helper-based `info`/`error` logging across non-Sinatra runtime paths including native dispatch, prompt caching, GAIA caller helpers, billing and metering pipeline steps, provider and tool registries, compressor, reflection, shadow evaluation, and escalation tracking
+
+### Changed
+- Uplifted remaining non-Sinatra `lib/**/*.rb` runtime modules to `Legion::Logging::Helper`, replacing lingering wrapper-style `log_debug` calls with direct `log.debug/info/warn/error`
+- Added catch-all `handle_exception` coverage for remaining non-Sinatra rescue paths, including RBAC pipeline failure handling
+- Fixed pipeline request ID generation for `Request.from_chat_args` callers so response objects consistently retain a non-nil `request_id`
+- Restored shared post-response tool-call serialization used by `PostResponse` and `KnowledgeCapture`, keeping audit publishing and local knowledge capture working in isolated step execution
+- Guarded non-pipeline shadow-evaluation checks when `ShadowEval` is not loaded and cleared the remaining RuboCop regressions in `lib/` and route helpers
+
 ## [0.6.8] - 2026-04-01
 
 ### Added

data/README.md

@@ -2,7 +2,7 @@
 
 LLM integration for the [LegionIO](https://github.com/LegionIO/LegionIO) framework. Wraps [ruby_llm](https://github.com/crmne/ruby_llm) to provide chat, embeddings, tool use, and agent capabilities to any Legion extension.
 
-**Version**: 0.5.15
+**Version**: 0.6.14
 
 ## Installation
 
@@ -111,11 +111,13 @@ Legion::LLM.settings     # -> Hash (current LLM settings)
 
 ```ruby
 # Synchronous response
-response = Legion::LLM.ask("What is the capital of France?")
-puts response[:content]
+result = Legion::LLM.ask(message: "What is the capital of France?")
+puts(result[:response] || result[:content])
 
-# The daemon path returns cached (HTTP 200), synchronous (HTTP 201), or async (HTTP 202) responses
-# HTTP 403 raises DaemonDeniedError; HTTP 429 raises DaemonRateLimitedError
+# Daemon immediate/created responses return the daemon body hash.
+# Direct fallback and async poll completion return:
+#   { status: :done, response: "...", meta: { ... } }
+# HTTP 403 raises DaemonDeniedError; HTTP 429 raises DaemonRateLimitedError.
 ```
 
 Configure daemon routing under `llm.daemon`:
@@ -131,23 +133,37 @@ Configure daemon routing under `llm.daemon`:
 }
 ```
 
-### Chat
+Large async responses that overflow the cache spool to disk under
+`llm.prompt_caching.response_cache.spool_dir` (default:
+`~/.legionio/data/spool/llm_responses`).
 
-Returns a `RubyLLM::Chat` instance for multi-turn conversation:
+### Chat
 
-```ruby
-# Use configured defaults
-chat = Legion::LLM.chat
-response = chat.ask("What is the capital of France?")
-puts response.content
+`Legion::LLM.chat` has two public modes:
 
-# Override model/provider per call
-chat = Legion::LLM.chat(model: 'gpt-4o', provider: :openai)
+- Call it without `message:` or `messages:` to create a `RubyLLM::Chat` session for multi-turn conversation.
+- Call it with `message:` or `messages:` to execute immediately. When the pipeline is enabled, these request-shaped calls run through the pipeline and return a pipeline response object.
 
-# Multi-turn conversation
+```ruby
+# Session creation for multi-turn conversation
 chat = Legion::LLM.chat
 chat.ask("Remember: my name is Matt")
 chat.ask("What's my name?")  # -> "Matt"
+
+# Immediate execution through the request path
+result = Legion::LLM.chat(message: "What is the capital of France?")
+
+# Explicit multi-message request
+result = Legion::LLM.chat(
+  messages: [
+    { role: :user, content: "Summarize the meeting notes" },
+    { role: :assistant, content: "Notes received." },
+    { role: :user, content: "Now produce the summary" }
+  ]
+)
+
+# Session creation with overrides still returns RubyLLM::Chat
+chat = Legion::LLM.chat(model: 'gpt-4o', provider: :openai)
 ```
 
 ### Embeddings
@@ -282,14 +298,14 @@ response = session.ask("Review this PR: #{diff}")
 
 ### Unified Pipeline
 
-All `chat()` calls flow through an 18-step request/response pipeline (enabled by default since v0.4.8). The pipeline handles RBAC, classification, RAG context retrieval, MCP tool discovery, metering, billing, audit, and GAIA advisory in a consistent sequence. Steps are skipped based on the caller profile (`:external`, `:gaia`, `:system`).
+`Legion::LLM.chat` calls that include `message:` or `messages:` flow through a multi-step request/response pipeline when `pipeline_enabled` is `true` (the default). Session-construction calls such as `Legion::LLM.chat(model: ..., provider: ...)` return a raw `RubyLLM::Chat` and do not enter the pipeline. The pipeline handles RBAC, classification, RAG context retrieval, MCP tool discovery, metering, billing, audit, and GAIA advisory in a consistent sequence. Steps are skipped based on the caller profile (`:external`, `:gaia`, `:system`).
 
 ```ruby
-# Pipeline is enabled by default — no configuration needed
+# Request-shaped calls enter the pipeline by default
 result = Legion::LLM.chat(message: "hello")
 
-# Disable pipeline for a specific call (not recommended — use caller: profile instead)
-# Set pipeline_enabled: false in settings to disable globally
+# Session creation does not
+session = Legion::LLM.chat(model: "gpt-4o")
 ```
 
 The pipeline accepts a `caller:` hash describing the request origin:

data/lib/legion/llm/arbitrage.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require 'legion/logging/helper'
 module Legion
   module LLM
     module Arbitrage
+      extend Legion::Logging::Helper
+
       # Default cost table: per-1M-token input/output prices in USD.
       # Overridable via settings: llm.arbitrage.cost_table
       DEFAULT_COST_TABLE = {
@@ -57,7 +60,7 @@ module Legion
           return nil if scored.empty?
 
           selected = scored.min_by { |_model, cost| cost }&.first
-          Legion::Logging.debug("Arbitrage selected model=#{selected} capability=#{capability}") if defined?(Legion::Logging)
+          log.debug("Arbitrage selected model=#{selected} capability=#{capability}")
           selected
         end
 
@@ -83,7 +86,7 @@ module Legion
           arb = llm[:arbitrage] || llm['arbitrage'] || {}
           arb.is_a?(Hash) ? arb.transform_keys(&:to_sym) : {}
         rescue StandardError => e
-          Legion::Logging.warn("Arbitrage settings unavailable: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn)
           {}
         end
 

data/lib/legion/llm/batch.rb

@@ -2,9 +2,12 @@
 
 require 'securerandom'
 
+require 'legion/logging/helper'
 module Legion
   module LLM
     module Batch
+      extend Legion::Logging::Helper
+
       @mutex = Mutex.new
       @flush_timer = nil
 
@@ -30,7 +33,7 @@ module Legion
 
           @mutex.synchronize { queue << entry }
           ensure_flush_timer
-          Legion::Logging.debug "Legion::LLM::Batch enqueued #{request_id} (queue size: #{queue_size})" if defined?(Legion::Logging)
+          log.debug "Legion::LLM::Batch enqueued #{request_id} (queue size: #{queue_size})"
           request_id
         end
 
@@ -49,7 +52,7 @@ module Legion
 
           return [] if to_flush.empty?
 
-          Legion::Logging.debug "Legion::LLM::Batch flushing #{to_flush.size} request(s)" if defined?(Legion::Logging)
+          log.debug "Legion::LLM::Batch flushing #{to_flush.size} request(s)"
 
           groups = to_flush.group_by { |e| [e[:provider], e[:model]] }
           results = []
@@ -117,7 +120,7 @@ module Legion
           @flush_timer = Concurrent::TimerTask.new(execution_interval: interval) do
             flush(max_wait: 0)
           rescue StandardError => e
-            Legion::Logging.warn("Batch auto-flush failed: #{e.message}") if defined?(Legion::Logging)
+            handle_exception(e, level: :warn)
           end
           @flush_timer.execute
         end
@@ -129,19 +132,28 @@ module Legion
           b = llm[:batch] || llm['batch'] || {}
           b.is_a?(Hash) ? b.transform_keys(&:to_sym) : {}
         rescue StandardError => e
-          Legion::Logging.warn("Batch settings unavailable: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn)
           {}
         end
 
         def submit_single(entry, provider:, model:)
+          msgs = entry[:messages]
+          prompt = if msgs.is_a?(Array)
+                     last_user = msgs.select { |m| (m[:role] || m['role']).to_s == 'user' }.last
+                     (last_user || {}).fetch(:content, nil) || (last_user || {}).fetch('content', nil) || ''
+                   else
+                     msgs.to_s
+                   end
           response = Legion::LLM.chat_direct(
-            messages: entry[:messages],
+            **entry[:opts],
+            provider: provider,
             model:    model,
-            **entry[:opts]
+            message:  prompt,
+            urgency:  :immediate
           )
 
           {
-            status:   :completed,
+            status:   response.is_a?(Hash) && response[:deferred] ? :deferred : :completed,
             model:    model,
             provider: provider,
             id:       entry[:id],
@@ -149,7 +161,7 @@ module Legion
             meta:     { batched: true, queued_at: entry[:queued_at], completed_at: Time.now.utc }
           }
         rescue StandardError => e
-          Legion::Logging.warn("Batch submit_single failed for #{entry[:id]}: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn)
           {
             status:   :failed,
             model:    model,

data/lib/legion/llm/cache.rb

@@ -2,9 +2,12 @@
 
 require 'digest'
 
+require 'legion/logging/helper'
 module Legion
   module LLM
     module Cache
+      extend Legion::Logging::Helper
+
       DEFAULT_TTL = 300
 
       module_function
@@ -28,13 +31,13 @@ module Legion
 
         raw = Legion::Cache.get(cache_key)
         if raw.nil?
-          Legion::Logging.debug("LLM cache miss key=#{cache_key}") if defined?(Legion::Logging)
+          log.debug("LLM cache miss key=#{cache_key}")
           return nil
         end
 
         ::JSON.parse(raw, symbolize_names: true)
       rescue StandardError => e
-        Legion::Logging.warn("LLM cache get error key=#{cache_key}: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :warn)
         nil
       end
 
@@ -43,10 +46,10 @@ module Legion
         return false unless available?
 
         Legion::Cache.set(cache_key, ::JSON.dump(response), ttl)
-        Legion::Logging.debug("LLM cache write key=#{cache_key} ttl=#{ttl}") if defined?(Legion::Logging)
+        log.debug("LLM cache write key=#{cache_key} ttl=#{ttl}")
         true
       rescue StandardError => e
-        Legion::Logging.warn("LLM cache set error key=#{cache_key}: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :warn)
         false
       end
 
@@ -69,7 +72,7 @@ module Legion
           Legion::LLM::Settings.default
         end
       rescue StandardError => e
-        Legion::Logging.warn("LLM cache settings unavailable: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :warn)
         {}
       end
     end

data/lib/legion/llm/claude_config_loader.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require 'legion/logging/helper'
 module Legion
   module LLM
     module ClaudeConfigLoader
+      extend Legion::Logging::Helper
+
       CLAUDE_SETTINGS = File.expand_path('~/.claude/settings.json')
       CLAUDE_CONFIG   = File.expand_path('~/.claude.json')
 
@@ -21,7 +24,7 @@ module Legion
         require 'json'
         ::JSON.parse(File.read(path), symbolize_names: true)
       rescue StandardError => e
-        Legion::Logging.debug("ClaudeConfigLoader could not read #{path}: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :debug)
         {}
       end
 
@@ -36,13 +39,13 @@ module Legion
 
         if config[:anthropicApiKey] && providers.dig(:anthropic, :api_key).nil?
           providers[:anthropic][:api_key] = config[:anthropicApiKey]
-          Legion::Logging.debug 'Imported Anthropic API key from Claude CLI config'
+          log.debug 'Imported Anthropic API key from Claude CLI config'
         end
 
         return unless config[:openaiApiKey] && providers.dig(:openai, :api_key).nil?
 
         providers[:openai][:api_key] = config[:openaiApiKey]
-        Legion::Logging.debug 'Imported OpenAI API key from Claude CLI config'
+        log.debug 'Imported OpenAI API key from Claude CLI config'
       end
 
       def apply_model_preference(config)
@@ -53,7 +56,7 @@ module Legion
         return if llm[:default_model]
 
         llm[:default_model] = model
-        Legion::Logging.debug "Imported model preference from Claude CLI config: #{model}"
+        log.debug "Imported model preference from Claude CLI config: #{model}"
       end
     end
   end

data/lib/legion/llm/codex_config_loader.rb

@@ -3,9 +3,12 @@
 require 'base64'
 require 'json'
 
+require 'legion/logging/helper'
 module Legion
   module LLM
     module CodexConfigLoader
+      extend Legion::Logging::Helper
+
       CODEX_AUTH = File.expand_path('~/.codex/auth.json')
 
       module_function
@@ -36,7 +39,7 @@ module Legion
       def read_json(path)
         ::JSON.parse(File.read(path), symbolize_names: true)
       rescue StandardError => e
-        Legion::Logging.debug("CodexConfigLoader could not read #{path}: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :debug)
         {}
       end
 
@@ -47,7 +50,7 @@ module Legion
         return unless token.is_a?(String) && !token.empty?
 
         unless token_valid?(token)
-          Legion::Logging.debug 'CodexConfigLoader: access token is expired, skipping' if defined?(Legion::Logging)
+          log.debug 'CodexConfigLoader: access token is expired, skipping'
           return
         end
 
@@ -57,7 +60,7 @@ module Legion
         return unless resolved_existing.nil? || (resolved_existing.respond_to?(:empty?) && resolved_existing.empty?)
 
         providers[:openai][:api_key] = token
-        Legion::Logging.debug 'Imported OpenAI API key from Codex auth config' if defined?(Legion::Logging)
+        log.debug 'Imported OpenAI API key from Codex auth config'
       end
 
       def resolve_env_api_key(value)
@@ -99,7 +102,8 @@ module Legion
 
         exp > Time.now.to_i
       rescue StandardError => e
-        Legion::Logging.debug("CodexConfigLoader: failed to parse access token for exp validation: #{e.class}: #{e.message}") if defined?(Legion::Logging)
+        log.debug("CodexConfigLoader.token_valid? failed to parse access token: #{e.message}")
+        handle_exception(e, level: :debug)
         true
       end
     end

data/lib/legion/llm/compressor.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require 'legion/logging/helper'
 module Legion
   module LLM
     module Compressor
+      extend Legion::Logging::Helper
+
       NONE       = 0
       LIGHT      = 1
       MODERATE   = 2
@@ -35,7 +38,7 @@ module Legion
           result = segments.map { |seg| seg[:protected] ? seg[:text] : compress_prose(seg[:text], level) }.join
 
           result = collapse_whitespace(result) if level >= AGGRESSIVE
-          Legion::Logging.debug("Compressor applied level=#{level} original=#{original_length} compressed=#{result.length}") if defined?(Legion::Logging)
+          log.debug("Compressor applied level=#{level} original=#{original_length} compressed=#{result.length}")
           result
         end
 
@@ -47,10 +50,14 @@ module Legion
 
           summary = llm_summarize(text, max_tokens)
           if summary
-            log_debug("summarize_messages: #{messages.size} messages -> #{summary.length} chars")
+            log.info("[llm][compressor] summarized messages=#{messages.size} summary_chars=#{summary.length}")
             { summary: summary, original_count: messages.size, compressed: true }
           else
             fallback = compress(text, level: AGGRESSIVE)
+            log.info(
+              "[llm][compressor] fallback_compress messages=#{messages.size} " \
+              "input_chars=#{text.length} summary_chars=#{fallback.length}"
+            )
             { summary: fallback, original_count: messages.size, compressed: true, method: :stopword }
           end
         end
@@ -172,7 +179,8 @@ module Legion
           response = session.ask("#{SUMMARIZE_PROMPT}\n\n#{text[0, max_tokens * 8]}")
           response.content
         rescue StandardError => e
-          log_debug("llm_summarize failed: #{e.message}")
+          handle_exception(e, level: :debug, operation: 'llm.compressor.llm_summarize')
+          log.debug("[llm][compressor] summarize_failed error=#{e.message}")
           nil
         end
 
@@ -189,10 +197,6 @@ module Legion
           union = (words_a | words_b).size.to_f
           union.zero? ? 0.0 : intersection / union
         end
-
-        def log_debug(msg)
-          Legion::Logging.debug("Compressor: #{msg}") if defined?(Legion::Logging)
-        end
       end
     end
   end

data/lib/legion/llm/confidence_scorer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'legion/logging/helper'
+
 module Legion
   module LLM
     # Computes a ConfidenceScore for an LLM response using available signals.
@@ -13,6 +15,8 @@ module Legion
     # Legion::Settings is available, otherwise the DEFAULT_BANDS constants are used.
     # Per-call overrides can be passed as options[:confidence_bands].
     module ConfidenceScorer
+      extend Legion::Logging::Helper
+
       # Default band boundaries. Keys are the *lower* boundary of that band name:
       #   score <  :low       -> :very_low
       #   score <  :medium    -> :low
@@ -119,7 +123,8 @@ module Legion
           # avg_lp is in (-inf, 0]; e^0 = 1.0 (perfect), e^(-5) ≈ 0.007 (very uncertain).
           # We clamp at -5 so very negative values still map to > 0.
           Math.exp([avg_lp, -5.0].max)
-        rescue StandardError
+        rescue StandardError => e
+          handle_exception(e, level: :debug, operation: 'llm.confidence_scorer.extract_logprobs')
           nil
         end
 
@@ -131,7 +136,8 @@ module Legion
           lp = raw_response.logprobs if klass.method_defined?(:logprobs)
           lp ||= raw_response.metadata&.dig(:logprobs) if klass.method_defined?(:metadata)
           lp
-        rescue StandardError
+        rescue StandardError => e
+          handle_exception(e, level: :debug, operation: 'llm.confidence_scorer.probe_logprobs')
           nil
         end
 

data/lib/legion/llm/context_curator.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require 'legion/logging/helper'
 module Legion
   module LLM
     class ContextCurator
+      include Legion::Logging::Helper
+
       CURATED_KEY = :__curated__
 
       def initialize(conversation_id:)
@@ -19,7 +22,7 @@ module Legion
           store_curated(@conversation_id, curated)
           @curated_cache = nil
         rescue StandardError => e
-          Legion::Logging.warn("ContextCurator: async curation failed: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn)
         end
       end
 
@@ -123,7 +126,7 @@ module Legion
           distill_tool_result(msg, assistant_response)
         end
       rescue StandardError => e
-        Legion::Logging.warn("ContextCurator: LLM distillation failed, using heuristic: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :warn)
         distill_tool_result(msg, assistant_response)
       end
 
@@ -141,7 +144,8 @@ module Legion
 
       def curation_settings
         Legion::Settings.dig(:llm, :context_curation) || {}
-      rescue StandardError
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'llm.context_curator.curation_settings')
         {}
       end
 
@@ -174,7 +178,7 @@ module Legion
           )
         end
       rescue StandardError => e
-        Legion::Logging.warn("ContextCurator: store_curated failed: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :warn)
       end
 
       def load_curated(conversation_id)
@@ -187,7 +191,7 @@ module Legion
         regular = raw.reject { |m| m[:role] == CURATED_KEY }
         apply_curation_pipeline(regular)
       rescue StandardError => e
-        Legion::Logging.warn("ContextCurator: load_curated failed: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :warn)
         nil
       end
 
@@ -201,7 +205,7 @@ module Legion
         result = evict_superseded(result)
         dedup_similar(result)
       rescue StandardError => e
-        Legion::Logging.warn("ContextCurator: apply_curation_pipeline failed: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :warn)
         messages
       end
 
@@ -279,7 +283,7 @@ module Legion
         response = Legion::LLM.chat_direct(model: model, message: prompt)
         response.respond_to?(:content) ? response.content : nil
       rescue StandardError => e
-        Legion::Logging.warn("ContextCurator: llm_summarize_tool_result failed: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :warn)
         nil
       end
 
@@ -300,7 +304,8 @@ module Legion
           return config[:default_model] if config.is_a?(Hash) && config[:enabled] && config[:default_model]
         end
         nil
-      rescue StandardError
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'llm.context_curator.detect_small_model')
         nil
       end
     end