legionio 1.5.13 → 1.5.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4815cb38dfcd2dc20af4e57d1ec14f63a9bf7876477b70fc11696b775685addf
-  data.tar.gz: 79f424e95bbe364be35ef6a1b5b11da3ef476dda096443a303b0d8136ffc79e5
+  metadata.gz: d66368a89ce7ef86f5c62277fe403c840caf722f8e6b840000251775ce74e4a4
+  data.tar.gz: 8a44567875935c668bf2884e7fac6e0831f0dad9f1860f5e2bde28eedb0b7df5
 SHA512:
-  metadata.gz: 4edcd4fabaa737d35e6176668dc63cd6091533240f0ca038250b2b44652130590ad04ee144ed58df2eca1aa3d5313353b46a99069b42eefd2d224384694209a5
-  data.tar.gz: 16d72dd0db3df555b27defbe22fe1a3b27e2aa11d11674f57d89bc8de593f624aeb5c5ae6fcb589a5f085b0eea9619b0fd6ef56349cf749a3819210f5cc7b7ca
+  metadata.gz: 7e45f6aa1d7838ed5c5ddac267310ea8163f27f1e4c8efd190720da148add55ff9f50e958c8096691d6ce3a613064322f11eba64d8fc0eae79bea26fc1ee1a9c
+  data.tar.gz: ce24287b1dd968ef9e33e053c358b7e182b92685c6696b0074fef7ab3d0447449452f9959a3086148a73b606fefc643444546ad34e596b8c8ea5039b4bf65c17

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Legion Changelog
 
