legionio 1.5.10 → 1.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a667cd060abef4731373441c150267a5cfff9851061823edf4ba2f11af957958
-  data.tar.gz: 667fa1b3e3779215514cbade8b8062a1e5a219fdbea51bbbae4e4e5a69c43c12
+  metadata.gz: 2b5d012d4df4a245648fe489a4c998c34fa209c119b74301d209f29cdeb44977
+  data.tar.gz: 2f818144217a965f4353201773843cbfef1e151406b27996f6d493f144fa7de9
 SHA512:
-  metadata.gz: 5bae139c1dc0209987800907ce76b4c198ffff24de925e7fdfd2d2d0603bfbb6c095c4e863cc32510cac62fbf820ed850d8a05023d659a70c9bfd234c754f603
-  data.tar.gz: eea81ebd4a661ecd921aaf48c08259757ff434baea7f4685859bd2df6cac912e7ac89b09e4c64c3edc315549c485d3b46501609cd3cf2cd7d0c60a12491700c1
+  metadata.gz: e436068fa3c9159a904fd9a57434916ad49a1e332b6220c2b89c290725094da4173aadea83c0656cccb564a05b0033521ad5ee37b6e0dc054eb83fa7facf2114
+  data.tar.gz: d83cacb7a7afddfb35892ef4d1183c32cce83c64bfa53fed51d599b8eb04a99589af9fc1202a778a7389b257ea2c9fdd9a71010f2ebfb2c8b2b193b54fbe31fe

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Legion Changelog
 
+## [1.5.12] - 2026-03-25
+
+### Added
+- `GET /api/stats` endpoint — comprehensive daemon runtime stats: extensions (loaded/actor counts), gaia (status/channels/phases), transport (session/channels), cache/cache_local (pool stats), llm (provider health/routing), data/data_local (pool/tuning via legion-data stats), api (puma threads/routes)
+
+### Changed
+- Bumped gemspec dependency: legion-data >= 1.6.0 (required for `Legion::Data.stats`)
+
+## [1.5.11] - 2026-03-25
+
+### Added
+- `legionio debug` command — full diagnostic dump (16 sections: versions, doctor, config, gems, extensions, RBAC, LLM, GAIA, transport, events, Apollo, remote/local Redis, PostgreSQL, RabbitMQ, API health) output as markdown or JSON, suitable for piping to an LLM session
+- `legionio update --cleanup` flag — removes old gem versions after update via `Gem::Uninstaller` (default: no cleanup)
+
+### Fixed
+- `update_command.rb` `snapshot_versions` now uses `find_all_by_name` + max version instead of `find_by_name`, which returned the already-activated (potentially stale) gem version
+- `service.rb` `setup_api` guard prevents duplicate Puma start when `@api_thread` is already alive
+
+### Changed
+- Bumped gemspec dependencies: legion-data >= 1.5.3, legion-gaia >= 0.9.24, legion-llm >= 0.5.8, legion-tty >= 0.4.35
+
 ## [1.5.10] - 2026-03-25
 
 ### Changed

data/CLAUDE.md

@@ -633,6 +633,7 @@ rack-test, rake, rspec, rubocop, rubocop-rspec, simplecov
 | `lib/legion/telemetry.rb` | Opt-in OpenTelemetry tracing: `with_span` wrapper, `sanitize_attributes`, `record_exception` |
 | `lib/legion/metrics.rb` | Opt-in Prometheus metrics: event-driven counters, pull-based gauges, `prometheus-client` guarded |
 | `lib/legion/api/metrics.rb` | `GET /metrics` Prometheus text-format endpoint with gauge refresh |
+| `lib/legion/api/stats.rb` | `GET /api/stats` comprehensive daemon runtime stats (extensions, gaia, transport, cache, llm, data, api) |
 | `lib/legion/chat/notification_queue.rb` | Thread-safe priority queue for background notifications (critical/info/debug) |
 | `lib/legion/chat/notification_bridge.rb` | Event-driven bridge: matches Legion events to chat notifications via fnmatch patterns |
 | `lib/legion/api/middleware/auth.rb` | Auth: JWT Bearer auth middleware (real token validation, skip paths for health/ready) |

