legion-llm 0.15.1 → 0.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c27dbb3d54472859916263b21e60e5150b8deb3b1138cfcb7c7d7e28d5ebbc1d
-  data.tar.gz: 3e4fb810c2ea38c895a98abd3cb432e3805a3faf35cdfecb5ad3e2347aa47046
+  metadata.gz: 63f3720eceeff21e7c4d1ca9c13858256b93bd2744d0ae3fc1bd0c7452b40d1a
+  data.tar.gz: 686e8646720ba92310f58ab7e675d380003e89e465a7b02711b916b38ee89953
 SHA512:
-  metadata.gz: c0f36cfb05fdf100e7c706dbfa254fd486afb1de6c7beb3644ca56f0504283168fe676fb8b5299222d06d4206db469af98b0498fe22d04adc1ec1ea8fc1212cb
-  data.tar.gz: f365e296fc5c77dba031187153c8f77cb454737b6637a199102e598a1e80beb3a26b68481888266bbd0c6a5943aa00eef6b5a11905ee60f6ada38f6861667290
+  metadata.gz: cf42fe3fc6d6128ca111f2d92488496079496357d03ddf5c8fdf45d1372d245fb19f997a941caff59b13a5c8c4ddf52ac1dcc28ad2aace7f5f5accd1fdb6c48d
+  data.tar.gz: be0e5fbd569a12eb65a0952c58ee91a42f06955858a073c52e83ae1e2165fec4f595dd2677b3287ffc1b5cf99fb53ed8f8905849876e93cbb21b100ea4f47d02

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Legion LLM Changelog
 
+## [0.15.2] - 2026-08-04
+
+### Fixed
+- **Runtime tool deadlines now terminate the process tree.** Replaced `Timeout.timeout` around `Open3.capture2e`, which raised a timeout but then blocked while Open3 joined the still-running child. Runtime tools now launch in a dedicated process group, send `TERM` at the deadline, wait the configured grace period, send `KILL` when needed, and reap the process before returning the timeout result.
+- **Codex Responses tool continuations preserve one assistant turn.** Codex orders a turn as function calls, assistant narration, then function-call outputs. The Responses normalizers previously split that into consecutive assistant messages and wedged narration between each call and its result, causing thinking-enabled providers to narrate and stop instead of issuing the next tool call. Assistant text and pending calls now stay on one canonical assistant message with adjacent tool results.
+
+### Changed
+- **Tool policy now has one settings subtree.** Added `Legion::LLM::Settings::Tools.defaults` at `llm.tools`, with runtime timeouts defaulting to 1 second, capped at 10 seconds, and a 1 second termination grace. Consolidated the existing tool loop, dispatch, trigger, sticky, confidence, logging, history, compaction, and Python environment policy under the same subtree, removing inline shadow defaults and operational constants from tool paths.
+
 ## [0.15.1] - 2026-08-01
 
 ### Fixed

data/lib/legion/llm/api/client_translators/openai_responses.rb

@@ -592,8 +592,27 @@ module Legion
                 flush_pending_tool_calls(messages, pending_tool_calls)
                 messages << { role: 'tool', tool_call_id: item[:call_id], content: item[:output].to_s }
               else
-                flush_pending_tool_calls(messages, pending_tool_calls)
                 role = item[:role]&.to_s
+
+                # SSOT: an assistant `message` item that arrives while tool calls
+                # are still pending is the SAME assistant turn as those calls
+                # (Codex/Responses orders: function_call(s) → assistant message →
+                # function_call_output(s)). Merge the text as the assistant
+                # message's content and flush ONE combined assistant message
+                # (content + tool_calls), so the tool results that follow stay
+                # adjacent to their tool_calls. Emitting a separate assistant text
+                # message here splits one turn into two and wedges narration
+                # between a tool_call and its result — a malformed chat/completions
+                # history that makes thinking-enabled models narrate instead of
+                # calling the next tool (the "dead stop").
+                if role == 'assistant' && !pending_tool_calls.empty?
+                  content = item[:content]
+                  content = content.to_s if content && !content.is_a?(Array)
+                  flush_pending_tool_calls(messages, pending_tool_calls, assistant_content: content)
+                  next
+                end
+
+                flush_pending_tool_calls(messages, pending_tool_calls)
                 next unless role
 
                 role = 'system' if role == 'developer'
@@ -614,8 +633,13 @@ module Legion
           # ToolCall(name: nil) — provider translators then drop the call,
           # leaving an orphan tool_result that Bedrock rejects with
           # "unexpected tool_use_id in tool_result".
-          def flush_pending_tool_calls(messages, pending)
-            return if pending.empty?
+          def flush_pending_tool_calls(messages, pending, assistant_content: nil)
+            if pending.empty?
+              # No pending calls but an assistant text turn wants flushing — emit it
+              # so a trailing/standalone assistant message is never dropped.
+              messages << { role: 'assistant', content: assistant_content } if assistant_content
+              return
+            end
 
             tool_calls = pending.map do |tc|
               args = tc[:arguments]
@@ -630,8 +654,13 @@ module Legion
             last = messages.last
             if last && last[:role] == 'assistant' && !last.key?(:tool_calls)
               last[:tool_calls] = tool_calls
+              # Text arriving AFTER the calls (Codex order) belongs to this same turn.
+              last[:content] = assistant_content if assistant_content && last[:content].to_s.empty?
             else
