legionio 1.5.8 → 1.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd1e62d0c34e503458b9648de476a15dd5c03a163bb506db8a4723da486aef24
-  data.tar.gz: 43147d5ba26541cf62f3d5255ce973480fccb1362a5d8daf224ff16b82b6e55f
+  metadata.gz: e7ed91b745c34247336b6d3c1d040b6773d21d531445ea7b42149cdbf4bfc170
+  data.tar.gz: 1eedc2e5b6011c0ed4a9b35d65e9be14bb474b46851720a30667e1167060633a
 SHA512:
-  metadata.gz: af364276c4d9589d8ee414a2e563640be7c49c472a0ef566a035b502198d7396acd055f42f576756a9bbd0beda57f09e0bb098bcb15b387da8dbf31baa728120
-  data.tar.gz: 44671d558a7e20e9dbda648e0ad71efd0c9db546d37507c0e21d3367a9e4c896b79476f8158597e36eb310c46415d1084dea9cfbe389405b7940a74c10609c63
+  metadata.gz: d89facba54ed5b92539bb40615837412b6e091283ce13fcfa6a4ac460fd204a80e103327c873afedaf62f81aa45a6a4390f97c6a945841b8fef9cc25c6a7a699
+  data.tar.gz: c298fc10efbc5a2d0a3ce69ccdc2c36976fc2f86700f3d7589ac060e97a3517cc47ea22807c9755da25390d8b2d22080abe523feba9e4b3aa6406a0ddd83ce0d

data/.rubocop.yml

@@ -52,6 +52,7 @@ Metrics/BlockLength:
     - 'lib/legion/cli/failover_command.rb'
     - 'lib/legion/cli/setup_command.rb'
     - 'lib/legion/cli/trace_command.rb'
+    - 'lib/legion/cli/features_command.rb'
 
 Metrics/AbcSize:
   Max: 60

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Legion Changelog
 
+## [1.5.9] - 2026-03-25
+
+### Fixed
+- `Subscription#activate` nil guard — skip activate when `@consumer` is nil (prepare failed silently)
+- `Extensions#shutdown` tracks real actor instances in `@running_instances`, cancels them with deadline-based drain
+- `Extensions::Helpers::Base` runner_class derivation improvements for self-contained actors
+
+### Changed
+- Bumped gemspec dependencies: legion-cache >= 1.3.16, legion-settings >= 1.3.19, legion-transport >= 1.4.0, legion-mcp >= 0.5.1
+
 ## [1.5.8] - 2026-03-24
 
 ### Added

data/legionio.gemspec

@@ -52,13 +52,13 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'thor', '>= 1.3'
   spec.add_dependency 'tty-spinner', '~> 0.9'
 
-  spec.add_dependency 'legion-cache', '>= 1.3.11'
-  spec.add_dependency 'legion-crypt', '>= 1.4.9'
+  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-json', '>= 1.2.1'
   spec.add_dependency 'legion-logging', '>= 1.3.2'
-  spec.add_dependency 'legion-settings', '>= 1.3.14'
-  spec.add_dependency 'legion-transport', '>= 1.3.11'
+  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 'lex-node'