data/legionio.gemspec

@@ -54,12 +54,14 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'legion-cache', '>= 1.3.16'
   spec.add_dependency 'legion-crypt', '>= 1.4.12'
-  spec.add_dependency 'legion-data', '>= 1.5.0'
+  spec.add_dependency 'legion-data', '>= 1.6.0'
   spec.add_dependency 'legion-json', '>= 1.2.1'
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.19'
   spec.add_dependency 'legion-transport', '>= 1.4.0'
 
-  spec.add_dependency 'legion-tty', '>= 0.4.34'
+  spec.add_dependency 'legion-gaia', '>= 0.9.24'
+  spec.add_dependency 'legion-llm', '>= 0.5.8'
+  spec.add_dependency 'legion-tty', '>= 0.4.35'
   spec.add_dependency 'lex-node'
 end

data/lib/legion/api/openapi.rb

@@ -155,6 +155,7 @@ module Legion
           .merge(gaia_paths)
           .merge(apollo_paths)
           .merge(openapi_paths)
+          .merge(stats_paths)
       end
       private_class_method :paths
 
@@ -1661,6 +1662,42 @@ module Legion
         }
       end
       private_class_method :openapi_paths
+
+      def self.stats_paths
+        {
+          '/api/stats' => {
+            get: {
+              tags:        ['Stats'],
+              summary:     'Comprehensive daemon runtime stats',
+              description: 'Returns runtime statistics for all subsystems: extensions, gaia, transport, cache, llm, data, and api. ' \
+                           'Each section collects independently — one subsystem failure does not affect others.',
+              operationId: 'getStats',
+              responses:   {
+                '200' => ok_response('Stats', wrap_data('StatsObject').merge(
+                                                properties: {
+                                                  data: {
+                                                    type:       'object',
+                                                    properties: {
+                                                      extensions:  { type: 'object' },
+                                                      gaia:        { type: 'object' },
+                                                      transport:   { type: 'object' },
+                                                      cache:       { type: 'object' },
+                                                      cache_local: { type: 'object' },
+                                                      llm:         { type: 'object' },
+                                                      data:        { type: 'object' },
+                                                      data_local:  { type: 'object' },
+                                                      api:         { type: 'object' }
+                                                    }
+                                                  },
+                                                  meta: { '$ref' => '#/components/schemas/Meta' }
+                                                }
+                                              ))
+              }
+            }
+          }
+        }
+      end
+      private_class_method :stats_paths
     end
   end
 end