-              messages << { role: 'assistant', content: '', tool_calls: tool_calls }
+              # assistant_content carries text that arrived AFTER the calls in the
+              # same turn — keep it ON the tool_calls message so the turn stays one
+              # message and the following tool results remain adjacent.
+              messages << { role: 'assistant', content: assistant_content.to_s, tool_calls: tool_calls }
             end
             pending.clear
           end

data/lib/legion/llm/api/namespaces/openai/responses.rb

@@ -214,8 +214,23 @@ module Legion
                   flush_pending(messages, pending)
                   messages << { role: 'tool', tool_call_id: item[:call_id], content: item[:output].to_s }
                 else
-                  flush_pending(messages, pending)
                   role = item[:role]&.to_s
+
+                  # SSOT: an assistant `message` arriving while calls are pending is
+                  # the SAME turn as those calls (Codex order: function_call(s) →
+                  # assistant message → function_call_output(s)). Merge its text onto
+                  # the flushed assistant tool_calls message so the turn stays ONE
+                  # message and the tool results that follow stay adjacent to their
+                  # calls. Splitting it out wedges narration between a tool_call and
+                  # its result — the malformed history behind the dead stop.
+                  if role == 'assistant' && !pending.empty?
+                    content = item[:content]
+                    content = content.to_s if content && !content.is_a?(Array)
+                    flush_pending(messages, pending, assistant_content: content)
+                    next
+                  end
+
+                  flush_pending(messages, pending)
                   next unless role
 
                   role = 'system' if role == 'developer'
@@ -229,12 +244,15 @@ module Legion
               messages
             end
 