data/lib/legion/cli/features_command.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'thor'
+require 'rbconfig'
+require 'legion/cli/output'
+
+module Legion
+  module CLI
+    class Features < Thor
+      namespace 'features'
+
+      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'
+
+      BUNDLES = {
+        tasking:       {
+          label:       'Tasking Engine',
+          description: 'Task scheduling, chaining, conditioning, and metering',
+          gems:        %w[lex-tasker lex-scheduler lex-lex lex-conditioner lex-transformer lex-health lex-metering]
+        },
+        cognitive:     {
+          label:       'Cognitive / Agentic',
+          description: 'Full GAIA cognitive stack (13 agentic domains + tick + mesh + apollo)',
+          gems:        %w[legion-gaia]
+        },
+        ai:            {
+          label:       'AI / LLM',
+          description: 'LLM routing, provider integration, and MCP tools',
+          gems:        %w[legion-llm legion-mcp]
+        },
+        observability: {
+          label:       'Observability',
+          description: 'Telemetry, logging, anomaly detection, and webhooks',
+          gems:        %w[lex-telemetry lex-log lex-webhook lex-detect]
+        },
+        governance:    {
+          label:       'Governance & Security',
+          description: 'RBAC, audit trails, FinOps, PII protection, and lifecycle governance',
+          gems:        %w[lex-governance lex-audit lex-finops lex-privatecore]
+        },
+        channels:      {
+          label:       'Chat Channels',
+          description: 'Slack, Microsoft Teams, and GitHub chat adapters',
+          gems:        %w[lex-slack lex-microsoft_teams lex-github]
+        },
+        devtools:      {
+          label:       'Development Tools',
+          description: 'Eval gating, datasets, prompt templates, autofix, and mind-growth',
+          gems:        %w[lex-eval lex-dataset lex-prompt lex-autofix lex-mind-growth]
+        },
+        swarm:         {
+          label:       'Swarm / Multi-Agent',
+          description: 'Multi-agent orchestration, GitHub swarm pipeline, and ACP adapter',
+          gems:        %w[lex-swarm lex-swarm-github lex-adapter lex-acp]
+        },
+        services:      {
+          label:       'Service Integrations',
+          description: 'HTTP, Vault, and Consul service connectors',
+          gems:        %w[lex-http lex-vault lex-consul]
+        }
+      }.freeze
+
+      desc 'install', 'Interactively select and install feature bundles'
+      option :dry_run, type: :boolean, default: false, desc: 'Show what would be installed without installing'
+      option :all,     type: :boolean, default: false, desc: 'Install all feature bundles'
+      def install
+        out = formatter
+        selected = options[:all] ? BUNDLES.keys : prompt_bundle_selection(out)
+
+        return out.error('No bundles selected') if selected.empty?
+
+        gems = resolve_gems(selected)
+        installed, missing = partition_gems(gems)
+
+        if missing.empty?
+          report_all_present(out, selected, installed)
+        elsif options[:dry_run]
+          report_dry_run(out, selected, installed, missing)
+        else
+          execute_install(out, selected, installed, missing)
+        end
+      end
+
+      desc 'list', 'Show available feature bundles and their install status'
+      def list
+        out = formatter
+        statuses = bundle_statuses
+
+        if options[:json]
+          out.json(bundles: statuses)
+        else
+          out.header('Feature Bundles')
+          out.spacer
+          statuses.each { |s| print_bundle_status(out, s) }
+          out.spacer
+          installed_count = statuses.count { |s| s[:missing].empty? }
+          puts "  #{installed_count} of #{statuses.size} bundle(s) fully installed"
+        end
+      end
+
+      no_commands do
+        def formatter
+          @formatter ||= Output::Formatter.new(
+            json:  options[:json],
+            color: !options[:no_color]
+          )
+        end
+
+        private
+
+        def prompt_bundle_selection(out)
+          require 'tty-prompt'
+          prompt = ::TTY::Prompt.new
+          statuses = bundle_statuses
+
+          choices = statuses.map do |s|
+            icon = s[:missing].empty? ? '(installed)' : "(#{s[:missing].size} gem(s) to install)"
+            { name: "#{s[:label]}  #{icon}  - #{s[:description]}", value: s[:name] }
+          end
+          choices << { name: 'Everything  - install all bundles above', value: :everything }
+
+          out.header('Legion Feature Bundles')
+          out.spacer
+
+          selected = prompt.multi_select('Select bundles to install:', choices, per_page: 12,
+                                                                                echo:     false,
+                                                                                min:      1)
+          return BUNDLES.keys if selected.include?(:everything)
+
+          selected
+        rescue ::TTY::Reader::InputInterrupt, Interrupt
+          out.spacer
+          puts '  Cancelled.'
+          []
+        end
+
+        def resolve_gems(bundle_keys)
+          bundle_keys.flat_map { |key| BUNDLES[key][:gems] }.uniq.sort
+        end
+
+        def partition_gems(gem_names)
+          installed = []
+          missing = []
+          gem_names.each do |name|
+            Gem::Specification.find_by_name(name)
+            installed << name
+          rescue Gem::MissingSpecError
+            missing << name
+          end
+          [installed, missing]
+        end
+
+        def gem_version(name)
+          Gem::Specification.find_by_name(name).version.to_s
+        rescue Gem::MissingSpecError
+          nil
+        end
+
+        def bundle_statuses
+          BUNDLES.map do |name, bundle|
+            installed, missing = partition_gems(bundle[:gems])
+            {
+              name:        name,
+              label:       bundle[:label],
+              description: bundle[:description],
+              installed:   installed.map { |g| { name: g, version: gem_version(g) } },
+              missing:     missing
+            }
+          end
+        end
+
+        def print_bundle_status(out, status)
+          icon = if status[:missing].empty?
+                   out.colorize('installed', :success)
+                 else
+                   out.colorize("#{status[:missing].size} missing", :muted)
+                 end
+          puts "  #{out.colorize(status[:label].ljust(24), :label)} #{icon}"
+          status[:installed].each do |g|
+            puts "    #{out.colorize(g[:name], :success)} #{g[:version]}"
+          end
+          status[:missing].each do |g|
+            puts "    #{out.colorize(g, :muted)} (not installed)"
+          end
+        end
+
+        def report_all_present(out, selected, installed)
+          labels = selected.map { |k| BUNDLES[k][:label] }.join(', ')
+          if options[:json]
+            out.json(status: 'already_installed', bundles: selected,
+                     gems: installed.map { |g| { name: g, version: gem_version(g) } })
+          else
+            out.success("All gems already installed for: #{labels}")
+            installed.each { |g| puts "  #{g} #{gem_version(g)}" }
+          end
+        end
+
+        def report_dry_run(out, selected, installed, missing)
+          labels = selected.map { |k| BUNDLES[k][:label] }.join(', ')
+          if options[:json]
+            out.json(status: 'dry_run', bundles: selected, to_install: missing,
+                     already_installed: installed.map { |g| { name: g, version: gem_version(g) } })
+          else
+            out.header("Feature install dry run: #{labels}")
+            out.spacer
+            missing.each { |g| puts "  #{out.colorize('install', :accent)} #{g}" }
+            installed.each { |g| puts "  #{out.colorize('skip', :muted)} #{g} #{gem_version(g)} (already installed)" }
+          end
+        end
+
+        def execute_install(out, selected, installed, missing)
+          labels = selected.map { |k| BUNDLES[k][:label] }.join(', ')
+          out.header("Installing: #{labels}") unless options[:json]
+          out.spacer unless options[:json]
+          puts "  #{missing.size} gem(s) to install, #{installed.size} already present" unless options[:json]
+          out.spacer unless options[:json]
+
+          gem_bin = File.join(RbConfig::CONFIG['bindir'], 'gem')
+          results = missing.map { |g| install_gem(g, gem_bin, out) }
+
+          Gem::Specification.reset
+          successes, failures = results.partition { |r| r[:status] == 'installed' }
+
+          if options[:json]
+            out.json(bundles: selected, installed: successes, failed: failures,
+                     already_present: installed.map { |g| { name: g, version: gem_version(g) } })
+          else
+            out.spacer
+            if failures.empty?
+              out.success("#{successes.size} gem(s) installed successfully")
+            else
+              out.error("#{failures.size} gem(s) failed to install")
+              failures.each { |f| puts "  #{f[:name]}: #{f[:error]}" }
+              out.spacer
+              out.success("#{successes.size} gem(s) installed") unless successes.empty?
+            end
+            suggest_next_steps(out, selected)
+          end
+        end
+
+        def install_gem(name, gem_bin, out)
+          puts "  Installing #{name}..." unless options[:json]
+          output = `#{gem_bin} install #{name} --no-document 2>&1`
+          if $CHILD_STATUS.success?
+            out.success("  #{name} installed") unless options[:json]
+            { name: name, status: 'installed' }
+          else
+            out.error("  #{name} failed") unless options[:json]
+            { name: name, status: 'failed', error: output.strip.lines.last&.strip }
+          end
+        end
+
+        def suggest_next_steps(out, selected)
+          out.spacer
+          puts '  Next steps:'
+          if selected.include?(:cognitive) || selected.include?(:ai)
+            puts '    legion start          # full daemon with cognitive stack'
+            puts '    legion start --lite   # single-process, no external services'
+            puts '    legion chat           # interactive AI conversation'
+          end
+          puts '    legion features list   # verify installed bundles'
+          puts '    legion doctor          # check environment health'
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli.rb