data/lib/legion/api/stats.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Stats
+        def self.registered(app)
+          app.get '/api/stats' do
+            result = {}
+            result[:extensions]  = Routes::Stats.collect_extensions
+            result[:gaia]        = Routes::Stats.collect_gaia
+            result[:transport]   = Routes::Stats.collect_transport
+            result[:cache]       = Routes::Stats.collect_cache
+            result[:cache_local] = Routes::Stats.collect_cache_local
+            result[:llm]         = Routes::Stats.collect_llm
+            result[:data]        = Routes::Stats.collect_data
+            result[:data_local]  = Routes::Stats.collect_data_local
+            result[:api]         = Routes::Stats.collect_api
+            json_response(result)
+          end
+        end
+
+        EXTENSION_IVARS = {
+          loaded:       :@loaded_extensions,
+          discovered:   :@extensions,
+          subscription: :@subscription_tasks,
+          every:        :@timer_tasks,
+          poll:         :@poll_tasks,
+          once:         :@once_tasks,
+          loop:         :@loop_tasks,
+          running:      :@running_instances
+        }.freeze
+
+        class << self
+          def collect_extensions
+            ext = Legion::Extensions
+            EXTENSION_IVARS.transform_values { |ivar| ext.instance_variable_get(ivar)&.count || 0 }
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_gaia
+            return { started: false } unless defined?(Legion::Gaia) && Legion::Gaia.respond_to?(:started?) && Legion::Gaia.started?
+
+            Legion::Gaia.status
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_transport
+            conn = Legion::Transport::Connection
+            connected = begin
+              Legion::Settings[:transport][:connected]
+            rescue StandardError
+              false
+            end
+            connector = defined?(Legion::Transport::TYPE) ? Legion::Transport::TYPE.to_s : 'unknown'
+
+            info = { connected: connected, connector: connector }
+
+            session = conn.session
+            if session.respond_to?(:open?) && session.open?
+              info[:session_open] = true
+              info[:channel_max] = session.channel_max if session.respond_to?(:channel_max)
+              # Bunny tracks open channels in @channels hash
+              channels = session.instance_variable_get(:@channels)
+              info[:channels_open] = channels.is_a?(Hash) ? channels.count : nil
+            else
+              info[:session_open] = false
+            end
+
+            info[:build_session_open] = conn.build_session_open?
+            info[:lite_mode] = conn.lite_mode?
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_cache
+            return { connected: false } unless defined?(Legion::Cache)
+
+            info = { connected: Legion::Cache.connected? }
+            info[:using_local]  = Legion::Cache.using_local? if Legion::Cache.respond_to?(:using_local?)
+            info[:using_memory] = Legion::Cache.instance_variable_get(:@using_memory) == true
+            info[:driver] = begin
+              Legion::Settings[:cache][:driver]
+            rescue StandardError
+              nil
+            end
+
+            if Legion::Cache.connected? && Legion::Cache.respond_to?(:size)
+              info[:pool_size] = begin
+                Legion::Cache.size
+              rescue StandardError
+                nil
+              end
+              info[:pool_available] = begin
+                Legion::Cache.available
+              rescue StandardError
+                nil
+              end
+            end
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_cache_local
+            return { connected: false } unless defined?(Legion::Cache::Local)
+
+            info = { connected: Legion::Cache::Local.connected? }
+            if Legion::Cache::Local.connected?
+              info[:pool_size] = begin
+                Legion::Cache::Local.size
+              rescue StandardError
+                nil
+              end
+              info[:pool_available] = begin
+                Legion::Cache::Local.available
+              rescue StandardError
+                nil
+              end
+            end
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_llm
+            return { started: false } unless defined?(Legion::LLM) && Legion::LLM.started?
+
+            info = { started: true }
+            s = Legion::LLM.settings
+            info[:default_model]    = s[:default_model]
+            info[:default_provider] = s[:default_provider]
+            info[:pipeline_enabled] = s[:pipeline_enabled] == true
+
+            if defined?(Legion::LLM::Router) && Legion::LLM::Router.routing_enabled?
+              info[:routing_enabled] = true
+              tracker = Legion::LLM::Router.health_tracker
+              if tracker
+                providers = s[:providers] || {}
+                info[:provider_health] = providers.each_with_object({}) do |(name, _cfg), h|
+                  h[name] = { circuit: tracker.circuit_state(name)&.to_s }
+                rescue StandardError
+                  nil
+                end
+              end
+            else
+              info[:routing_enabled] = false
+            end
+
+            if defined?(Legion::LLM::ConversationStore)
+              store = Legion::LLM::ConversationStore
+              info[:conversations] = store.respond_to?(:size) ? store.size : nil
+            end
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_data
+            return { connected: false } unless defined?(Legion::Data) && Legion::Settings[:data][:connected]
+
+            if Legion::Data.respond_to?(:stats)
+              stats = Legion::Data.stats
+              stats[:shared] || stats
+            else
+              { connected: true, adapter: begin
+                Legion::Data::Connection.adapter
+              rescue StandardError
+                nil
+              end }
+            end
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_data_local
+            return { connected: false } unless defined?(Legion::Data::Local) && Legion::Data::Local.connected?
+
+            if Legion::Data::Local.respond_to?(:stats)
+              Legion::Data::Local.stats
+            else
+              { connected: true }
+            end
+          rescue StandardError => e
+            { error: e.message }
+          end
+
+          def collect_api
+            port = Legion::Settings.dig(:api, :port) || Legion::Settings.dig(:http, :port) || 4567
+            info = { port: port }
+
+            # Puma thread pool stats if available
+            puma_server = Puma::Server.current if defined?(Puma::Server) && Puma::Server.respond_to?(:current)
+            if puma_server.respond_to?(:pool_capacity)
+              info[:puma] = {
+                pool_capacity: puma_server.pool_capacity,
+                max_threads:   puma_server.max_threads,
+                running:       puma_server.running,
+                backlog:       puma_server.backlog
+              }
+            end
+
+            info[:routes] = begin
+              Legion::API.routes.values.flatten.count
+            rescue StandardError
+              nil
+            end
+            info
+          rescue StandardError => e
+            { error: e.message }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -45,6 +45,7 @@ require_relative 'api/marketplace'
 require_relative 'api/apollo'
 require_relative 'api/costs'
 require_relative 'api/traces'