-            def self.flush_pending(messages, pending)
-              return if pending.empty?
+            def self.flush_pending(messages, pending, assistant_content: nil)
+              if pending.empty?
+                messages << { role: 'assistant', content: assistant_content } if assistant_content
+                return
+              end
 
               messages << {
                 role:       'assistant',
-                content:    '',
+                content:    assistant_content.to_s,
                 tool_calls: pending.map do |tc|
                   { id: tc[:id], type: 'function', function: { name: tc[:name], arguments: tc[:arguments] } }
                 end

data/lib/legion/llm/api/native/helpers.rb

@@ -67,7 +67,7 @@ module Legion
             case ref
             when 'sh'
               cmd = kwargs[:command] || kwargs[:cmd] || kwargs.values.first.to_s
-              log.warn("[llm][native] client_tool=sh command=#{cmd[0, 120]}")
+              log.warn("[llm][native] client_tool=sh command=#{cmd[0, Legion::Settings[:llm][:tools][:command_log_chars]]}")
               output, status = ::Open3.capture2e(cmd, chdir: Dir.pwd)
               "exit=#{status.exitstatus}\n#{output}"
             when 'file_read'

data/lib/legion/llm/api/native/inference.rb

@@ -80,8 +80,9 @@ module Legion
               end
 
               client_tool_names = tool_declarations.map(&:name)
-              client_tool_summary = client_tool_names.empty? ? 'none' : client_tool_names.first(30).join(',')
-              client_tool_summary = "#{client_tool_summary},+#{client_tool_names.size - 30}more" if client_tool_names.size > 30
+              name_limit = Legion::Settings[:llm][:tools][:name_log_limit]
+              client_tool_summary = client_tool_names.empty? ? 'none' : client_tool_names.first(name_limit).join(',')
+              client_tool_summary = "#{client_tool_summary},+#{client_tool_names.size - name_limit}more" if client_tool_names.size > name_limit
               log.info(
                 "[llm][api][tools] action=client_tools_built request_id=#{request_id} " \
                 "conversation_id=#{conversation_id || 'none'} count=#{tool_declarations.size} names=#{client_tool_summary}"

data/lib/legion/llm/call/structured_output.rb

@@ -125,12 +125,11 @@ module Legion
               .strip
           end
 
+          # -- substring check (each model
           def supports_response_format?(model)
-            # rubocop:disable Style/ArrayIntersect -- substring check (each model
             # fragment `include?`d in the model name), NOT array intersection.
             # `intersect?` raises TypeError on the String arg.
             SCHEMA_CAPABLE_MODELS.any? { |m| model.to_s.include?(m) }
-            # rubocop:enable Style/ArrayIntersect
           end
 
           def retry_enabled?

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

@@ -619,13 +619,11 @@ module Legion
           clarification_signals = ['clarif', 'what do you mean', 'i see', 'understood', 'got it', 'correct', 'exactly', 'yes', 'right', 'agree']
           conclusion_signals    = ['in summary', 'to summarize', 'in conclusion', 'therefore', 'so to answer', 'the answer is']
 
-          # rubocop:disable Style/ArrayIntersect -- these are substring checks
+          # -- these are substring checks
           # (signal `include?` against a String), NOT array intersection. The
           # cop's `intersect?` suggestion raises TypeError on a String arg.
           has_clarification = contents.any? { |c| clarification_signals.any? { |s| c.include?(s) } }
           has_conclusion    = contents.last.length < 500 || conclusion_signals.any? { |s| contents.last.include?(s) }
-          # rubocop:enable Style/ArrayIntersect
-
           has_clarification && has_conclusion
         end
 

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

@@ -76,14 +76,16 @@ module Legion
 
             filtered = messages.reject do |msg|
               role = (msg[:role] || msg['role']).to_s
-              role == 'tool' && (msg[:content] || msg['content']).to_s.length > 500
+              role == 'tool' && (msg[:content] || msg['content']).to_s.length >
+                Legion::Settings[:llm][:tools][:context_compaction][:threshold_chars]
             end
             messages = filtered.map do |msg|
               role = (msg[:role] || msg['role']).to_s
               next msg unless role == 'tool'
 
               content = (msg[:content] || msg['content']).to_s
-              content.length > 200 ? msg.merge(content: "#{content[0, 200]}\n[compacted]") : msg
+              result_chars = Legion::Settings[:llm][:tools][:context_compaction][:result_chars]
+              content.length > result_chars ? msg.merge(content: "#{content[0, result_chars]}\n[compacted]") : msg
             end
 
             return messages if estimate_message_tokens(messages) <= target_tokens
@@ -183,7 +185,7 @@ module Legion
           # Pure oversized-tool-result trim. Shared by trim_oversized_tool_results
           # (which adds logging) and reduce_messages_for_dispatch.
           def trim_oversized_tool_results_pure(messages)
-            max_chars = Legion::Settings[:llm][:tool_result_max_dispatch_chars].to_i
+            max_chars = Legion::Settings[:llm][:tools][:result_max_dispatch_chars]
             return messages unless max_chars.positive?
 
             preserve_after = last_user_message_index(messages)
@@ -205,7 +207,7 @@ module Legion
             trimmed_count = messages.zip(result).count { |before, after| before != after }
             if trimmed_count.positive?
               log.info "[llm][executor] action=trim_tool_results request_id=#{@request.id} trimmed=#{trimmed_count} " \
-                       "max_chars=#{Legion::Settings[:llm][:tool_result_max_dispatch_chars].to_i}"
+                       "max_chars=#{Legion::Settings[:llm][:tools][:result_max_dispatch_chars]}"
             end
             result
           end

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

@@ -96,7 +96,7 @@ module Legion
               return value if [true, false].include?(value)
             end
 
-            Legion::Settings.dig(:llm, :tool_trigger, :client_tool_passthrough) == true
+            Legion::Settings.dig(:llm, :tools, :trigger, :client_tool_passthrough) == true
           end
 
           def client_tool_passthrough_allowed?(definition)
@@ -111,7 +111,7 @@ module Legion
           end
 
           def client_tool_passthrough_list(key)
-            Array(Legion::Settings.dig(:llm, :tool_trigger, key)).flat_map do |entry|
+            Array(Legion::Settings.dig(:llm, :tools, :trigger, key)).flat_map do |entry|
               client_tool_policy_variants(entry)
             end.uniq
           end

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

@@ -216,7 +216,7 @@ module Legion
         def registry_tool_limit
           return nil unless local_provider?
 
-          raw_limit = Legion::Settings.dig(:llm, :tool_trigger, :local_tool_limit)
+          raw_limit = Legion::Settings.dig(:llm, :tools, :trigger, :local_tool_limit)
           limit = raw_limit.to_i
           limit.positive? ? limit : nil
         end

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

@@ -38,8 +38,7 @@ module Legion
 
         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?
+          max_rounds = Legion::Settings[:llm][:tools][:max_rounds]
           round = 0
           # Track which (tool_name, args) pairs LegionIO executed,
           # and how many consecutive rounds ended in all Legion-tool failures.
@@ -69,7 +68,7 @@ module Legion
                         "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} " \
+                        "thinking_preview=#{result_thinking.to_s[0, Legion::Settings[:llm][:tools][:thinking_log_chars]].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
@@ -135,7 +134,7 @@ module Legion
                 failed_names = round_results.map { |e| e[:tool_call][:name] }.join(',')
                 log.warn "[llm][native_tool_loop] action=all_legion_executed_tools_failed round=#{round} " \
                          "consecutive_failures=#{consecutive_failures} tools=#{failed_names}"
-                if consecutive_failures >= 2
+                if consecutive_failures >= Legion::Settings[:llm][:tools][:consecutive_failure_limit]
                   log.warn "[llm][native_tool_loop] action=legion_tool_failure_loop_broken consecutive_failures=#{consecutive_failures}"
                   return client_passthrough_tool_loop_result(result, client_calls, round)
                 end
@@ -156,8 +155,7 @@ module Legion
 
         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?
+          max_rounds = Legion::Settings[:llm][:tools][:max_rounds]
           round = 0
           executed_calls = {}
           consecutive_failures = 0
@@ -187,7 +185,7 @@ module Legion
                         "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} " \
+                        "thinking_preview=#{result_thinking.to_s[0, Legion::Settings[:llm][:tools][:thinking_log_chars]].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
@@ -244,7 +242,7 @@ module Legion
                 failed_names = round_results.map { |e| e[:tool_call][:name] }.join(',')
                 log.warn "[llm][native_tool_loop] action=all_legion_executed_tools_failed round=#{round} " \
                          "consecutive_failures=#{consecutive_failures} tools=#{failed_names}"
-                if consecutive_failures >= 2
+                if consecutive_failures >= Legion::Settings[:llm][:tools][:consecutive_failure_limit]
                   log.warn "[llm][native_tool_loop] action=legion_tool_failure_loop_broken consecutive_failures=#{consecutive_failures}"
                   return client_passthrough_tool_loop_result(result, client_calls, round)
                 end
@@ -267,7 +265,7 @@ module Legion
         # the provider adapter handles the wire format internally.
 
         def split_tool_calls_by_cap(tool_calls, round)
-          max_per_turn = Legion::Settings[:llm][:max_tool_calls_per_turn].to_i
+          max_per_turn = Legion::Settings[:llm][:tools][:max_calls_per_turn]
           return [tool_calls, []] unless max_per_turn.positive? && tool_calls.size > max_per_turn
 
           log.warn "[llm][native_tool_loop] action=cap_per_turn round=#{round} " \
@@ -326,7 +324,7 @@ module Legion
                         ext.translator.capabilities[:forced_tool_choice]
 
           text = latest_user_text.to_s.downcase
-          return if text.empty? || text.length > 500
+          return if text.empty? || text.length > Legion::Settings[:llm][:tools][:explicit_choice_max_chars]
 
           match = native_dispatch_tools.keys.map(&:to_s).sort_by { |tool_name| -tool_name.length }.find do |tool_name|
             explicit_tool_name_mentioned?(text, tool_name)

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

@@ -110,11 +110,10 @@ module Legion
               patterns << name if text.match?(regex)
             end
 
-            # rubocop:disable Style/ArrayIntersect -- substring check (each keyword
+            # -- substring check (each keyword
             # `include?`d in the text), NOT array intersection. `intersect?` raises
             # TypeError on the String arg.
             phi_found = PHI_KEYWORDS.any? { |kw| text.downcase.include?(kw) }
-            # rubocop:enable Style/ArrayIntersect
             patterns << :phi_keyword if phi_found
             if text.match?(EMAIL_PATTERN) && (standalone_email_pii? || phi_found || patterns.any?)
               patterns.delete(:email)

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

@@ -209,7 +209,7 @@ module Legion
 
           def extract_question(request)
             request.messages.select { |m| m[:role].to_s == 'user' }
-                            .last&.dig(:content) || ''
+                   .last&.dig(:content) || ''
           end
 
           def extract_content(response)

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

@@ -286,7 +286,7 @@ module Legion
 
           def extract_query
             @request.messages.select { |m| m[:role].to_s == 'user' }
-                             .then { |messages| content_text(message_content(messages.last)) }
+                    .then { |messages| content_text(message_content(messages.last)) }
           end
 
           def message_content(message)

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

@@ -12,37 +12,31 @@ module Legion
           private
 
           def sticky_enabled?
-            sticky_setting(:enabled, true) != false
+            sticky_setting(:enabled) != false
           end
 
           def trigger_sticky_turns
-            sticky_setting(:trigger_turns, 2)
+            sticky_setting(:trigger_turns)
           end
 
           def execution_sticky_tool_calls
-            sticky_setting(:execution_tool_calls, 5)
+            sticky_setting(:execution_tool_calls)
           end
 
           def max_history_entries
-            sticky_setting(:max_history_entries, 50)
+            sticky_setting(:max_history_entries)
           end
 
           def max_result_length
-            sticky_setting(:max_result_length, 2000)
+            sticky_setting(:max_result_length)
           end
 
           def max_args_length
-            sticky_setting(:max_args_length, 500)
+            sticky_setting(:max_args_length)
           end
 
-          def sticky_setting(key, default = nil)
-            value = Legion::Settings.dig(:llm, :tool_sticky, key)
-            value.nil? ? default : value
-          end
-
-          def settings_value(*keys, default: nil)
-            value = Legion::Settings.dig(:llm, *keys)
-            value.nil? ? default : value
+          def sticky_setting(key)
+            Legion::Settings[:llm][:tools][:sticky][key]
           end
         end
       end

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

@@ -94,7 +94,7 @@ module Legion
               @timeline.record(
                 category: :tool, key: "tool:result:#{tc[:name] || tc['name']}",
                 exchange_id: tool_exchange_id, direction: :inbound,
-                detail: result[:result].to_s[0..100].to_s,
+                detail: result[:result].to_s[0, Legion::Settings[:llm][:tools][:result_detail_chars]].to_s,
                 from: "tool:#{tc[:name] || tc['name']}", to: 'pipeline',
                 data: {
                   tool_call_id: tool_call_id,
@@ -325,7 +325,7 @@ module Legion
             counts.map { |key, count| "#{key}:#{count}" }.join(',')
           end
 
-          def format_tool_names(names, limit = 30)
+          def format_tool_names(names, limit = Legion::Settings[:llm][:tools][:name_log_limit])
             names = Array(names).map(&:to_s).reject(&:empty?)
             return 'none' if names.empty?
 

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

@@ -57,13 +57,14 @@ module Legion
           end
 
           def summarize_result(result_str, error)
-            return "error: #{result_str.to_s[0, 100]}" if error
+            history = Legion::Settings[:llm][:tools][:history]
+            return "error: #{result_str.to_s[0, history[:error_summary_chars]]}" if error
 
             str = result_str.to_s
             # If result is JSON but too long/truncated, avoid trying to parse incomplete JSON.
             # Large tool results (e.g. legion_list_special_tools) can be 2KB+ and get
             # truncated, causing parse errors that add noise to the logs.
-            if str.length > 2000 && str.start_with?('{')
+            if str.length > history[:large_json_threshold_chars] && str.start_with?('{')
               # Return a summary for large JSON results without parsing
               keys = extract_json_top_keys(str)
               return keys.empty? ? "large JSON result (#{str.length} chars)" : "JSON with keys: #{keys.join(', ')}"
@@ -72,7 +73,7 @@ module Legion
             begin
               parsed = Legion::JSON.load(str)
             rescue StandardError
-              return str[0, 200]
+              return str[0, history[:summary_chars]]
             end
 
             if parsed.is_a?(Array)
@@ -85,10 +86,10 @@ module Legion
               elsif parsed[:result].is_a?(Hash) && parsed[:result][:number]
                 "##{parsed[:result][:number]} at #{parsed[:result][:html_url]}"
               else
-                str[0, 200]
+                str[0, history[:summary_chars]]
               end
             else
-              str[0, 200]
+              str[0, history[:summary_chars]]
             end
           end
 
@@ -102,7 +103,8 @@ module Legion
             bracket_depth = 0
             in_string = false
             escaped = false
-            char_limit = [str.length, 500].min # Only scan first 500 chars
+            history = Legion::Settings[:llm][:tools][:history]
+            char_limit = [str.length, history[:json_scan_chars]].min
 
             (0...char_limit).each do |i|
               ch = str[i]
@@ -124,7 +126,7 @@ module Legion
                 in_key = false
                 keys << buffer unless buffer.empty?
                 buffer = +''
-                break if keys.size >= 3 # Only need first 3 keys
+                break if keys.size >= history[:json_key_limit]
               else
                 buffer << ch
               end

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

@@ -205,11 +205,11 @@ module Legion
           end
 
           def trigger_scan_depth
-            Legion::Settings[:llm][:tool_trigger][:scan_depth]
+            Legion::Settings[:llm][:tools][:trigger][:scan_depth]
           end
 
           def trigger_tool_limit
-            Legion::Settings[:llm][:tool_trigger][:tool_limit]
+            Legion::Settings[:llm][:tools][:trigger][:tool_limit]
           end
 
           def log_trigger_match(action, **fields)
@@ -225,7 +225,7 @@ module Legion
           def format_trigger_log_value(value)
             case value
             when Array
-              value.map(&:to_s).first(20).join(',')
+              value.map(&:to_s).first(Legion::Settings[:llm][:tools][:trigger][:log_name_limit]).join(',')
             else
               value
             end

data/lib/legion/llm/inventory.rb

@@ -227,8 +227,7 @@ module Legion
           sets     = policy_sets_for(provider: provider)
 
           # Whitelist takes precedence over blacklist (M2).  Substring match —
-          # a model is denied if NO whitelist pattern is contained in its name.
-          # rubocop:disable Style/ArrayIntersect -- substring checks (patterns
+          # a model is denied if NO whitelist pattern is contained in its name. # -- substring checks (patterns
           # `include?`d in the model name), NOT array intersection; `intersect?`
           # raises TypeError on the String arg.
           if sets[:whitelist]
@@ -238,7 +237,6 @@ module Legion
           end
 
           sets[:blacklist]&.any? { |p| model.include?(p) } || false
-          # rubocop:enable Style/ArrayIntersect
         end
 
         # Specificity cascade — same precedence as lex-llm Provider#model_whitelist:

data/lib/legion/llm/settings/tools.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module LLM
+    module Settings
+      module Tools
+        extend Legion::Logging::Helper
+
+        def self.defaults
+          {
+            max_rounds:                200,
+            max_calls_per_turn:        100,
+            consecutive_failure_limit: 2,
+            explicit_choice_max_chars: 500,
+            error_log_chars:           500,
+            result_detail_chars:       100,
+            result_max_dispatch_chars: 5_000,
+            name_log_limit:            30,
+            command_log_chars:         120,
+            thinking_log_chars:        200,
+            python_venv_dir:           '~/.legionio/python',
+            timeouts:                  {
+              default:         1_000,
+              max:             10_000,
+              terminate_grace: 1_000
+            },
+            trigger:                   {
+              scan_depth:                        10,
+              tool_limit:                        25,
+              local_tool_limit:                  50,
+              log_name_limit:                    20,
+              client_tool_passthrough:           true,
+              client_tool_passthrough_whitelist: [],
+              client_tool_passthrough_blacklist: [
+                'sudo', 'visudo', 'su', 'legion', 'legionio', 'legionio do', 'legionio/legion',
+                'computer_use_session', 'computer_use_control', 'computer_use_session_info',
+                'computer_use_session_message', 'plugin__aithena__recall', 'plugin__aithena__remember',
+                'plugin__aithena__skill_search', 'plugin__aithena__skill_feedback', 'plugin__aithena__memory_stats',
+                'plugin__cron__create', 'plugin__cron__list', 'plugin__cron__get', 'plugin__cron__update',
+                'plugin__cron__delete', 'plugin__cron__get_history', 'plugin__cron__run_now', 'plugin__cron__stop'
+              ]
+            },
+            history:                   {
+              error_summary_chars:        100,
+              large_json_threshold_chars: 2_000,
+              summary_chars:              200,
+              json_scan_chars:            500,
+              json_key_limit:             3
+            },
+            context_compaction:        {
+              threshold_chars: 500,
+              result_chars:    200
+            },
+            sticky:                    {
+              enabled:              true,
+              trigger_turns:        2,
+              execution_tool_calls: 5,
+              max_history_entries:  50,
+              max_result_length:    2_000,
+              max_args_length:      500
+            },
+            confidence:                {
+              override_threshold:           0.8,
+              shadow_threshold:             0.5,
+              success_delta:                0.05,
+              failure_delta:                -0.1,
+              apollo_limit:                 100,
+              apollo_confidence_multiplier: 0.8,
+              cache_ttl_seconds:            3_600
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/legion/llm/settings.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/logging/helper'
+require 'legion/llm/settings/tools'
 require 'legion/settings'
 
 module Legion
@@ -8,65 +9,51 @@ module Legion
     module Settings
       extend Legion::Logging::Helper
 
-      CLIENT_TOOL_PASSTHROUGH_BLACKLIST_DEFAULT = [
-        'sudo', 'visudo', 'su', 'legion', 'legionio', 'legionio do', 'legionio/legion',
-        'computer_use_session', 'computer_use_control', 'computer_use_session_info',
-        'computer_use_session_message', 'plugin__aithena__recall', 'plugin__aithena__remember',
-        'plugin__aithena__skill_search', 'plugin__aithena__skill_feedback', 'plugin__aithena__memory_stats',
-        'plugin__cron__create', 'plugin__cron__list', 'plugin__cron__get', 'plugin__cron__update',
-        'plugin__cron__delete', 'plugin__cron__get_history', 'plugin__cron__run_now', 'plugin__cron__stop'
-      ].freeze
-      CLIENT_TOOL_PASSTHROUGH_WHITELIST_DEFAULT = [].freeze
-
       def self.default
         model_override = ENV.fetch('ANTHROPIC_MODEL', nil)
         {
-          enabled:                        true,
-          connected:                      false,
-          pipeline_enabled:               true,
-          pipeline_async_post_steps:      true,
-          context_window:                 250_000,
-          max_output_tokens:              16_384,
-          max_tool_rounds:                200,
-          max_tool_calls_per_turn:        100,
-          tool_error_log_chars:           500,
-          tool_result_max_dispatch_chars: 5_000,
-          default_model:                  model_override,
-          default_temperature:            0.9,
-          default_provider:               nil,
-          providers:                      {},
-          tier_order:                     nil,
-          system_baseline:                system_baseline_default,
-          fleet:                          fleet_defaults,
-          routing:                        routing_defaults,
-          budget:                         budget_defaults,
-          confidence:                     confidence_defaults,
-          discovery:                      discovery_defaults,
-          daemon:                         daemon_defaults,
-          prompt_caching:                 prompt_caching_defaults,
-          arbitrage:                      arbitrage_defaults,
-          batch:                          batch_defaults,
-          scheduling:                     scheduling_defaults,
-          rag:                            rag_defaults,
-          rag_guard:                      rag_guard_defaults,
-          gaia:                           gaia_defaults,
-          knowledge_capture:              knowledge_capture_defaults,
-          embedding:                      embedding_defaults,
-          conversation:                   conversation_defaults,
-          telemetry:                      telemetry_defaults,
-          pricing:                        {},
-          metering:                       metering_defaults,
-          context_curation:               context_curation_defaults,
-          debate:                         debate_defaults,
-          provider_layer:                 provider_layer_defaults,
-          tool_trigger:                   tool_trigger_defaults,
-          api:                            api_defaults,
-          streaming:                      streaming_defaults,
-          compliance:                     compliance_defaults,
-          skills:                         skills_defaults,
-          claude_cli:                     claude_cli_defaults,
-          fallback:                       fallback_defaults,
-          structured_output:              structured_output_defaults
+          enabled:                   true,
+          connected:                 false,
+          pipeline_enabled:          true,
+          pipeline_async_post_steps: true,
+          context_window:            250_000,
+          max_output_tokens:         16_384,
+          default_model:             model_override,
+          default_temperature:       0.9,
+          default_provider:          nil,
+          providers:                 {},
+          tier_order:                nil,
+          system_baseline:           system_baseline_default,
+          fleet:                     fleet_defaults,
+          routing:                   routing_defaults,
+          budget:                    budget_defaults,
+          confidence:                confidence_defaults,
+          discovery:                 discovery_defaults,
+          daemon:                    daemon_defaults,
+          prompt_caching:            prompt_caching_defaults,
+          arbitrage:                 arbitrage_defaults,
+          batch:                     batch_defaults,
+          scheduling:                scheduling_defaults,
+          rag:                       rag_defaults,
+          rag_guard:                 rag_guard_defaults,
+          gaia:                      gaia_defaults,
+          knowledge_capture:         knowledge_capture_defaults,
+          embedding:                 embedding_defaults,
+          conversation:              conversation_defaults,
+          telemetry:                 telemetry_defaults,
+          pricing:                   {},
+          metering:                  metering_defaults,
+          context_curation:          context_curation_defaults,
+          debate:                    debate_defaults,
+          provider_layer:            provider_layer_defaults,
+          tools:                     Legion::LLM::Settings::Tools.defaults,
+          api:                       api_defaults,
+          streaming:                 streaming_defaults,
+          compliance:                compliance_defaults,
+          skills:                    skills_defaults,
+          claude_cli:                claude_cli_defaults,
+          fallback:                  fallback_defaults,
+          structured_output:         structured_output_defaults
         }
       end
 
@@ -483,17 +470,6 @@ module Legion
         }
       end
 
-      def self.tool_trigger_defaults
-        {
-          scan_depth:                        10,
-          tool_limit:                        25,
-          local_tool_limit:                  50,
-          client_tool_passthrough:           true,
-          client_tool_passthrough_whitelist: CLIENT_TOOL_PASSTHROUGH_WHITELIST_DEFAULT.dup,
-          client_tool_passthrough_blacklist: CLIENT_TOOL_PASSTHROUGH_BLACKLIST_DEFAULT.dup
-        }
-      end
-
       def self.debate_defaults
         {
           enabled:                  false,

data/lib/legion/llm/tools/confidence.rb

@@ -9,11 +9,6 @@ module Legion
         extend Legion::Logging::Helper
         extend ::Legion::Cache::Helper
 
-        OVERRIDE_THRESHOLD = 0.8
-        SHADOW_THRESHOLD = 0.5
-        SUCCESS_DELTA = 0.05
-        FAILURE_DELTA = -0.1
-
         @overrides_l0 = {}
         @mutex = Mutex.new
 
@@ -36,7 +31,7 @@ module Legion
             entry = @overrides_l0[tool]
             return unless entry
 
-            entry[:confidence] = (entry[:confidence] + SUCCESS_DELTA).clamp(0.0, 1.0)
+            entry[:confidence] = (entry[:confidence] + confidence_settings[:success_delta]).clamp(0.0, 1.0)
             entry[:hit_count] += 1
             entry[:updated_at] = Time.now
           end
@@ -48,7 +43,7 @@ module Legion
             entry = @overrides_l0[tool]
             return unless entry
 
-            entry[:confidence] = (entry[:confidence] + FAILURE_DELTA).clamp(0.0, 1.0)
+            entry[:confidence] = (entry[:confidence] + confidence_settings[:failure_delta]).clamp(0.0, 1.0)
             entry[:miss_count] += 1
             entry[:updated_at] = Time.now
           end
@@ -63,12 +58,13 @@ module Legion
 
         def should_override?(tool)
           entry = lookup(tool)
-          entry.is_a?(Hash) && entry[:confidence] >= OVERRIDE_THRESHOLD
+          entry.is_a?(Hash) && entry[:confidence] >= confidence_settings[:override_threshold]
         end
 
         def should_shadow?(tool)
           entry = lookup(tool)
-          entry.is_a?(Hash) && entry[:confidence] >= SHADOW_THRESHOLD && entry[:confidence] < OVERRIDE_THRESHOLD
+          entry.is_a?(Hash) && entry[:confidence] >= confidence_settings[:shadow_threshold] &&
+            entry[:confidence] < confidence_settings[:override_threshold]
         end
 
         def all_overrides
@@ -98,7 +94,7 @@ module Legion
           results = Legion::Extensions::Apollo::Runners::Knowledge.handle_retrieve(
             tags:             %w[override mesh_confirmed],
             knowledge_domain: 'system',
-            limit:            100
+            limit:            confidence_settings[:apollo_limit]
           )
           return unless results.is_a?(Array)
 
@@ -115,7 +111,8 @@ module Legion
               @overrides_l0[tool] = {
                 tool: tool,
                 lex: ctx[:lex] || ctx['lex'],
-                confidence: ((ctx[:confidence] || ctx['confidence']).to_f * 0.8).clamp(0.0, 1.0),
+                confidence: ((ctx[:confidence] || ctx['confidence']).to_f *
+                  confidence_settings[:apollo_confidence_multiplier]).clamp(0.0, 1.0),
                 hit_count: 0, miss_count: 0,
                 created_at: Time.now, updated_at: Time.now
               }
@@ -140,7 +137,7 @@ module Legion
             entry = @mutex.synchronize { @overrides_l0[tool] }
             return unless entry
 
-            l1_cache_set("override:#{tool}", Legion::JSON.dump(entry), ttl: 3600)
+            l1_cache_set("override:#{tool}", Legion::JSON.dump(entry), ttl: confidence_settings[:cache_ttl_seconds])
           rescue StandardError => e
             handle_exception(e, level: :warn, handled: true, operation: 'llm.tools.confidence.sync_l1', tool: tool)
             nil
@@ -197,6 +194,10 @@ module Legion
             handle_exception(e, level: :warn, handled: true, operation: 'llm.tools.confidence.lookup_l2')
             nil
           end
+
+          def confidence_settings
+            Legion::Settings[:llm][:tools][:confidence]
+          end
         end
       end
     end

data/lib/legion/llm/tools/dispatcher.rb

@@ -217,10 +217,7 @@ module Legion
         end
 
         def tool_error_log_chars
-          configured = Legion::Settings[:llm][:tool_error_log_chars].to_i
-          configured.positive? ? configured : 500
-        rescue StandardError
-          500
+          Legion::Settings[:llm][:tools][:error_log_chars]
         end
       end
     end

data/lib/legion/llm/tools/interceptors/python_venv.rb

@@ -7,8 +7,6 @@ module Legion
     module Tools
       module Interceptors
         module PythonVenv
-          VENV_DIR = (ENV['LEGION_PYTHON_VENV'] || File.expand_path('~/.legionio/python')).freeze
-
           TOOL_PATTERN = /\A(python3?|pip3?)\z/i
 
           module_function
@@ -24,7 +22,7 @@ module Legion
           end
 
           def venv_available?
-            Special.python_available? || File.exist?("#{VENV_DIR}/pyvenv.cfg")
+            Special.python_available? || File.exist?("#{venv_dir}/pyvenv.cfg")
           end
 
           def rewrite(**args)
@@ -43,11 +41,16 @@ module Legion
           end
 
           def python_path
-            Special.python_path || "#{VENV_DIR}/bin/python3"
+            Special.python_path || "#{venv_dir}/bin/python3"
           end
 
           def pip_path
-            Special.pip_path || "#{VENV_DIR}/bin/pip3"
+            Special.pip_path || "#{venv_dir}/bin/pip3"
+          end
+
+          def venv_dir
+            configured = Legion::Settings[:llm][:tools][:python_venv_dir]
+            File.expand_path(ENV['LEGION_PYTHON_VENV'] || configured)
           end
         end
       end

data/lib/legion/llm/tools/special.rb

@@ -17,8 +17,6 @@ module Legion
 
         LIST_SPECIAL_TOOLS_NAME = 'legion_list_special_tools'
         LIST_ALL_TOOLS_NAME = 'legion_list_all_tools'
-        DEFAULT_TIMEOUT_MS = 120_000
-        MAX_TIMEOUT_MS = 600_000
         TOOL_ALIASES = {
           'python' => %w[python python3],
           'pip'    => %w[pip pip3]
@@ -138,7 +136,8 @@ module Legion
         end
 
         def python_venv_dir
-          ENV['LEGION_PYTHON_VENV'] || File.expand_path('~/.legionio/python')
+          configured = Legion::Settings[:llm][:tools][:python_venv_dir]
+          ENV['LEGION_PYTHON_VENV'] || File.expand_path(configured)
         end
 
         def special_tools_definition
@@ -326,11 +325,51 @@ module Legion
         end
 
         def run_process(executable, argv, **args)
-          Timeout.timeout(timeout_ms(args) / 1000.0) do
-            Open3.capture2e(executable, *argv, chdir: process_cwd(args), stdin_data: process_stdin(args))
+          Open3.popen2e(executable, *argv, chdir: process_cwd(args), pgroup: true) do |stdin, output, wait_thread|
+            output_reader = Thread.new { output.read }
+            output_reader.report_on_exception = false
+            stdin_writer = Thread.new do
+              stdin.write(process_stdin(args))
+            rescue Errno::EPIPE, IOError
+              nil
+            ensure
+              stdin.close unless stdin.closed?
+            end
+            stdin_writer.report_on_exception = false
+
+            unless wait_thread.join(timeout_ms(args) / 1000.0)
+              terminate_process_group(wait_thread)
+              stdin_writer.join
+              output_reader.join
+              raise Timeout::Error
+            end
+
+            stdin_writer.join
+            [output_reader.value, wait_thread.value]
           end
         end
 
+        def terminate_process_group(wait_thread)
+          process_group_id = wait_thread.pid
+          signal_process_group('TERM', process_group_id)
+          wait_thread.join(terminate_grace_ms / 1000.0)
+          signal_process_group('KILL', process_group_id) if process_group_alive?(process_group_id)
+          wait_thread.join
+        end
+
+        def signal_process_group(signal, process_group_id)
+          ::Process.kill(signal, -process_group_id)
+        rescue Errno::ESRCH
+          nil
+        end
+
+        def process_group_alive?(process_group_id)
+          ::Process.kill(0, -process_group_id)
+          true
+        rescue Errno::ESRCH
+          false
+        end
+
         def process_cwd(args)
           cwd = args[:cwd] || args['cwd']
           cwd.to_s.empty? ? Dir.pwd : cwd.to_s
@@ -342,10 +381,15 @@ module Legion
         end
 
         def timeout_ms(args)
-          requested = (args[:timeout] || args['timeout'] || DEFAULT_TIMEOUT_MS).to_i
-          return DEFAULT_TIMEOUT_MS unless requested.positive?
+          timeouts = Legion::Settings[:llm][:tools][:timeouts]
+          requested = (args[:timeout] || args['timeout'] || timeouts[:default]).to_i
+          return timeouts[:default] unless requested.positive?
+
+          [requested, timeouts[:max]].min
+        end
 
-          [requested, MAX_TIMEOUT_MS].min
+        def terminate_grace_ms
+          Legion::Settings[:llm][:tools][:timeouts][:terminate_grace]
         end
 
         def pip_candidates_for(bin_dir)
@@ -410,10 +454,7 @@ module Legion
         end
 
         def tool_error_log_chars
-          configured = Legion::Settings[:llm][:tool_error_log_chars].to_i
-          configured.positive? ? configured : 500
-        rescue StandardError
-          500
+          Legion::Settings[:llm][:tools][:error_log_chars]
         end
       end
     end

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.15.1'
+    VERSION = '0.15.2'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.15.2
 platform: ruby
 authors:
 - Esity
@@ -411,6 +411,7 @@ files:
 - lib/legion/llm/scheduling/batch.rb
 - lib/legion/llm/scheduling/off_peak.rb
 - lib/legion/llm/settings.rb
+- lib/legion/llm/settings/tools.rb
 - lib/legion/llm/skills.rb
 - lib/legion/llm/skills/base.rb
 - lib/legion/llm/skills/disk_loader.rb