legion-llm 0.14.17 → 0.14.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 911fae6cf0899e9ce7ed1fea909e023b411f3437ea0225d263bcc1cb95d6f9b6
-  data.tar.gz: e7f85c4c731a1e5fe8af13dfcc85f4497619256923b6eba39afc2d9e49574863
+  metadata.gz: 96388b9de10bee10e82a3d0ec28ee9206710cfdc0c61684022fc94bb9250a9b0
+  data.tar.gz: 93362c4565301c19d55a32cb28b9e2e8fae145a893fb7330594188916280fa9e
 SHA512:
-  metadata.gz: bd8368de549a561693308531c6a5efd64ba2cbf09ca8f5cc638c76c335944392686a44418204eb5895e9386d388160550b79426c4ed832931c759dec0eee2c4d
-  data.tar.gz: cd03fa5498c7783c3be2a587c3d6ec8543ab203b19ddb3e6e207388107e30ed54b66f08980f7a5c2b9e64147d4c4defe23bbb62ed46ebf33257a96f3ceeae9d8
+  metadata.gz: 717d93944bb01f208072e86b90ecf4649baa084da362cab3217f3c58c76c6e7da3c35ad088907b8ed10a607199ae4604fcc6f89862c2f625e1ce8da9160afdf7
+  data.tar.gz: b80edee9bd60d15b433e3a5b816eeb90ee75065b9018a7ec07acc7574191af17904752531a1361cdf41ebdd44f6fcc9dea08a4db69e3336c1ef3371e1e4a8c80

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Legion LLM Changelog
 
+## [0.14.20] - 2026-07-24
+
+### Fixed
+- **Curator `strip_thinking` no longer runs on tool messages.** Tool results (`role: :tool`) contain raw command output, not thinking content. The method was incorrectly applying `lstrip` and thinking-tag detection to tool results, stripping leading whitespace from Bash output on every curation pass.
+- **Curator `strip_thinking_tags` no longer lstrips content unconditionally.** Leading whitespace is only removed between consecutive tag removals, not from the original input.
+- **StreamAssembler allows interleaved thinking blocks.** Models that produce think→content→think→content sequences no longer have subsequent thinking phases silently dropped. Each thinking phase opens a new block instead of being discarded.
+- **Trigger match strips all tagged blocks and harness messages.** Tool injection no longer triggers on words from `<system-reminder>`, CLAUDE.md content, or harness prompts (SUGGESTION MODE, title generation). Only actual user conversational text is scanned for trigger words.
+
+### Changed
+- **Context curation token targets raised.** `target_context_tokens` 60K→120K, `summarize_threshold` 90K→120K, `target_tokens` 60K→90K.
+
+## [0.14.19] - 2026-07-24
+
+### Fixed
+- **Curator `strip_thinking` no longer runs on tool messages.** Tool results (`role: :tool`) contain raw command output, not thinking content. The method was incorrectly applying `lstrip` and thinking-tag detection to tool results, stripping leading whitespace from Bash output on every curation pass.
+
+## [0.14.18] - 2026-07-24
+
+### Changed
+- `@applied_signals` rewritten from flat Array to structured Hash with named keys (`advisory_id`, `behavioral_synapse_ids`, `trace_ids`, `advisory_types`, `envelope_keys`, `prediction_id`, `response_stats`)
+- `step_response_return` implemented with `populate_response_stats`, `fire_pipeline_observation`, `record_applied_to_gaia`
+- `:response_return` removed from `ASYNC_SAFE_STEPS` (attribution must complete synchronously)
+- `gut_check` moved before `metering` in `POST_PROVIDER_STEPS`
+- GaiaCaller: `caller_class:`/`caller_client:` as explicit kwargs; `:class`/`:client` at top level of caller hash
+
+### Added
+- `fire_pipeline_observation` — calls `Gaia.observe_from_pipeline` for `:human` callers (forms bonds from API clients)
+- `gaia_preferred_lane` in TierAssigner — injects preferred provider/model for `gaia:*` callers from settings
+- `require_relative 'steps/gut_check'` in steps.rb (fixes boot crash)
+- `preferred_provider`/`preferred_model` in `gaia_defaults` settings
+
+### Removed
+- `record_advisory_meta_to_gaia` method and its call in `gaia_advisory` step (superseded by `@applied_signals` seeding)
+
 ## [0.14.17] - 2026-07-22
 
 ### Added