+require_relative 'api/stats'
 require_relative 'api/graphql' if defined?(GraphQL)
 
 module Legion
@@ -135,6 +136,7 @@ module Legion
     register Routes::Apollo
     register Routes::Costs
     register Routes::Traces
+    register Routes::Stats
     register Routes::GraphQL if defined?(Routes::GraphQL)
 
     use Legion::API::Middleware::RequestLogger

data/lib/legion/cli/debug_command.rb

@@ -0,0 +1,453 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'net/http'
+require 'json'
+require 'socket'
+require 'thor'
+
+module Legion
+  module CLI
+    class Debug < Thor
+      namespace 'debug'
+
+      def self.exit_on_failure?
+        true
+      end
+
+      class_option :json, type: :boolean, default: false, desc: 'Output as JSON'
+      class_option :no_color, type: :boolean, default: false, desc: 'Disable color output'
+      class_option :port, type: :numeric, default: 4567, desc: 'API port'
+      class_option :host, type: :string, default: '127.0.0.1', desc: 'API host'
+      class_option :config_dir, type: :string, desc: 'Config directory path'
+
+      desc 'dump', 'Full diagnostic dump (markdown, suitable for piping to LLM)'
+      default_task :dump
+      def dump
+        sections = collect_all_sections
+
+        output = if options[:json]
+                   ::JSON.pretty_generate(sections)
+                 else
+                   build_markdown(sections)
+                 end
+
+        puts output
+
+        path = write_dump_file(output)
+        warn "Saved to #{path}" if path
+      end
+
+      DEBUG_DIR = File.expand_path('~/.legionio/debug')
+
+      no_commands do # rubocop:disable Metrics/BlockLength
+        private
+
+        def collect_all_sections
+          sections = {}
+          sections[:versions]     = section_versions
+          sections[:doctor]       = section_doctor
+          sections[:config]       = section_config
+          sections[:gems]         = section_gems
+          sections[:extensions]   = section_extensions
+          sections[:rbac]         = section_rbac
+          sections[:llm]          = section_llm
+          sections[:gaia]         = section_gaia
+          sections[:transport]    = section_transport
+          sections[:events]       = section_events
+          sections[:apollo]       = section_apollo
+          sections[:remote_redis] = section_remote_redis
+          sections[:local_redis]  = section_local_redis
+          sections[:postgresql]   = section_postgresql
+          sections[:rabbitmq]     = section_rabbitmq
+          sections[:api_health]   = section_api_health
+          sections
+        end
+
+        def write_dump_file(output)
+          FileUtils.mkdir_p(DEBUG_DIR)
+          ext = options[:json] ? 'json' : 'md'
+          filename = "#{Time.now.utc.strftime('%Y-%m-%d_%H%M%S')}.#{ext}"
+          path = File.join(DEBUG_DIR, filename)
+          File.write(path, output)
+          path
+        rescue StandardError => e
+          warn "Warning: could not write debug file: #{e.message}"
+          nil
+        end
+
+        def api_host
+          options[:host] || '127.0.0.1'
+        end
+
+        def api_port_number
+          options[:port] || 4567
+        end
+
+        def api_get(path)
+          uri  = URI("http://#{api_host}:#{api_port_number}#{path}")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.open_timeout = 3
+          http.read_timeout = 5
+          response = http.get(uri.request_uri)
+          ::JSON.parse(response.body, symbolize_names: true)
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def load_settings
+          Connection.config_dir = options[:config_dir] if options[:config_dir]
+          Connection.log_level = 'error'
+          Connection.ensure_settings
+        rescue StandardError
+          nil
+        end
+
+        def section_versions
+          components = {}
+          components[:legionio] = defined?(Legion::VERSION) ? Legion::VERSION : 'unknown'
+          components[:ruby] = RUBY_VERSION
+          components[:platform] = RUBY_PLATFORM
+          components[:yjit] = defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
+
+          %w[legion-transport legion-cache legion-crypt legion-data
+             legion-json legion-logging legion-settings
+             legion-llm legion-gaia legion-mcp legion-rbac legion-tty].each do |gem_name|
+            spec = Gem::Specification.find_by_name(gem_name)
+            components[gem_name.to_sym] = spec.version.to_s
+          rescue Gem::MissingSpecError
+            components[gem_name.to_sym] = 'not installed'
+          end
+
+          components
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_doctor
+          load_settings
+          require 'legion/cli/doctor_command'
+          Doctor::CHECKS.map do |name|
+            check = Doctor.const_get(name).new
+            result = check.run
+            { name: result.name, status: result.status, message: result.message }
+          rescue StandardError => e
+            { name: name.to_s, status: :error, message: e.message }
+          end
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_config
+          load_settings
+          settings_hash = Legion::Settings.loader.to_hash
+          redact_deep(settings_hash)
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_gems
+          gems = {}
+          duplicates = []
+          Gem::Specification.each do |spec|
+            next unless spec.name.start_with?('legion-', 'lex-', 'legionio')
+
+            gems[spec.name] ||= []
+            gems[spec.name] << spec.version.to_s
+          end
+
+          gems.each do |name, versions|
+            duplicates << { name: name, versions: versions } if versions.size > 1
+          end
+
+          { total: gems.size, duplicates: duplicates,
+            versions: gems.transform_values { |v| v.max_by { |ver| Gem::Version.new(ver) } } }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_extensions
+          data = api_get('/api/extensions')
+          return data if data[:error]
+
+          exts = data[:data] || data[:extensions] || data
+          { count: exts.is_a?(Array) ? exts.size : nil, extensions: exts }
+        end
+
+        def section_rbac
+          api_get('/api/rbac/roles')
+        end
+
+        def section_llm
+          load_settings
+          require 'legion/llm'
+          Legion::Settings.merge_settings(:llm, Legion::LLM::Settings.default)
+          settings = Legion::LLM.settings
+          providers = settings[:providers] || {}
+          {
+            started:          defined?(Legion::LLM) && Legion::LLM.started?,
+            default_provider: settings[:default_provider],
+            default_model:    settings[:default_model],
+            providers:        providers.map { |name, cfg| { name: name, enabled: cfg[:enabled] } }
+          }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_gaia
+          status = api_get('/api/gaia/status')
+          channels = api_get('/api/gaia/channels')
+          buffer = api_get('/api/gaia/buffer')
+          sessions = api_get('/api/gaia/sessions')
+          { status: status[:data] || status, channels: channels[:data] || channels,
+            buffer: buffer[:data] || buffer, sessions: sessions[:data] || sessions }
+        end
+
+        def section_transport
+          api_get('/api/transport/status')
+        end
+
+        def section_events
+          api_get('/api/events/recent?count=20')
+        end
+
+        def section_apollo
+          api_get('/api/apollo/stats')
+        end
+
+        def section_remote_redis
+          load_settings
+          cache_cfg = Legion::Settings[:cache]
+          return { error: 'no cache config' } unless cache_cfg.is_a?(Hash) && cache_cfg[:servers]
+
+          server = cache_cfg[:servers].first
+          host, port = server.to_s.split(':')
+          password = cache_cfg[:password]
+
+          redis_info(host, port.to_i, password)
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_local_redis
+          load_settings
+          local_cfg = Legion::Settings[:cache_local]
+          return { error: 'no cache_local config' } unless local_cfg.is_a?(Hash) && local_cfg[:servers]
+
+          server = local_cfg[:servers].first
+          host, port = server.to_s.split(':')
+          password = local_cfg[:password]
+
+          redis_info(host, port.to_i, password)
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_postgresql
+          load_settings
+          data_cfg = Legion::Settings[:data]
+          return { error: 'no data config' } unless data_cfg.is_a?(Hash) && data_cfg[:creds]
+
+          creds = data_cfg[:creds]
+          require 'pg'
+          conn = PG.connect(
+            host: creds[:host], port: creds[:port] || 5432,
+            dbname: creds[:database], user: creds[:user], password: creds[:password],
+            connect_timeout: 5
+          )
+
+          db_size = conn.exec_params(
+            'SELECT pg_size_pretty(pg_database_size(current_database())) AS size'
+          ).first['size']
+          migration = conn.exec_params(
+            'SELECT version FROM schema_info ORDER BY version DESC LIMIT 1'
+          ).first
+          migration_version = migration ? migration['version'] : 'unknown'
+
+          tables = conn.exec_params(<<~SQL).to_a
+            SELECT tablename AS name,
+                   pg_size_pretty(pg_total_relation_size(quote_ident(tablename))) AS size,
+                   (SELECT n_live_tup FROM pg_stat_user_tables WHERE relname = tablename) AS rows
+            FROM pg_tables WHERE schemaname = 'public'
+            ORDER BY pg_total_relation_size(quote_ident(tablename)) DESC LIMIT 20
+          SQL
+
+          conn.close
+          { db_size: db_size, migration_version: migration_version, tables: tables }
+        rescue LoadError
+          { error: 'pg gem not available' }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_rabbitmq
+          load_settings
+          transport_cfg = Legion::Settings[:transport] || {}
+          host = transport_cfg[:host] || 'localhost'
+          mgmt_port = transport_cfg[:management_port] || 15_672
+          user = transport_cfg[:user] || 'guest'
+          pass = transport_cfg[:password] || 'guest'
+          vhost = transport_cfg[:vhost] || '/'
+
+          uri = URI("http://#{host}:#{mgmt_port}/api/overview")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.open_timeout = 3
+          http.read_timeout = 5
+          req = Net::HTTP::Get.new(uri)
+          req.basic_auth(user, pass)
+          resp = http.request(req)
+          overview = ::JSON.parse(resp.body, symbolize_names: true)
+
+          encoded_vhost = URI.encode_www_form_component(vhost)
+          queues_uri = URI("http://#{host}:#{mgmt_port}/api/queues/#{encoded_vhost}")
+          req2 = Net::HTTP::Get.new("#{queues_uri.path}?page=1&page_size=15&sort=messages&sort_reverse=true")
+          req2.basic_auth(user, pass)
+          resp2 = http.request(req2)
+          queues = ::JSON.parse(resp2.body, symbolize_names: true)
+
+          queue_list = queues.is_a?(Array) ? queues : (queues[:items] || [])
+
+          {
+            cluster_name:     overview[:cluster_name],
+            rabbitmq_version: overview[:rabbitmq_version],
+            erlang_version:   overview[:erlang_version],
+            message_stats:    overview[:message_stats],
+            queue_totals:     overview[:queue_totals],
+            object_totals:    overview[:object_totals],
+            top_queues:       queue_list.first(15).map do |q|
+              { name: q[:name], messages: q[:messages], consumers: q[:consumers] }
+            end
+          }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_api_health
+          ready = api_get('/api/ready')
+          health = api_get('/api/health')
+          capacity = api_get('/api/capacity')
+          cost = api_get('/api/cost/summary')
+          { ready: ready, health: health, capacity: capacity, cost: cost }
+        end
+
+        def redis_info(host, port, password)
+          socket = TCPSocket.new(host, port)
+          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+          if password && !password.empty?
+            socket.write("AUTH #{password}\r\n")
+            auth_resp = socket.gets
+            return { error: "AUTH failed: #{auth_resp&.strip}" } unless auth_resp&.start_with?('+OK')
+          end
+
+          info = redis_command(socket, 'INFO memory')
+          dbsize_raw = redis_command(socket, 'DBSIZE')
+
+          socket.close
+
+          memory_lines = info.lines.select { |l| l.include?(':') }.to_h { |l| l.strip.split(':', 2) }
+          dbsize = dbsize_raw.to_s.scan(/\d+/).first
+
+          {
+            used_memory_human:       memory_lines['used_memory_human'],
+            used_memory_peak_human:  memory_lines['used_memory_peak_human'],
+            maxmemory_human:         memory_lines['maxmemory_human'],
+            mem_fragmentation_ratio: memory_lines['mem_fragmentation_ratio'],
+            dbsize:                  dbsize
+          }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def redis_command(socket, cmd)
+          parts = cmd.split
+          socket.write("*#{parts.size}\r\n")
+          parts.each { |p| socket.write("$#{p.bytesize}\r\n#{p}\r\n") }
+
+          first = socket.gets
+          return '' unless first
+
+          case first[0]
+          when '+', ':' then first[1..].strip
+          when '-' then "ERROR: #{first[1..].strip}"
+          when '$'
+            len = first[1..].to_i
+            return '' if len.negative?
+
+            data = socket.read(len + 2)
+            data&.strip || ''
+          when '*'
+            count = first[1..].to_i
+            return '' if count.negative?
+
+            count.times.map { redis_read_bulk(socket) }.join("\n")
+          else
+            first.strip
+          end
+        end
+
+        def redis_read_bulk(socket)
+          header = socket.gets
+          return '' unless header&.start_with?('$')
+
+          len = header[1..].to_i
+          return '' if len.negative?
+
+          data = socket.read(len + 2)
+          data&.strip || ''
+        end
+
+        def redact_deep(obj)
+          case obj
+          when Hash
+            obj.each_with_object({}) do |(k, v), h|
+              h[k] = if k.to_s.match?(/password|secret|token|key|credential/i) && v.is_a?(String)
+                       '[REDACTED]'
+                     else
+                       redact_deep(v)
+                     end
+            end
+          when Array
+            obj.map { |v| redact_deep(v) }
+          else
+            obj
+          end
+        end
+
+        def build_markdown(sections)
+          lines = []
+          lines << '# LegionIO Diagnostic Dump'
+          lines << ''
+          lines << "Generated: #{Time.now.utc.iso8601}"
+          lines << ''
+
+          { 'Versions'                 => :versions,
+            'Doctor Checks'            => :doctor,
+            'Configuration (redacted)' => :config,
+            'Installed Gems'           => :gems,
+            'Loaded Extensions'        => :extensions,
+            'RBAC Roles'               => :rbac,
+            'LLM Status'               => :llm,
+            'GAIA Status'              => :gaia,
+            'Transport Status'         => :transport,
+            'Recent Events (last 20)'  => :events,
+            'Apollo Stats'             => :apollo,
+            'Remote Redis'             => :remote_redis,
+            'Local Redis'              => :local_redis,
+            'PostgreSQL'               => :postgresql,
+            'RabbitMQ'                 => :rabbitmq,
+            'API Health'               => :api_health }.each do |title, key|
+            lines << "## #{title}"
+            lines << ''
+            lines << '```json'
+            lines << ::JSON.pretty_generate(sections[key])
+            lines << '```'
+            lines << ''
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/update_command.rb