@@ -61,6 +61,7 @@ module Legion
     autoload :Failover,    'legion/cli/failover_command'
     autoload :Apollo,      'legion/cli/apollo_command'
     autoload :TraceCommand, 'legion/cli/trace_command'
+    autoload :Features,     'legion/cli/features_command'
 
     class Main < Thor
       def self.exit_on_failure?
@@ -338,6 +339,9 @@ module Legion
       desc 'trace SUBCOMMAND', 'Natural language trace search via LLM'
       subcommand 'trace', Legion::CLI::TraceCommand
 
+      desc 'features SUBCOMMAND', 'Install feature bundles (interactive selector)'
+      subcommand 'features', Legion::CLI::Features
+
       desc 'tree', 'Print a tree of all available commands'
       def tree
         legion_print_command_tree(self.class, 'legion', '')

data/lib/legion/extensions/actors/subscription.rb

@@ -86,6 +86,10 @@ module Legion
         end
 
         def activate
+          unless @consumer
+            log.warn "[Subscription] skipping activate for #{lex_name}/#{runner_name}: no consumer (prepare failed?)"
+            return
+          end
           @queue.subscribe_with(@consumer)
           log.info "[Subscription] activated: #{lex_name}/#{runner_name} (consumer registered)"
         end

data/lib/legion/extensions/helpers/base.rb