data/lib/legion/llm/api/stream_assembler.rb

@@ -352,24 +352,26 @@ module Legion
         end
 
         def handle_thinking_delta(text, signature)
-          # Thinking always comes before text per the canonical ordering.
-          # When emit_thinking_blocks is off we still accumulate the internal
-          # buffer (so finalize can attach it to the final message audit) but
-          # never emit blocks to the client.
           @full_thinking << text.to_s unless text.to_s.empty?
           @full_thinking_signature ||= signature.to_s unless signature.to_s.empty?
 
           return unless @emit_thinking_blocks
 
-          unless @thinking_block_open || @thinking_block_closed
+          # If thinking arrives after text has started, open a new thinking block
+          if @thinking_block_closed
+            close_text_block
+            @thinking_block_closed = false
+            @thinking_block_index = @next_block_index
+            @next_block_index += 1
+            guard { @emitter.on_thinking_open(block_index: @thinking_block_index) }
+            @thinking_block_open = true
+          elsif !@thinking_block_open
             @thinking_block_index = @next_block_index
             @next_block_index += 1
             guard { @emitter.on_thinking_open(block_index: @thinking_block_index) }
             @thinking_block_open = true
           end
 
-          return if @thinking_block_closed
-
           @phase = :mid_thinking
           guard { @emitter.on_thinking_delta(block_index: @thinking_block_index, text: text.to_s, signature: signature.to_s) }
         end

data/lib/legion/llm/context/curator.rb

@@ -123,6 +123,7 @@ module Legion
         # Heuristic: remove extended thinking blocks, keep conclusions.
         def strip_thinking(msg)
           return msg unless setting(:thinking_eviction, true)
+          return msg if msg[:role] == :tool
 
           content = msg[:content].to_s
           stripped = strip_thinking_tags(content)
@@ -136,6 +137,10 @@ module Legion
           chars_removed = content.length - stripped.length
           log.info "[llm][curator] action=strip_thinking conversation_id=#{@conversation_id} " \
                    "chars_removed=#{chars_removed} original_chars=#{content.length} stripped_chars=#{stripped.length}"
+          if content.length < 50
+            log.debug "[llm][curator] action=strip_thinking_debug conversation_id=#{@conversation_id} " \
+                      "original=#{content.inspect} stripped=#{stripped.inspect} role=#{msg[:role]}"
+          end
           msg.merge(content: stripped, curated: true, original_content: content)
         end
 
@@ -293,7 +298,7 @@ module Legion
         end
 
         def strip_thinking_tags(text)
-          result = text.lstrip
+          result = text
           loop do
             stripped = false
             THINKING_TAG_PAIRS.each do |open_tag, close_tag|

data/lib/legion/llm/inference/enrichment_injector.rb

@@ -20,7 +20,14 @@ module Legion
 
           # GAIA system prompt (highest priority enrichment)
           if (gaia = enrichments.dig('gaia:system_prompt', :content))
-            parts << gaia
+            prompt = gaia
+            if (partner = enrichments.dig('gaia:partner_model', :data))
+              # Render partner_model slots (e.g. {{partner_name}}, {{partner_standing}})
+              partner.each do |slot, value|
+                prompt = prompt.gsub("{{#{slot}}}", value.to_s)
+              end
+            end
+            parts << prompt
           end
 
           # Prior conversation history loaded by the context step.

data/lib/legion/llm/inference/executor/routing.rb

@@ -50,6 +50,8 @@ module Legion
             return unless assignment
 
             @proactive_tier_assignment = assignment