@@ -6,6 +6,7 @@ require 'rbconfig'
 require 'concurrent'
 require 'net/http'
 require 'json'
+require 'rubygems/uninstaller'
 
 module Legion
   module CLI
@@ -22,6 +23,7 @@ module Legion
       desc 'gems', 'Update Legion gems to latest versions (default)'
       default_task :gems
       option :dry_run, type: :boolean, default: false, desc: 'Show what would be updated without installing'
+      option :cleanup, type: :boolean, default: false, desc: 'Remove old gem versions after update'
       def gems
         out = formatter
         gem_bin = File.join(RbConfig::CONFIG['bindir'], 'gem')
@@ -44,6 +46,8 @@ module Legion
         else
           display_results(out, results, before, after)
         end
+
+        cleanup_old_gems(out, target_gems) if options[:cleanup] && !options[:dry_run]
       end
 
       no_commands do
@@ -66,11 +70,12 @@ module Legion
 
         def snapshot_versions(gem_names)
           gem_names.each_with_object({}) do |name, hash|
-            spec = Gem::Specification.find_by_name(name)
-            hash[name] = spec.version.to_s
-          rescue Gem::MissingSpecError => e
-            Legion::Logging.debug("UpdateCommand#snapshot_versions gem #{name} not found: #{e.message}") if defined?(Legion::Logging)
-            hash[name] = nil
+            specs = Gem::Specification.find_all_by_name(name)
+            hash[name] = if specs.empty?
+                           nil
+                         else
+                           specs.map(&:version).max.to_s
+                         end
           end
         end
 