@@ -96,8 +96,13 @@ module Legion
 
         def full_path
           @full_path ||= begin
-            gem_name = "lex-#{segments.join('-')}"
-            gem_dir = Gem::Specification.find_by_name(gem_name).gem_dir
+            base_name = segments.join('-')
+            gem_name = "lex-#{base_name}"
+            gem_dir = begin
+              Gem::Specification.find_by_name(gem_name).gem_dir
+            rescue Gem::MissingSpecError
+              Gem::Specification.find_by_name("lex-#{base_name.tr('_', '-')}").gem_dir
+            end
             require_path = Helpers::Segments.derive_require_path(gem_name)
             "#{gem_dir}/lib/#{require_path}"
           end

data/lib/legion/extensions/transport.rb

@@ -106,12 +106,12 @@ module Legion
 
       def bind_e_to_q(to:, from: default_exchange, routing_key: nil, **)
         if from.is_a? String
-          from = "#{transport_class}::Exchanges::#{from.split('_').collect(&:capitalize).join}" unless from.include?('::')
+          from = "#{transport_class}::Exchanges::#{from.tr('.', '_').split('_').collect(&:capitalize).join}" unless from.include?('::')
           auto_create_exchange(from) unless Object.const_defined? from
         end
 
         if to.is_a? String
-          to = "#{transport_class}::Queues::#{to.split('_').collect(&:capitalize).join}" unless to.include?('::')
+          to = "#{transport_class}::Queues::#{to.tr('.', '_').split('_').collect(&:capitalize).join}" unless to.include?('::')
           auto_create_queue(to) unless Object.const_defined?(to)
         end
 

data/lib/legion/extensions.rb

@@ -21,6 +21,7 @@ module Legion
         @subscription_tasks = []
         @local_tasks = []
         @actors = []