+## [1.5.15] - 2026-03-25
+
+### Removed
+- CLI chat Apollo writeback prototype (replaced by pipeline step 19 in legion-llm)
+
+## [1.5.14] - 2026-03-25
+
+### Fixed
+- Shutdown no longer hangs when network is unreachable — all component shutdowns wrapped in bounded timeouts via `shutdown_component` helper (#30)
+- Reload path also wrapped with same timeout guards to prevent hangs during network-triggered reload (#30)
+
+### Added
+- Network watchdog: background `Concurrent::TimerTask` monitors transport/data/cache connectivity, pauses actors after sustained failures, triggers `Legion.reload` when network restores (#30)
+- `Legion::Extensions.pause_actors` suspends all `Every` timer tasks without destroying instances (#30)
+- Watchdog is feature-flagged via `network.watchdog.enabled` (default: false), configurable threshold and interval (#30)
+
 ## [1.5.13] - 2026-03-25
 
 ### Fixed

data/lib/legion/cli/chat/tools/query_knowledge.rb

@@ -43,7 +43,7 @@ module Legion
           private
 
           def apollo_query(query:, domain:, limit:)
-            body = { query: query, limit: limit }
+            body = { query: query, limit: limit, status: %w[confirmed candidate] }
             body[:domain] = domain if domain
 
             uri = URI("http://#{DEFAULT_HOST}:#{apollo_port}/api/apollo/query")

data/lib/legion/cli/chat_command.rb

@@ -102,10 +102,16 @@ module Legion
 
         chat_log.info "headless prompt model=#{session.model_id} length=#{text.length}"
 
+        turn_tool_calls = []
+        tool_callbacks = {
+          on_tool_call:   ->(tc) { turn_tool_calls << { name: tc.name, args: tc.arguments, result: nil } },
+          on_tool_result: ->(tr) { turn_tool_calls.last[:result] = tr.to_s.lines.first(3).join.rstrip if turn_tool_calls.last }
+        }
+
         response = if options[:output_format] == 'json'
-                     session.send_message(text)
+                     session.send_message(text, **tool_callbacks)
                    else
-                     session.send_message(text) { |chunk| print chunk.content if chunk.content }
+                     session.send_message(text, **tool_callbacks) { |chunk| print chunk.content if chunk.content }
                    end
 
         chat_log.info "headless complete tokens_in=#{session.stats[:input_tokens]} tokens_out=#{session.stats[:output_tokens]}"
@@ -298,11 +304,13 @@ module Legion
             buffer = String.new
             tool_index = 0
             tool_total = 0
+            turn_tool_calls = []
             @session.send_message(
               stripped,
               on_tool_call:   lambda { |tc|
                 tool_index += 1
                 chat_log.debug "tool_call name=#{tc.name} args=#{tc.arguments.keys.join(',')}"
+                turn_tool_calls << { name: tc.name, args: tc.arguments, result: nil }
                 @session.emit(:tool_start, {
                                 name: tc.name, args: tc.arguments,
                   index: tool_index, total: tool_total
@@ -312,6 +320,7 @@ module Legion
               on_tool_result: lambda { |tr|
                 result_preview = tr.to_s.lines.first(3).join.rstrip
                 chat_log.debug "tool_result preview=#{result_preview[0..200]}"
+                turn_tool_calls.last[:result] = result_preview if turn_tool_calls.last
                 @session.emit(:tool_complete, {
                                 name: 'tool', result_preview: result_preview,
                   index: tool_index, total: tool_total

data/lib/legion/extensions.rb

@@ -96,6 +96,16 @@ module Legion
         Legion::Logging.info "Successfully shut down all actors (#{(Time.now - shutdown_start).round(1)}s)"
       end
 
+      def pause_actors
+        @running_instances&.each do |inst|
+          timer = inst.instance_variable_get(:@timer)
+          timer&.shutdown if timer.respond_to?(:shutdown)
+        rescue StandardError => e
+          Legion::Logging.error "pause_actors: #{e.class}: #{e.message}" if defined?(Legion::Logging)
+        end
+        Legion::Logging.warn 'All actors paused' if defined?(Legion::Logging)
+      end
+
       def load_extensions
         @extensions ||= []
         @loaded_extensions ||= []

data/lib/legion/service.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'timeout'
 require_relative 'readiness'
 require_relative 'process_role'
 
@@ -130,6 +131,7 @@ module Legion
       api_settings = Legion::Settings[:api] || {}
       @api_enabled = api && api_settings.fetch(:enabled, true)
       setup_api if @api_enabled
+      setup_network_watchdog
       Legion::Settings[:client][:ready] = true
       Legion::Events.emit('service.ready')
     end
@@ -465,13 +467,14 @@ module Legion
       Legion::Settings[:client][:shutting_down] = true
       Legion::Events.emit('service.shutting_down')
 
+      shutdown_network_watchdog
       shutdown_audit_archiver
       shutdown_api
 
       Legion::Metrics.reset! if defined?(Legion::Metrics)
 
       if defined?(Legion::Gaia) && Legion::Gaia.respond_to?(:started?) && Legion::Gaia.started?
-        Legion::Gaia.shutdown
+        shutdown_component('Gaia') { Legion::Gaia.shutdown }
         Legion::Readiness.mark_not_ready(:gaia)
       end
 
@@ -480,32 +483,33 @@ module Legion
         @cluster_leader = nil
       end
 
-      Legion::Extensions.shutdown
+      ext_timeout = Legion::Settings.dig(:extensions, :shutdown_timeout) || 15
+      shutdown_component('Extensions', timeout: ext_timeout) { Legion::Extensions.shutdown }
       Legion::Readiness.mark_not_ready(:extensions)
 
       if Legion::Settings[:llm]&.dig(:connected)
-        Legion::LLM.shutdown
+        shutdown_component('LLM') { Legion::LLM.shutdown }
         Legion::Readiness.mark_not_ready(:llm)
       end
 
       if defined?(Legion::Rbac) && Legion::Settings[:rbac]&.dig(:connected)
-        Legion::Rbac.shutdown
+        shutdown_component('Rbac') { Legion::Rbac.shutdown }
         Legion::Readiness.mark_not_ready(:rbac)
       end
 
-      Legion::Data.shutdown if Legion::Settings[:data][:connected]
+      shutdown_component('Data') { Legion::Data.shutdown } if Legion::Settings[:data][:connected]
       Legion::Readiness.mark_not_ready(:data)
 
       Legion::Leader.reset! if defined?(Legion::Leader)
 
-      Legion::Cache.shutdown
+      shutdown_component('Cache') { Legion::Cache.shutdown }
       Legion::Readiness.mark_not_ready(:cache)
 
-      Legion::Transport::Connection.shutdown
+      shutdown_component('Transport') { Legion::Transport::Connection.shutdown }
       Legion::Readiness.mark_not_ready(:transport)
 
       shutdown_mtls_rotation
-      Legion::Crypt.shutdown
+      shutdown_component('Crypt') { Legion::Crypt.shutdown }
       Legion::Readiness.mark_not_ready(:crypt)
 
       Legion::Settings[:client][:ready] = false
@@ -513,29 +517,34 @@ module Legion
     end
 
     def reload
+      return if @reloading
+
+      @reloading = true
       Legion::Logging.info 'Legion::Service.reload was called'
       Legion::Settings[:client][:ready] = false
 
+      shutdown_network_watchdog
       shutdown_api
 
       if defined?(Legion::Gaia) && Legion::Gaia.respond_to?(:started?) && Legion::Gaia.started?
-        Legion::Gaia.shutdown
+        shutdown_component('Gaia') { Legion::Gaia.shutdown }
         Legion::Readiness.mark_not_ready(:gaia)
       end
 
-      Legion::Extensions.shutdown
+      ext_timeout = Legion::Settings.dig(:extensions, :shutdown_timeout) || 15
+      shutdown_component('Extensions', timeout: ext_timeout) { Legion::Extensions.shutdown }
       Legion::Readiness.mark_not_ready(:extensions)
 
-      Legion::Data.shutdown
+      shutdown_component('Data') { Legion::Data.shutdown }
       Legion::Readiness.mark_not_ready(:data)
 
-      Legion::Cache.shutdown
+      shutdown_component('Cache') { Legion::Cache.shutdown }
       Legion::Readiness.mark_not_ready(:cache)
 
-      Legion::Transport::Connection.shutdown
+      shutdown_component('Transport') { Legion::Transport::Connection.shutdown }
       Legion::Readiness.mark_not_ready(:transport)
 
-      Legion::Crypt.shutdown
+      shutdown_component('Crypt') { Legion::Crypt.shutdown }
       Legion::Readiness.mark_not_ready(:crypt)
 
       Legion::Readiness.wait_until_not_ready(:transport, :data, :cache, :crypt)
@@ -569,9 +578,12 @@ module Legion
 
       Legion::Crypt.cs
       setup_api if @api_enabled
+      setup_network_watchdog
       Legion::Settings[:client][:ready] = true
       Legion::Events.emit('service.ready')
       Legion::Logging.info 'Legion has been reloaded'
+    ensure
+      @reloading = false
     end
 
     def load_extensions
@@ -630,6 +642,67 @@ module Legion
       nil
     end
 
+    def shutdown_component(name, timeout: 5, &)
+      Timeout.timeout(timeout, &)
+    rescue Timeout::Error
+      Legion::Logging.warn "#{name} shutdown timed out after #{timeout}s, forcing"
+    rescue StandardError => e
+      Legion::Logging.warn "#{name} shutdown error: #{e.class}: #{e.message}"
+    end
+
+    def setup_network_watchdog
+      return unless Legion::Settings.dig(:network, :watchdog, :enabled)
+
+      @consecutive_failures = Concurrent::AtomicFixnum.new(0)
+      threshold = Legion::Settings.dig(:network, :watchdog, :failure_threshold) || 5
+      interval = Legion::Settings.dig(:network, :watchdog, :check_interval) || 15
+
+      @network_watchdog = Concurrent::TimerTask.new(execution_interval: interval) do
+        if network_healthy?
+          prev = @consecutive_failures.value
+          @consecutive_failures.value = 0
+          if prev >= threshold
+            Legion::Logging.info '[Watchdog] Network restored, triggering reload'
+            Thread.new { Legion.reload } unless @reloading
+          end
+        else
+          count = @consecutive_failures.increment
+          Legion::Logging.warn "[Watchdog] Network check failed (#{count}/#{threshold})"
+          if count == threshold
+            Legion::Logging.error '[Watchdog] Network failure threshold reached, pausing actors'
+            Legion::Extensions.pause_actors if Legion::Extensions.respond_to?(:pause_actors)
+          end
+        end
+      rescue StandardError => e
+        Legion::Logging.debug "[Watchdog] check error: #{e.message}"
+      end
+      @network_watchdog.execute
+      Legion::Logging.info "[Watchdog] Network watchdog started (interval=#{interval}s, threshold=#{threshold})"
+    rescue StandardError => e
+      Legion::Logging.warn "Network watchdog setup failed: #{e.message}"
+    end
+
+    def shutdown_network_watchdog
+      @network_watchdog&.shutdown
+      @network_watchdog = nil
+    end
+
+    def network_healthy?
+      return true if defined?(Legion::Transport::Connection) && Legion::Transport::Connection.lite_mode?
+
+      checks = []
+      checks << Legion::Transport::Connection.session_open? if Legion::Settings[:transport][:connected]
+      if Legion::Settings[:data][:connected] && defined?(Legion::Data::Connection)
+        checks << (Legion::Data::Connection.sequel&.test_connection rescue false) # rubocop:disable Style/RescueModifier
+      end
+      checks << Legion::Cache.connected? if Legion::Settings[:cache][:connected] && defined?(Legion::Cache)
+      return true if checks.empty?
+
+      checks.any?
+    rescue StandardError
+      false
+    end
+
     private
 
     def port_in_use?(bind, port)

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.5.13'
+  VERSION = '1.5.15'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.5.13
+  version: 1.5.15
 platform: ruby
 authors:
 - Esity