@@ -174,6 +179,39 @@ module Legion
           suggest_detect(out)
         end
 
+        def cleanup_old_gems(out, gem_names)
+          Gem::Specification.reset
+          cleaned = 0
+
+          gem_names.each do |name|
+            specs = Gem::Specification.find_all_by_name(name).sort_by(&:version)
+            next if specs.size <= 1
+
+            latest = specs.pop
+            specs.each do |old_spec|
+              Gem::Uninstaller.new(
+                old_spec.name,
+                version:            old_spec.version,
+                ignore:             true,
+                executables:        false,
+                force:              true,
+                abort_on_dependent: false
+              ).uninstall
+              out.success("  Cleaned #{old_spec.name}-#{old_spec.version} (keeping #{latest.version})")
+              cleaned += 1
+            rescue StandardError => e
+              out.error("  Failed to clean #{old_spec.name}-#{old_spec.version}: #{e.message}")
+            end
+          end
+
+          out.spacer
+          if cleaned.positive?
+            out.success("Cleaned #{cleaned} old gem version(s)")
+          else
+            puts 'No old gem versions to clean'
+          end
+        end
+
         def suggest_detect(out)
           require 'legion/extensions/detect'
           missing = Legion::Extensions::Detect.missing

data/lib/legion/cli.rb