+        @running_instances = Concurrent::Array.new
         @pending_actors = Concurrent::Array.new
 
         find_extensions
@@ -31,9 +32,12 @@ module Legion
 
       attr_reader :local_tasks
 
-      def shutdown # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def shutdown # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
         return nil if @loaded_extensions.nil?
 
+        deadline = Legion::Settings.dig(:extensions, :shutdown_timeout) || 15
+        shutdown_start = Time.now
+
         @loaded_extensions.each { |name| Catalog.transition(name, :stopping) }
 
         if @subscription_pool
@@ -42,22 +46,54 @@ module Legion
           @subscription_pool = nil
         end
 
-        @subscription_tasks.each do |task|
-          task[:running_class]&.new&.cancel if task[:running_class].is_a?(Class)
+        # Cancel all running instances (real objects, not new instances)
+        @running_instances&.each do |instance|
+          instance.cancel if instance.respond_to?(:cancel)
         rescue StandardError => e
           Legion::Logging.debug "Extension shutdown cancel failed: #{e.message}" if defined?(Legion::Logging)
         end
 
-        @loop_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
-        @once_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
-        @timer_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
-        @poll_tasks.each { |task| task[:running_class].cancel if task[:running_class].respond_to?(:cancel) }
+        # Wait for in-flight work to drain, up to deadline
+        remaining = deadline - (Time.now - shutdown_start)
+        if remaining.positive?
+          drain_start = Time.now
+          loop do
+            elapsed = Time.now - drain_start
+            break if elapsed >= remaining
+
+            still_active = @running_instances&.any? do |inst|
+              (inst.respond_to?(:channel) && inst.instance_variable_get(:@queue)&.channel&.open?) ||
+                (inst.instance_variable_get(:@timer).respond_to?(:running?) && inst.instance_variable_get(:@timer).running?) ||
+                (inst.instance_variable_get(:@loop) == true)
+            end
+            break unless still_active
+
+            sleep 0.25
+          end
+        end
+
+        # Force-close any channels still open after deadline
+        elapsed = Time.now - shutdown_start
+        if elapsed >= deadline
+          Legion::Logging.warn "Shutdown deadline (#{deadline}s) reached, force-closing remaining actors" if defined?(Legion::Logging)
+          @running_instances&.each do |inst|
+            queue = inst.instance_variable_get(:@queue)
+            queue&.channel&.close if queue&.channel.respond_to?(:close) && queue.channel.open?
+            timer = inst.instance_variable_get(:@timer)
+            timer&.kill if timer.respond_to?(:kill)
+            inst.instance_variable_set(:@loop, false) if inst.instance_variable_defined?(:@loop)
+          rescue StandardError => e
+            Legion::Logging.debug "Force-close failed: #{e.message}" if defined?(Legion::Logging)
+          end
+        end
+
+        @running_instances&.clear
 
         @loaded_extensions.each do |name|
           Catalog.transition(name, :stopped)
           unregister_capabilities(name)
         end
-        Legion::Logging.info 'Successfully shut down all actors'
+        Legion::Logging.info "Successfully shut down all actors (#{(Time.now - shutdown_start).round(1)}s)"
       end
 
       def load_extensions
@@ -276,12 +312,16 @@ module Legion
 
         if actor_class.ancestors.include? Legion::Extensions::Actors::Every
           @timer_tasks.push(extension_hash)
+          @running_instances << extension_hash[:running_class]
         elsif actor_class.ancestors.include? Legion::Extensions::Actors::Once
           @once_tasks.push(extension_hash)
+          @running_instances << extension_hash[:running_class]
         elsif actor_class.ancestors.include? Legion::Extensions::Actors::Loop
           @loop_tasks.push(extension_hash)
+          @running_instances << extension_hash[:running_class]
         elsif actor_class.ancestors.include? Legion::Extensions::Actors::Poll
           @poll_tasks.push(extension_hash)