+            @applied_signals[:envelope_keys] << "tier_assigned:#{assignment[:source]}" if @applied_signals.is_a?(Hash)
+
             @audit[:'routing:tier_assignment'] = {
               outcome:     :success,
               detail:      "proactive tier=#{assignment[:tier]} source=#{assignment[:source]}",

data/lib/legion/llm/inference/executor.rb

@@ -52,6 +52,7 @@ module Legion
         include Steps::StickyRunners
         include Steps::ToolHistory
         include Steps::StickyPersist
+        include Steps::GutCheck
 
         PRE_PROVIDER_STEPS = %i[
           tracing_init idempotency conversation_uuid context_load
@@ -61,14 +62,14 @@ module Legion
         ].freeze
 
         POST_PROVIDER_STEPS = %i[
-          response_normalization post_response metering debate confidence_scoring
+          response_normalization post_response gut_check metering debate confidence_scoring
           tool_calls sticky_persist
           context_store knowledge_capture response_return
         ].freeze
 
         STEPS = (PRE_PROVIDER_STEPS + %i[provider_call] + POST_PROVIDER_STEPS).freeze
 
-        ASYNC_SAFE_STEPS = %i[post_response knowledge_capture response_return].freeze
+        ASYNC_SAFE_STEPS = %i[post_response knowledge_capture].freeze
 
         THINKING_TAG_PAIRS = [
           ['<thinking>', '</thinking>'],
@@ -134,6 +135,15 @@ module Legion
           @injected_tool_map = {}
           @native_tool_source_map = {}
           @freshly_triggered_keys = []
+          @applied_signals = {
+            advisory_id:            nil,
+            behavioral_synapse_ids: [],
+            trace_ids:              [],
+            advisory_types:         [],
+            envelope_keys:          [],
+            prediction_id:          nil,
+            response_stats:         {}
+          }
           @context_accounting = ContextAccounting.empty
         end
 
@@ -1073,7 +1083,58 @@ module Legion
           handle_exception(e, level: :warn, operation: 'llm.pipeline.trigger_async_curation', conversation_id: conv_id)
         end
 
-        def step_response_return; end
+        def step_response_return
+          populate_response_stats
+          fire_pipeline_observation
+          record_applied_to_gaia
+        end
+
+        def populate_response_stats
+          @applied_signals[:response_stats] = {
+            output_tokens:   @extracted_tokens.respond_to?(:output_tokens) ? @extracted_tokens.output_tokens.to_i : 0,
+            provider:        @resolved_provider,
+            model:           @resolved_model,
+            tier:            @resolved_tier,
+            latency_ms:      if @timestamps&.dig(:provider_start) && @timestamps[:provider_end]
+                               ((@timestamps[:provider_end] - @timestamps[:provider_start]) * 1000).round
+                             else
+                               0
+                             end,
+            exchange_id:     @exchange_id,
+            conversation_id: @request.conversation_id
+          }
+        end
+
+        def fire_pipeline_observation
+          return unless defined?(::Legion::Gaia) && ::Legion::Gaia.respond_to?(:observe_from_pipeline)
+
+          identity = @request.caller&.dig(:requested_by, :identity)
+          caller_type = @request.caller&.dig(:requested_by, :type)
+          return unless identity && caller_type&.to_sym == :human
+
+          exchange_id = @exchange_id || @request.id
+          ::Legion::Gaia.observe_from_pipeline(
+            identity:    identity,
+            caller:      @request.caller,
+            exchange_id: exchange_id
+          )
+        rescue StandardError => e
+          handle_exception(e, level: :warn, operation: 'llm.pipeline.response_return.observe_pipeline')
+        end
+
+        def record_applied_to_gaia
+          return unless defined?(::Legion::Gaia) && ::Legion::Gaia.respond_to?(:record_response_applied)
+          return if @applied_signals[:advisory_id].nil? && @applied_signals[:behavioral_synapse_ids].empty?
+
+          identity = @request.caller&.dig(:requested_by, :identity)
+          ::Legion::Gaia.record_response_applied(
+            advisory_id: @applied_signals[:advisory_id],
+            identity:    identity,
+            applied:     @applied_signals.dup
+          )
+        rescue StandardError => e
+          handle_exception(e, level: :warn, operation: 'llm.pipeline.response_return.record_applied')
+        end
 
         def finalize_context_accounting
           tokens = @context_accounting[:tokens]
@@ -1178,6 +1239,10 @@ module Legion
 
           log.debug("[pipeline][build_response] action=build request_id=#{@request.id} provider=#{@resolved_provider} model=#{@resolved_model}")
 
+          # Synchronous delivery attribution hook (H2-llm)
+          # Records what signals (GAIA hints, role mappings, etc) were actually applied to the final route.
+          emit_final_delivery_attribution
+
           Response.build(
             request_id:      @request.id,
             conversation_id: @request.conversation_id || "conv_#{SecureRandom.hex(8)}",
@@ -1206,6 +1271,17 @@ module Legion
           )
         end
 
+        def emit_final_delivery_attribution
+          keys = @applied_signals.is_a?(Hash) ? @applied_signals[:envelope_keys] : []
+          return if keys.nil? || keys.empty?
+
+          log.info("[pipeline][attribution] action=emit_final_delivery signals=#{keys.join(',')}")
+          @audit[:'delivery:attribution'] = {
+            applied_signals: @applied_signals,
+            timestamp:       Time.now
+          }
+        end
+
         def requested_deferred_tool_names
           return [] unless @request.respond_to?(:metadata)
 

data/lib/legion/llm/inference/gaia_caller.rb

@@ -10,26 +10,30 @@ module Legion
 
         extend Legion::Logging::Helper
 
-        def chat(message:, phase: 'unknown', tick_trace_id: nil, tick_span_id: nil, caller: nil, **kwargs)
+        def chat(message:, phase: 'unknown', tick_trace_id: nil, tick_span_id: nil,
+                 caller: nil, caller_class: nil, caller_client: nil, **kwargs)
           log.info("[llm][gaia] chat phase=#{phase} model=#{kwargs[:model] || 'default'}")
+
           request = Request.build(
             messages: [{ role: :user, content: message }],
             system:   kwargs[:system],
             routing:  { provider: kwargs[:provider], model: kwargs[:model] }.compact,
-            caller:   caller || gaia_caller(phase),
+            caller:   caller || gaia_caller(phase, caller_class: caller_class, caller_client: caller_client),
             tracing:  gaia_tracing(phase, tick_trace_id, tick_span_id)
           )
           Executor.new(request).call
         end
 
-        def structured(message:, schema:, phase: 'unknown', tick_trace_id: nil, tick_span_id: nil, caller: nil, **kwargs)
+        def structured(message:, schema:, phase: 'unknown', tick_trace_id: nil, tick_span_id: nil,
+                       caller: nil, caller_class: nil, caller_client: nil, **kwargs)
           log.info("[llm][gaia] structured phase=#{phase} model=#{kwargs[:model] || 'default'}")
+
           request = Request.build(
             messages:        [{ role: :user, content: message }],
             system:          kwargs[:system],
             routing:         { provider: kwargs[:provider], model: kwargs[:model] }.compact,
             response_format: { type: :json_schema, schema: schema },
-            caller:          caller || gaia_caller(phase),
+            caller:          caller || gaia_caller(phase, caller_class: caller_class, caller_client: caller_client),
             tracing:         gaia_tracing(phase, tick_trace_id, tick_span_id)
           )
           Executor.new(request).call
@@ -40,8 +44,8 @@ module Legion
           LLM.embed(text, **)
         end
 
-        def gaia_caller(phase)
-          {
+        def gaia_caller(phase, caller_class: nil, caller_client: nil)
+          hash = {
             requested_by: {
               identity:   "gaia:tick:#{phase}",
               type:       :system,
@@ -49,6 +53,9 @@ module Legion
               name:       "GAIA #{phase.to_s.tr('_', ' ').capitalize}"
             }
           }
+          hash[:class]  = caller_class  if caller_class
+          hash[:client] = caller_client if caller_client
+          hash
         end
 
         def gaia_tracing(phase, trace_id, span_id)

data/lib/legion/llm/inference/native_tool_loop.rb

@@ -36,7 +36,7 @@ module Legion
 
         private
 
-        def execute_native_tool_loop
+        def execute_native_tool_loop # rubocop:disable Metrics/AbcSize
           messages = native_dispatch_messages.dup
           max_rounds = Legion::Settings[:llm][:max_tool_rounds].to_i
           max_rounds = 200 unless max_rounds.positive?
@@ -60,6 +60,17 @@ module Legion
               result = apply_synthesized_tool_calls(result, tool_calls) if tool_calls.any?
             end
             if tool_calls.empty?
+              result_text = result.respond_to?(:text) ? result.text : (result[:result] || result[:content])
+              result_thinking = if result.respond_to?(:thinking)
+                                  t = result.thinking
+                                  t.respond_to?(:content) ? t.content : t.to_s
+                                end
+              log.debug "[llm][native_tool_loop] action=exit_no_tool_calls round=#{round} " \
+                        "result_text_length=#{result_text.to_s.length} " \
+                        "result_text=#{result_text.to_s.inspect} " \
+                        "thinking_length=#{result_thinking.to_s.length} " \
+                        "thinking_first_200=#{result_thinking.to_s[0, 200].inspect} " \
+                        "stop_reason=#{result.respond_to?(:stop_reason) ? result.stop_reason : 'n/a'}"
               log.debug "[llm][executor] action=native_tool_loop.complete rounds=#{round} reason=no_tool_calls"
               @last_tool_loop_messages = messages
               return result
@@ -143,7 +154,7 @@ module Legion
           @native_tool_loop_round = nil
         end
 
-        def execute_native_streaming_tool_loop(&block)
+        def execute_native_streaming_tool_loop(&block) # rubocop:disable Metrics/AbcSize
           messages = native_dispatch_messages.dup
           max_rounds = Legion::Settings[:llm][:max_tool_rounds].to_i
           max_rounds = 200 unless max_rounds.positive?
@@ -167,6 +178,17 @@ module Legion
               result = apply_synthesized_tool_calls(result, tool_calls) if tool_calls.any?
             end
             if tool_calls.empty?
+              result_text = result.respond_to?(:text) ? result.text : (result[:result] || result[:content])
+              result_thinking = if result.respond_to?(:thinking)
+                                  t = result.thinking
+                                  t.respond_to?(:content) ? t.content : t.to_s
+                                end
+              log.debug "[llm][native_tool_loop] action=stream_exit_no_tool_calls round=#{round} " \
+                        "result_text_length=#{result_text.to_s.length} " \
+                        "result_text=#{result_text.to_s.inspect} " \
+                        "thinking_length=#{result_thinking.to_s.length} " \
+                        "thinking_first_200=#{result_thinking.to_s[0, 200].inspect} " \
+                        "stop_reason=#{result.respond_to?(:stop_reason) ? result.stop_reason : 'n/a'}"
               log.debug "[llm][executor] action=native_streaming_tool_loop.complete rounds=#{round} reason=no_tool_calls"
               @last_tool_loop_messages = messages
               return result

data/lib/legion/llm/inference/steps/debate.rb

@@ -90,6 +90,7 @@ module Legion
               "original_chars=#{original_chars} synthetic_chars=#{debate_result[:synthetic_response].content.to_s.length} " \
               "rounds=#{debate_result[:rounds]}"
             )
+            @applied_signals[:envelope_keys] << 'debate:applied' if @applied_signals.is_a?(Hash)
             @enrichments['debate:result'] = {
               content:   "debate completed: #{debate_result[:rounds]} rounds, judge synthesis produced",
               data:      debate_result[:metadata],

data/lib/legion/llm/inference/steps/gaia_advisory.rb

@@ -44,16 +44,12 @@ module Legion
               timestamp: Time.now
             }
 
-            if advisory[:system_prompt]
-              log_step_info(:gaia_advisory, :system_prompt_injected, chars: advisory[:system_prompt].to_s.length)
-              @enrichments['gaia:system_prompt'] = {
-                content:   advisory[:system_prompt],
-                timestamp: Time.now
-              }
-            end
+            # system_prompt is injected via gaia:system_prompt enrichment key below
 
             if advisory[:routing_hint]
-              log_step_info(:gaia_advisory, :routing_hint_injected, tier: advisory[:routing_hint][:recommended_tier] || 'none')
+              hint = advisory[:routing_hint]
+              tier_value = hint[:tier] || hint[:recommended_tier] || 'none'
+              log_step_info(:gaia_advisory, :routing_hint_injected, tier: tier_value)
               @enrichments['gaia:routing_hint'] = {
                 data:      advisory[:routing_hint],
                 timestamp: Time.now
@@ -66,7 +62,12 @@ module Legion
               from: 'gaia', to: 'pipeline'
             )
 
-            record_advisory_meta_to_gaia(advisory)
+            advisory_id = advisory[:advisory_id] || advisory['advisory_id']
+            if advisory_id
+              @applied_signals[:advisory_id]    = advisory_id
+              @applied_signals[:advisory_types] = classify_advisory_types(advisory)
+            end
+
             log_step_info(
               :gaia_advisory,
               :complete,
@@ -228,29 +229,6 @@ module Legion
             nil
           end
 
-          def record_advisory_meta_to_gaia(advisory)
-            unless defined?(::Legion::Gaia) && ::Legion::Gaia.respond_to?(:record_advisory_meta)
-              log_step_debug(:gaia_advisory, :record_meta_skipped, reason: :gaia_unavailable)
-              return
-            end
-            unless advisory[:partner_context]
-              log_step_debug(:gaia_advisory, :record_meta_skipped, reason: :no_partner_context)
-              return
-            end
-
-            advisory_id = SecureRandom.uuid
-            advisory_types = classify_advisory_types(advisory)
-
-            ::Legion::Gaia.record_advisory_meta(
-              advisory_id:    advisory_id,
-              advisory_types: advisory_types
-            )
-            log_step_debug(:gaia_advisory, :record_meta, advisory_id: advisory_id, advisory_type_count: advisory_types.size)
-          rescue StandardError => e
-            handle_exception(e, level: :warn, operation: 'llm.pipeline.steps.gaia_advisory.record_meta')
-            nil
-          end
-
           def classify_advisory_types(advisory)
             types = []
             pc = advisory[:partner_context]

data/lib/legion/llm/inference/steps/gut_check.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'legion/logging/helper'
+require_relative 'logging'
+
+module Legion
+  module LLM
+    module Inference
+      module Steps
+        module GutCheck
+          include Legion::Logging::Helper
+          include Steps::Logging
+
+          def step_gut_check
+            unless defined?(::Legion::Gaia::Gut) && ::Legion::Gaia::Gut.respond_to?(:check)
+              log_step_debug(:gut_check, :skipped, reason: :gaia_gut_unavailable)
+              return
+            end
+
+            # Gather draft stats for conflict detection.
+            # This typically includes things like routing source, applied signals, and model used.
+            draft_stats = {
+              resolved_provider: @resolved_provider,
+              resolved_model:    @resolved_model,
+              applied_signals:   @applied_signals,
+              tier:              @resolved_tier || @proactive_tier_assignment&.dig(:tier)
+            }
+
+            identity = @request.caller&.dig(:requested_by, :identity) || 'unknown'
+
+            log_step_debug(:gut_check, :checking, identity: identity)
+
+            result = ::Legion::Gaia::Gut.check(
+              identity:    identity,
+              draft_stats: draft_stats
+            )
+
+            if result && result[:conflict]
+              log_step_info(:gut_check, :conflict_detected,
+                            severity: result[:severity],
+                            reason:   result[:reason])
+
+              @warnings << "Cognitive conflict detected by GAIA Gut Check: #{result[:reason]}"
+
+              # If the conflict is critical, we could potentially trigger an escalation
+              # or mark the response as suspect. For now, we follow the requirement to detect.
+              @audit[:'delivery:gut_check'] = {
+                outcome:   :conflict,
+                severity:  result[:severity],
+                reason:    result[:reason],
+                timestamp: Time.now
+              }
+            else
+              log_step_debug(:gut_check, :no_conflict)
+            end
+          rescue StandardError => e
+            @warnings << "Gut check error: #{e.message}"
+            handle_exception(e, level: :warn, operation: 'llm.pipeline.steps.gut_check')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/llm/inference/steps/rag_context.rb

@@ -38,6 +38,7 @@ module Legion
             result = apollo_retrieve(query: query, strategy: strategy)
             record_rag_enrichment(result, strategy)
             record_rag_timeline(result, strategy, start_time)
+            @applied_signals[:envelope_keys] << "rag_context:#{strategy}" if @applied_signals.is_a?(Hash)
           rescue StandardError => e
             @warnings << "RAG context error: #{e.message}"
             handle_exception(e, level: :warn, operation: 'llm.pipeline.steps.rag_context')

data/lib/legion/llm/inference/steps/tier_assigner.rb

@@ -33,7 +33,12 @@ module Legion
             end
 
             # 1. GAIA routing hint
-            recommended = nested_value(gaia_hint, :data, :recommended_tier)
+            recommended = nested_value(gaia_hint, :data, :tier)
+            if recommended.nil? && nested_value(gaia_hint, :data, :recommended_tier)
+              log.warn('[llm][routing] gaia_hint uses deprecated :recommended_tier; GAIA advisory should emit :tier')
+              recommended = nested_value(gaia_hint, :data, :recommended_tier)
+            end
+
             if recommended
               log.info("[llm][routing] tier_assigned source=gaia tier=#{recommended}")
               return { tier: recommended.to_sym, source: :gaia }
@@ -78,11 +83,22 @@ module Legion
 
               tier = value(mapping, :tier)
               log.info("[llm][routing] tier_mapping identity=#{identity} tier=#{tier}")
-              return { tier: tier&.to_sym, intent: value(mapping, :intent), source: :role_mapping }
+              result = { tier: tier&.to_sym, intent: value(mapping, :intent), source: :role_mapping }
+              result.merge!(gaia_preferred_lane) if identity.start_with?('gaia:')
+              return result
             end
             nil
           end
 
+          def gaia_preferred_lane
+            provider = Legion::Settings.dig(:llm, :gaia, :preferred_provider)
+            model    = Legion::Settings.dig(:llm, :gaia, :preferred_model)
+            extras   = {}
+            extras[:provider] = provider.to_sym if provider
+            extras[:model]    = model.to_s      if model
+            extras
+          end
+
           def tier_mappings
             configured = Legion::Settings[:llm][:routing][:tier_mappings]
             configured.nil? || configured.empty? ? DEFAULT_MAPPINGS : configured

data/lib/legion/llm/inference/steps/token_budget.rb

@@ -16,9 +16,11 @@ module Legion
             session_limit = Legion::LLM::Metering::Tokens.summary[:session_max_tokens]
             log_step_debug(:token_budget, :checking, max_input_tokens: max_input || 'none',
                                                      session_total: session_total, session_limit: session_limit || 'none')
+
             check_input_cap(max_input) if max_input&.positive?
             check_session_budget
             log_step_debug(:token_budget, :passed, max_input_tokens: max_input || 'none')
+            @applied_signals[:envelope_keys] << 'token_budget:passed' if @applied_signals.is_a?(Hash)
           rescue Legion::LLM::TokenBudgetExceeded
             log_step_info(:token_budget, :blocked)
             raise

data/lib/legion/llm/inference/steps/trigger_match.rb

@@ -70,40 +70,56 @@ module Legion
             record_trigger_match_timeline(0, start_time)
           end
 
-          private
+          HARNESS_PREFIXES = [
+            '[SUGGESTION MODE',
+            '[REQUEST INTERRUPTED',
+            'Write the title in the predominant language'
+          ].freeze
 
           def extract_recent_text
             depth = trigger_scan_depth
             messages = @request.messages.last(depth)
+
             text = messages.filter_map do |msg|
               next unless msg.is_a?(Hash)
               next unless (msg[:role] || msg['role']).to_s == 'user'
 
               content = msg[:content] || msg['content']
-              if content.is_a?(Array)
-                content.filter_map do |c|
-                  if c.is_a?(String)
-                    c
-                  else
-                    (c.is_a?(Hash) ? (c[:text] || c['text']) : nil)
-                  end
-                end.join(' ')
-              else
-                content.to_s
-              end
+              raw = if content.is_a?(Array)
+                      content.filter_map do |c|
+                        if c.is_a?(String)
+                          c
+                        else
+                          (c.is_a?(Hash) ? (c[:text] || c['text']) : nil)
+                        end
+                      end.join(' ')
+                    else
+                      content.to_s
+                    end
+              next if harness_message?(raw)
+
+              raw
             end.join(' ')
 
             sanitize_trigger_text(text)
           end
 
           def sanitize_trigger_text(text)
-            stripped = strip_system_reminders(text)
-            session_text = extract_session_text(stripped)
-            session_text || stripped
+            session_text = extract_session_text(text)
+            return session_text if session_text
+
+            strip_tagged_blocks(text)
           end
 
-          def strip_system_reminders(text)
-            text.to_s.gsub(%r{<system-reminder\b[^>]*>.*?</system-reminder>}mi, ' ')
+          def strip_tagged_blocks(text)
+            text.to_s.gsub(%r{<[a-z][\w-]*\b[^>]*>.*?</[a-z][\w-]*>}mi, ' ')
+          end
+
+          def harness_message?(text)
+            return false if text.nil? || text.empty?
+
+            trimmed = text.lstrip
+            HARNESS_PREFIXES.any? { |prefix| trimmed.start_with?(prefix) }
           end
 
           def extract_session_text(text)

data/lib/legion/llm/inference/steps.rb

@@ -31,5 +31,6 @@ require_relative 'steps/confidence_scoring'
 require_relative 'steps/token_budget'
 require_relative 'steps/prompt_cache'
 require_relative 'steps/debate'
+require_relative 'steps/gut_check'
 require_relative 'steps/tool_history'
 require_relative 'steps/sticky_persist'

data/lib/legion/llm/inference.rb

@@ -10,6 +10,7 @@ require_relative 'inference/profile'
 require_relative 'inference/timeline'
 require_relative 'inference/tracing'
 require_relative 'inference/steps'
+require_relative 'inference/steps/gut_check'
 require_relative 'inference/tool_dispatcher'
 require_relative 'inference/audit_publisher'
 require_relative 'inference/enrichment_injector'

data/lib/legion/llm/router.rb

@@ -57,6 +57,35 @@ module Legion
           rng: default_rng,
           **
         )
+          # 0. GAIA Preferred Provider/Model (OP2)
+          if type == :inference && (tiers.include?(:gaia) || tiers.include?('gaia'))
+            pref_provider = Legion::Settings.dig(:llm, :gaia, :preferred_provider)
+            pref_model    = Legion::Settings.dig(:llm, :gaia, :preferred_model)
+
+            if pref_provider || pref_model
+              # If either is set, we try to force a lane matching both (if both set) or either.
+              # We prioritize this over general weights for the :gaia tier.
+              candidates = Legion::LLM::Inventory.lanes_for(
+                provider: pref_provider,
+                model:    pref_model,
+                type:     type
+              )
+
+              if candidates&.any?
+                # Filter candidates by hard constraints (privacy, context, etc)
+                passing = candidates.select do |lane|
+                  lane_passes_hard_filters?(
+                    lane: lane, type: type, tiers: tiers, providers: providers, instances: instances,
+                    models: models, capabilities: capabilities, thinking: thinking, privacy: privacy,
+                    estimated_context: estimated_context
+                  )
+                end
+                # Use the first one that passes hard filters as the preferred selection
+                return passing.first if passing.any?
+              end
+            end
+          end
+
           candidates = if providers.size == 1 && instances.size <= 1
                          Legion::LLM::Inventory.lanes_for(
                            provider: providers.first, instance: instances.first, type: type

data/lib/legion/llm/settings.rb

@@ -330,7 +330,9 @@ module Legion
 
       def self.gaia_defaults
         {
-          advisory_enabled: true
+          advisory_enabled:   true,
+          preferred_provider: nil,
+          preferred_model:    nil
         }
       end
 
@@ -435,7 +437,7 @@ module Legion
             # Claude Code linter/formatter file-dump note.
             'was modified, either by the user or by a linter'
           ],
-          target_context_tokens:    60_000,
+          target_context_tokens:    120_000,
           context_window_threshold: 0.90,
           archive_dropped_turns:    true,
           archive_preserve_recent:  10
@@ -444,8 +446,8 @@ module Legion
 
       def self.conversation_defaults
         {
-          summarize_threshold: 90_000,
-          target_tokens:       60_000,
+          summarize_threshold: 120_000,
+          target_tokens:       90_000,
           preserve_recent:     10,
           auto_compact:        true
         }

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.14.17'
+    VERSION = '0.14.20'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.14.17
+  version: 0.14.20
 platform: ruby
 authors:
 - Esity
@@ -360,6 +360,7 @@ files:
 - lib/legion/llm/inference/steps/confidence_scoring.rb
 - lib/legion/llm/inference/steps/debate.rb
 - lib/legion/llm/inference/steps/gaia_advisory.rb
+- lib/legion/llm/inference/steps/gut_check.rb
 - lib/legion/llm/inference/steps/knowledge_capture.rb
 - lib/legion/llm/inference/steps/logging.rb
 - lib/legion/llm/inference/steps/mcp_discovery.rb