@@ -62,6 +62,7 @@ module Legion
     autoload :Apollo,      'legion/cli/apollo_command'
     autoload :TraceCommand, 'legion/cli/trace_command'
     autoload :Features,     'legion/cli/features_command'
+    autoload :Debug,        'legion/cli/debug_command'
 
     class Main < Thor
       def self.exit_on_failure?
@@ -342,6 +343,9 @@ module Legion
       desc 'features SUBCOMMAND', 'Install feature bundles (interactive selector)'
       subcommand 'features', Legion::CLI::Features
 
+      desc 'debug', 'Diagnostic dump for troubleshooting (pipe to LLM for analysis)'
+      subcommand 'debug', Legion::CLI::Debug
+
       desc 'tree', 'Print a tree of all available commands'
       def tree
         legion_print_command_tree(self.class, 'legion', '')

data/lib/legion/service.rb

@@ -236,6 +236,11 @@ module Legion
     end
 
     def setup_api
+      if @api_thread&.alive?
+        Legion::Logging.warn 'API already running, skipping duplicate setup_api call'
+        return
+      end
+
       require 'legion/api'
       api_settings = Legion::Settings[:api] || {}
       port = api_settings[:port] || 4567

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.5.10
+  version: 1.5.12
 platform: ruby
 authors:
 - Esity
@@ -253,14 +253,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: legion-json
   requirement: !ruby/object:Gem::Requirement
@@ -317,20 +317,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.24
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.24
+- !ruby/object:Gem::Dependency
+  name: legion-llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.8
 - !ruby/object:Gem::Dependency
   name: legion-tty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.34
+        version: 0.4.35
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.34
+        version: 0.4.35
 - !ruby/object:Gem::Dependency
   name: lex-node
   requirement: !ruby/object:Gem::Requirement
@@ -451,6 +479,7 @@ files:
 - lib/legion/api/relationships.rb
 - lib/legion/api/schedules.rb
 - lib/legion/api/settings.rb
+- lib/legion/api/stats.rb
 - lib/legion/api/tasks.rb
 - lib/legion/api/tenants.rb
 - lib/legion/api/token.rb
@@ -555,6 +584,7 @@ files:
 - lib/legion/cli/dashboard/renderer.rb
 - lib/legion/cli/dashboard_command.rb
 - lib/legion/cli/dataset_command.rb
+- lib/legion/cli/debug_command.rb
 - lib/legion/cli/detect_command.rb
 - lib/legion/cli/do_command.rb
 - lib/legion/cli/docs_command.rb