+          @running_instances << extension_hash[:running_class]
         elsif actor_class.ancestors.include? Legion::Extensions::Actors::Subscription
           hook_subscription_actors_pooled([extension_hash])
         else
@@ -368,6 +408,7 @@ module Legion
 
           begin
             entry[:instance].activate if entry[:instance].respond_to?(:activate)
+            @running_instances << entry[:instance]
           rescue StandardError => e
             ext_name = entry[:actor_hash][:extension_name]
             Legion::Logging.error "[Subscription] activate failed for #{ext_name}: #{e.message}" if defined?(Legion::Logging)
@@ -709,8 +750,11 @@ module Legion
         segments = Helpers::Segments.derive_segments(gem_name)
         tier     = category == :default ? 5 : (categories.dig(category, :tier) || 5)
 
-        # Multi-segment gem names always need nesting for correct require paths
+        # Multi-segment gem names: check if the gem actually uses nested directories
+        # (e.g. lex-agentic-memory -> agentic/memory/) or flat underscored naming
+        # (e.g. lex-swarm-github -> swarm_github.rb). Probe the gem's lib/ to decide.
         nesting = true if segments.length > 1
+        nesting = probe_nesting(gem_name, segments) if nesting && segments.length > 1
 
         if nesting
           const_path   = Helpers::Segments.derive_const_path(gem_name)
@@ -725,6 +769,19 @@ module Legion
           segments: segments, const_path: const_path, require_path: require_path }
       end
 
+      def probe_nesting(gem_name, segments)
+        gem_dir = Gem::Specification.find_by_name(gem_name).gem_dir
+        nested_path = "#{gem_dir}/lib/legion/extensions/#{segments.join('/')}.rb"
+        return true if File.exist?(nested_path)
+
+        flat_path = "#{gem_dir}/lib/legion/extensions/#{segments.join('_')}.rb"
+        return false if File.exist?(flat_path)
+
+        true # default to nested if neither found
+      rescue Gem::MissingSpecError
+        true
+      end
+
       def default_category_registry
         {
           core:    { type: :list, tier: 1 },

data/lib/legion/service.rb

@@ -319,6 +319,7 @@ module Legion
     def register_logging_hooks
       return unless defined?(Legion::Transport::Connection)
       return unless Legion::Transport::Connection.session_open?
+      return unless Legion::Transport::Connection.respond_to?(:log_channel)
 
       log_ch = Legion::Transport::Connection.log_channel
       unless log_ch
@@ -327,7 +328,7 @@ module Legion
       end
 
       require 'legion/transport/exchanges/logging' unless defined?(Legion::Transport::Exchanges::Logging)
-      exchange = Legion::Transport::Exchanges::Logging.new(channel: log_ch)
+      exchange = Legion::Transport::Exchanges::Logging.new('legion.logging', channel: log_ch)
 
       %i[fatal error warn].each do |level|
         Legion::Logging.send(:"on_#{level}") do |event|

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.5.8
+  version: 1.5.9
 platform: ruby
 authors:
 - Esity
@@ -225,28 +225,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.11
+        version: 1.3.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.11
+        version: 1.3.16
 - !ruby/object:Gem::Dependency
   name: legion-crypt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.9
+        version: 1.4.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.9
+        version: 1.4.12
 - !ruby/object:Gem::Dependency
   name: legion-data
   requirement: !ruby/object:Gem::Requirement
@@ -295,28 +295,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.14
+        version: 1.3.19
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.14
+        version: 1.3.19
 - !ruby/object:Gem::Dependency
   name: legion-transport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.11
+        version: 1.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.11
+        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: legion-tty
   requirement: !ruby/object:Gem::Requirement
@@ -576,6 +576,7 @@ files:
 - lib/legion/cli/error_handler.rb
 - lib/legion/cli/eval_command.rb
 - lib/legion/cli/failover_command.rb
+- lib/legion/cli/features_command.rb
 - lib/legion/cli/function.rb
 - lib/legion/cli/gaia_command.rb
 - lib/legion/cli/generate_command.rb