legionio 1.7.17 → 1.7.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fc7545d6fe4e3dc832eba2265dc27fed7546fb3d770dec04b4375b35505479f
-  data.tar.gz: 513b2ff1093560b1d88c427b176d6f27959a6c94abd3106173d462d29f8cd69c
+  metadata.gz: c2114c2b32ae4dbc1650bef546391f6abb1499a0b9d96d577739503c47caba79
+  data.tar.gz: 1e95267b23de0b635ffb32c9f745f58fe0bac63aa7d806a6581e3557b9b1aad6
 SHA512:
-  metadata.gz: b6de374974924d397249494b4aed6ff9e99263116a36d47226530c12653d672371565d060b65913d249fce4d0ed808fd6ffae45a669a6e4b1b67d87a056dcbe8
-  data.tar.gz: 2d64efa40365a2da40fcc97de5173e2c3bfd3458e8adf861a0efde9c35514d7b876ab200f2d5648ca68f08f5de879c29dde2c4d5c3f53d9c2240ae8f4575debe
+  metadata.gz: 56c140c38d73a16c97574b405c4f27bdb91de199758692e76aecd0ec55afad66acab08fc011cf31a658df408cfcf8506e5e2971f4fbe92a4276e8856153a7481
+  data.tar.gz: 903faf2b78e2f27e1176e03558138f58ee9e6bdfcc34ac3f61c8c933424a0f7a0c641ba97d38d27c527b41cad93c9d8f69bffb64fed8a032a5d1aeb2bd6cb5ff

data/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [1.7.19] - 2026-04-06
+
+### Added
+- `ALWAYS_LOADED` constant in `Tools::Discovery` — pins apollo/knowledge and eval/evaluation runners to always-loaded regardless of extension DSL
+- `always_loaded_names` method on `Tools::Registry` returning names of all non-deferred registered tools
+
+### Changed
+- Tool name format changed from dot-separated to dash-separated (`legion-ext-runner-func`) for LLM provider compatibility
+- Reduced noisy debug logging in `Tools::Discovery` and `Tools::Registry`
+
+## [1.7.18] - 2026-04-06
+
+### Added
+- Multi-phase extension loading: identity providers (`lex-identity-*`) load in phase 0 before all other extensions in phase 1
+- `identity` category in extension registry with prefix matching for `lex-identity-*` gems at tier 0, phase 0
+- `group_by_phase` method groups discovered extensions by phase from the category registry
+- `load_phase_extensions` replaces `load_extensions` — scopes parallel loading to a subset of entries per phase
+- `hook_phase_actors` replaces `hook_all_actors` — hooks deferred actors after each phase completes
+- Per-phase logging during extension loading shows cumulative actor counts
+
+### Changed
+- `hook_extensions` now iterates phases sequentially (phase 0 then phase 1), running full load+hook cycle per phase
+- `default_category_registry` includes `phase:` key on all categories; all non-identity categories default to phase 1
+- Catalog transitions (`transition(:running)` + `flush_persisted_transitions`) happen after all phases complete
+- Reserved prefixes list now includes `identity`
+
 ### Added
 - `Legion::Tools::Base` - canonical tool base class with DSL
 - `Legion::Tools::Registry` - always/deferred tool classification

data/CLAUDE.md

@@ -9,7 +9,7 @@ The primary gem for the LegionIO framework. An extensible async job engine for s
 
 **GitHub**: https://github.com/LegionIO/LegionIO
 **Gem**: `legionio`
-**Version**: 1.6.0
+**Version**: 1.7.18
 **License**: Apache-2.0
 **Docker**: `legionio/legion`
 **Ruby**: >= 3.4
@@ -51,14 +51,14 @@ Legion.start
       ├── 10. setup_gaia         (legion-gaia, cognitive coordination layer, optional)
       ├── 11. setup_telemetry    (OpenTelemetry, optional)
       ├── 12. setup_supervision  (process supervision)
-      ├── 13. load_extensions    (two-phase parallel: require+autobuild on FixedThreadPool, then hook_all_actors)
+      ├── 13. load_extensions    (multi-phase: phase 0 (identity providers) loads and hooks actors first, then phase 1 (everything else))
       ├── 14. Legion::Crypt.cs   (distribute cluster secret)
       └── 15. setup_api          (start Sinatra/Puma on port 4567)
 ```
 
 Each phase calls `Legion::Readiness.mark_ready(:component)`. All phases are individually toggleable via `Service.new(transport: false, ...)`.
 
-Extension loading is two-phase and parallel: all extensions are `require`d and `autobuild` runs concurrently on a `Concurrent::FixedThreadPool(min(count, extensions.parallel_pool_size))`, collecting actors into a thread-safe `Concurrent::Array` of `@pending_actors`. Pool size defaults to 24, configurable via `Legion::Settings[:extensions][:parallel_pool_size]`. After all extensions are loaded, `hook_all_actors` starts AMQP subscriptions, timers, and other actor types sequentially. This prevents race conditions where early extensions start ticking while later ones haven't loaded yet. Thread safety relies on ThreadLocal AMQP channels, per-extension Settings keys, and sequential post-processing of Catalog transitions and Registry writes.
+Extension loading is multi-phase and parallel: `hook_extensions` calls `group_by_phase` to partition discovered extensions by phase number (from the category registry), then iterates phases sequentially. Phase 0 contains identity providers (`lex-identity-*` gems, category `:identity`, tier 0); phase 1 contains all other extensions. Within each phase, extensions are `require`d and `autobuild` runs concurrently on a `Concurrent::FixedThreadPool(min(count, extensions.parallel_pool_size))`, collecting actors into a thread-safe `Concurrent::Array` of `@pending_actors`. Pool size defaults to 24, configurable via `Legion::Settings[:extensions][:parallel_pool_size]`. After each phase's extensions are loaded, `hook_phase_actors` starts AMQP subscriptions, timers, and other actor types for that phase sequentially — ensuring identity providers are fully running before any other extension boots. Catalog transitions (`transition(:running)` and `flush_persisted_transitions`) happen after all phases complete. Thread safety relies on ThreadLocal AMQP channels, per-extension Settings keys, and sequential post-processing of Catalog transitions and Registry writes.
 
 ### Reload Sequence
 
@@ -85,7 +85,7 @@ Legion (lib/legion.rb)
 │                      # Ingress.run(payload:, runner_class:, function:, source:)
 │                      # Ingress.normalize returns message hash without executing
 ├── Extensions         # LEX discovery, loading, and lifecycle management
-│   ├── Core           # Mixin: data_required?, cache_required?, crypt_required?, etc.
+│   ├── Core           # Mixin: data_required?, cache_required?, crypt_required?, mcp_tools?, mcp_tools_deferred?, etc.
 │   ├── Actors/        # Actor execution modes
 │   │   ├── Base       # Base actor class
 │   │   ├── Every      # Run at interval (timer)
@@ -96,7 +96,7 @@ Legion (lib/legion.rb)
 │   │   └── Nothing    # No-op actor
 │   ├── Builders/      # Build actors and runners from LEX definitions
 │   │   ├── Actors     # Build actors from extension definitions
-│   │   ├── Runners    # Build runners from extension definitions (stores runner_module ref)
+│   │   ├── Runners    # Build runners from extension definitions; exposes `runner_modules` accessor for Discovery
 │   │   ├── Helpers    # Builder utilities
 │   │   ├── Hooks      # Webhook hook system builder
 │   │   └── Routes     # Auto-route builder: introspects runners, registers POST /api/extensions/* routes
@@ -149,7 +149,17 @@ Legion (lib/legion.rb)
 │                      # Populated by Builders::Routes during autobuild via LexDispatch
 │
 ├── MCP (legion-mcp gem)  # Extracted to standalone gem — see legion-mcp/CLAUDE.md
-│   └── (58 tools, 2 resources, TierRouter, PatternStore, ContextGuard, Observer, EmbeddingIndex)
+│   └── (tools, 2 resources, TierRouter, PatternStore, ContextGuard, Observer, EmbeddingIndex)
+│
+├── Tools              # Canonical tool layer — replaces Extensions::Capability and Catalog::Registry
+│   ├── Base           # Base class for all framework tools (Do, Status, Config are built-in statics)
+│   ├── Registry       # always/deferred classification for all tools; replaces Catalog::Registry
+│   │                  # Extensions declare tools via `mcp_tools?` / `mcp_tools_deferred?` DSL on Core
+│   ├── Discovery      # Auto-discovers tools from extension runner modules at boot
+│   │                  # `runner_modules` accessor on Builders::Runners feeds Discovery
+│   │                  # `loaded_extension_modules` on Extensions exposes the full set
+│   └── EmbeddingCache # 5-tier persistent embedding cache:
+│                      #   L0 in-memory hash → L1 Cache::Local → L2 Cache → L3 Data::Local → L4 Data
 │
 ├── DigitalWorker      # Digital worker platform (AI-as-labor governance)
 │   ├── Lifecycle      # Worker state machine (active/paused/retired/terminated)
@@ -248,6 +258,16 @@ Legion (lib/legion.rb)
 
 `Legion::Extensions.find_extensions` discovers lex-* gems via `Bundler.load.specs` (when running under Bundler) or falls back to `Gem::Specification.all_names`. It also processes `Legion::Settings[:extensions]` for explicitly configured extensions, attempting `Gem.install` for missing ones if `auto_install` is enabled.
 
+**Category registry**: Extensions are classified by `categorize_and_order` using `default_category_registry`. Each category has a `type` (`:list` or `:prefix`), `tier` (load order within a phase), and `phase`:
+
+| Category | Type | Tier | Phase | Matches |
+|----------|------|------|-------|---------|
+| `identity` | prefix | 0 | 0 | `lex-identity-*` gems |
+| `core` | list | 1 | 1 | explicitly listed core extensions |
+| `ai` | list | 2 | 1 | explicitly listed AI provider extensions |
+| `gaia` | list | 3 | 1 | explicitly listed GAIA extensions |
+| `agentic` | prefix | 4 | 1 | `lex-agentic-*` gems |
+
 **Role-based filtering**: After discovery, `apply_role_filter` prunes extensions based on `Legion::Settings[:role][:profile]`:
 
 | Profile | What loads |
@@ -479,7 +499,7 @@ legion
 
 ### MCP Design
 
-Extracted to the `legion-mcp` gem (v0.5.9). See `legion-mcp/CLAUDE.md` for full architecture.
+Extracted to the `legion-mcp` gem (v0.7.3). See `legion-mcp/CLAUDE.md` for full architecture.
 
 - `Legion::MCP.server` is memoized singleton — call `Legion::MCP.reset!` in tests
 - Tool naming: `legion.snake_case_name` (dot namespace, not slash)
@@ -571,7 +591,7 @@ rack-test, rake, rspec, rubocop, rubocop-rspec, simplecov
 | `lib/legion/readiness.rb` | Component readiness tracking (COMPONENTS constant, `ready?`, `to_h`) |
 | `lib/legion/events.rb` | In-process pub/sub: `on`, `emit`, `once`, `off`, wildcard `*` |
 | `lib/legion/ingress.rb` | Universal runner invocation: `normalize`, `run` |
-| `lib/legion/extensions.rb` | LEX discovery, loading, actor hooking, shutdown |
+| `lib/legion/extensions.rb` | LEX discovery, loading, actor hooking, shutdown; exposes `loaded_extension_modules` for Tools::Discovery |
 | `lib/legion/extensions/core.rb` | Extension mixin (requirement flags, autobuild) |
 | `lib/legion/extensions/actors/` | Actor types: base, every, loop, once, poll, subscription, nothing, defaults |
 | `lib/legion/extensions/builders/` | Build actors, runners, helpers, hooks, routes from definitions |
@@ -586,7 +606,12 @@ rack-test, rake, rspec, rubocop, rubocop-rspec, simplecov
 | `lib/legion/isolation.rb` | Process isolation for untrusted extension execution |
 | `lib/legion/sandbox.rb` | Sandboxed execution environment for extensions |
 | `lib/legion/context.rb` | Thread-local execution context (request tracing, tenant) |
-| `lib/legion/catalog.rb` | Extension catalog: registry of available extensions with metadata |
+| `lib/legion/catalog.rb` | Extension catalog: registry of available extensions with metadata (Catalog::Registry removed — replaced by Tools::Registry) |
+| `lib/legion/tools.rb` | Tools module entry point |
+| `lib/legion/tools/base.rb` | Tools::Base — canonical base class for all tools |
+| `lib/legion/tools/registry.rb` | Tools::Registry — always/deferred classification, replaces Catalog::Registry |
+| `lib/legion/tools/discovery.rb` | Tools::Discovery — auto-discovers tools from extension runner_modules at boot |
+| `lib/legion/tools/embedding_cache.rb` | Tools::EmbeddingCache — 5-tier persistent embedding cache (L0–L4) |
 | `lib/legion/registry.rb` | Extension registry with security scanning |
 | `lib/legion/registry/security_scanner.rb` | Gem security scanner (CVE checks, signature verification) |
 | `lib/legion/webhooks.rb` | Webhook delivery system: HTTP POST with retry, HMAC signing |

data/lib/legion/cli/do_command.rb

@@ -158,7 +158,7 @@ module Legion
           end
           return nil unless matched
 
-          matched.tool_name.split('.').last
+          matched.tool_name.split(/[-.]/).last
         end
 
         def build_runner_class(extension, runner)

data/lib/legion/extensions.rb

@@ -21,12 +21,21 @@ module Legion
         @local_tasks = []
         @actors = []
         @running_instances = Concurrent::Array.new
-        @pending_actors = Concurrent::Array.new
+        @loaded_extensions = []
 
         find_extensions
-        load_extensions
+
+        phases = group_by_phase
+        phases.each do |phase_num, entries|
+          @pending_actors = Concurrent::Array.new
+          load_phase_extensions(phase_num, entries)
+          hook_phase_actors(phase_num)
+        end
+
+        @loaded_extensions&.each { |name| Catalog.transition(name, :running) }
+        Catalog.flush_persisted_transitions
+
         load_yaml_agents
-        hook_all_actors
       end
 
       attr_reader :local_tasks
@@ -107,11 +116,8 @@ module Legion
         Legion::Logging.warn 'All actors paused' if defined?(Legion::Logging)
       end
 
-      def load_extensions
-        @extensions ||= []
-        @loaded_extensions ||= []
-
-        eligible = @extensions.filter_map do |entry|
+      def load_phase_extensions(phase_num, entries)
+        eligible = entries.filter_map do |entry|
           gem_name = entry[:gem_name]
           ext_name = entry[:require_path].split('/').last
 
@@ -130,15 +136,35 @@ module Legion
         load_extensions_parallel(eligible)
 
         Legion::Logging.info(
-          "#{@extensions.count} extensions loaded with " \
-          "subscription:#{@subscription_tasks.count}," \
+          "Phase #{phase_num}: #{eligible.count} extensions loaded " \
+          "(subscription:#{@subscription_tasks.count}," \
           "every:#{@timer_tasks.count}," \
           "poll:#{@poll_tasks.count}," \
           "once:#{@once_tasks.count}," \
-          "loop:#{@loop_tasks.count}"
+          "loop:#{@loop_tasks.count})"
         )
       end
 
+      def hook_phase_actors(phase_num)
+        return if @pending_actors.nil? || @pending_actors.empty?
+
+        Legion::Logging.info "Phase #{phase_num}: hooking #{@pending_actors.size} deferred actors"
+
+        groups = group_pending_actors
+
+        %i[once poll every loop].each do |type|
+          next if groups[type].empty?
+
+          groups[type].each { |actor| hook_actor(**actor) }
+        end
+
+        hook_subscription_actors_pooled(groups[:subscription]) unless groups[:subscription].empty?
+
+        dispatch_local_actors(@local_tasks) unless @local_tasks.empty?
+
+        @pending_actors.clear
+      end
+
       def load_extensions_parallel(eligible)
         return if eligible.empty?
 
@@ -273,38 +299,6 @@ module Legion
         false
       end
 
-      def hook_all_actors
-        return if @pending_actors.nil? || @pending_actors.empty?
-
-        Legion::Logging.info "Hooking #{@pending_actors.size} deferred actors"
-
-        groups = group_pending_actors
-
-        %i[once poll every loop].each do |type|
-          next if groups[type].empty?
-
-          Legion::Logging.info "Starting #{type} actors (#{groups[type].size})"
-          groups[type].each { |actor| hook_actor(**actor) }
-        end
-        unless groups[:subscription].empty?
-          Legion::Logging.info "Starting subscription actors (#{groups[:subscription].size})"
-          hook_subscription_actors_pooled(groups[:subscription])
-        end
-        dispatch_local_actors(@local_tasks) unless @local_tasks.empty?
-
-        @pending_actors.clear
-        Legion::Logging.info(
-          "Actors hooked: subscription:#{@subscription_tasks.count}," \
-          "every:#{@timer_tasks.count}," \
-          "poll:#{@poll_tasks.count}," \
-          "once:#{@once_tasks.count}," \
-          "loop:#{@loop_tasks.count}," \
-          "local:#{@local_tasks.count}"
-        )
-        @loaded_extensions&.each { |name| Catalog.transition(name, :running) }
-        Catalog.flush_persisted_transitions
-      end
-
       ACTOR_TYPE_MAP = {
         Once:         :once,
         Poll:         :poll,
@@ -313,6 +307,17 @@ module Legion
         Subscription: :subscription
       }.freeze
 
+      def group_by_phase
+        settings_cats = ::Legion::Settings.dig(:extensions, :categories) || {}
+        categories = default_category_registry.merge(settings_cats)
+        default_phase = 1
+
+        @extensions.group_by do |entry|
+          cat = entry[:category]
+          categories.dig(cat, :phase) || default_phase
+        end.sort_by(&:first)
+      end
+
       def group_pending_actors
         groups = { once: [], poll: [], every: [], loop: [], subscription: [] }
         @pending_actors.each do |actor|
@@ -661,9 +666,10 @@ module Legion
         ext_settings = ::Legion::Settings[:extensions] || {}
         categories   = ext_settings[:categories] || default_category_registry
         lists        = {
-          core: Array(ext_settings[:core]),
-          ai:   Array(ext_settings[:ai]),
-          gaia: Array(ext_settings[:gaia])
+          identity: Array(ext_settings[:identity]),
+          core:     Array(ext_settings[:core]),
+          ai:       Array(ext_settings[:ai]),
+          gaia:     Array(ext_settings[:gaia])
         }
         ctx = {
           blocked:     Array(ext_settings[:blocked]),
@@ -696,7 +702,7 @@ module Legion
           Legion::Logging.debug "Extensions#check_reserved_words failed to read reserved_prefixes: #{e.message}" if defined?(Legion::Logging)
           []
         end
-        reserved_prefixes = configured_prefixes.empty? ? %w[core ai agentic gaia] : configured_prefixes
+        reserved_prefixes = configured_prefixes.empty? ? %w[core ai agentic gaia identity] : configured_prefixes
 
         configured_words = begin
           Array(::Legion::Settings.dig(:extensions, :reserved_words))
@@ -881,10 +887,11 @@ module Legion
 
       def default_category_registry
         {
-          core:    { type: :list, tier: 1 },
-          ai:      { type: :list, tier: 2 },
-          gaia:    { type: :list, tier: 3 },
-          agentic: { type: :prefix, tier: 4 }
+          identity: { type: :prefix, tier: 0, phase: 0 },
+          core:     { type: :list,   tier: 1, phase: 1 },
+          ai:       { type: :list,   tier: 2, phase: 1 },
+          gaia:     { type: :list,   tier: 3, phase: 1 },
+          agentic:  { type: :prefix, tier: 4, phase: 1 }
         }
       end
 

data/lib/legion/tools/config.rb

@@ -6,6 +6,7 @@ module Legion
       tool_name 'legion.get_config'
       description 'Get Legion configuration (sensitive values are redacted).'
       input_schema(
+        type:       'object',
         properties: {
           section: { type: 'string', description: 'Specific config section (e.g., "transport", "data")' }
         }

data/lib/legion/tools/discovery.rb

@@ -3,6 +3,13 @@
 module Legion
   module Tools
     module Discovery
+      # Extension/runner pairs that should always be loaded (not deferred)
+      # nil means all runners for that extension; array means specific runners only
+      ALWAYS_LOADED = {
+        'apollo' => ['knowledge'],
+        'eval'   => ['evaluation']
+      }.freeze
+
       class << self
         def log
           Legion::Logging.respond_to?(:logger) ? Legion::Logging.logger : nil
@@ -15,11 +22,19 @@ module Legion
         def discover_and_register
           return unless defined?(Legion::Extensions)
 
-          loaded_extensions.each do |ext|
+          exts = loaded_extensions
+          log&.info("[Tools::Discovery] scanning #{exts.size} extensions")
+
+          exts.each do |ext|
             discover_runners(ext)
           rescue StandardError => e
             handle_exception(e, level: :warn, handled: true, operation: :discovery_process_extension)
           end
+
+          log&.info(
+            "[Tools::Discovery] done: always=#{Registry.tools.size} " \
+            "deferred=#{Registry.deferred_tools.size}"
+          )
         end
 
         private
@@ -58,8 +73,6 @@ module Legion
           end
         end
 
-        # Build a functions hash from class_methods when settings[:functions] is not populated.
-        # The builders/runners.rb populates class_methods but not settings[:functions] by default.
         def synthesize_functions(ext, runner_mod)
           return {} unless ext.respond_to?(:runners) && ext.runners.is_a?(Hash)
 
@@ -87,7 +100,6 @@ module Legion
           Legion::Tools::Registry.register(tool_class)
         end
 
-        # Hierarchical: runner overrides extension
         def resolve_mcp_tools_enabled(ext, runner_mod)
           return runner_mod.mcp_tools? if runner_mod.respond_to?(:mcp_tools?)
 
@@ -95,6 +107,13 @@ module Legion
         end
 
         def resolve_deferred(ext, runner_mod)
+          ext_name = derive_extension_name(ext)
+          runner_name = derive_runner_snake(runner_mod)
+          if ALWAYS_LOADED.key?(ext_name)
+            runners = ALWAYS_LOADED[ext_name]
+            return false if runners.nil? || runners.include?(runner_name)
+          end
+
           return runner_mod.mcp_tools_deferred? if runner_mod.respond_to?(:mcp_tools_deferred?)
 
           ext.respond_to?(:mcp_tools_deferred?) ? ext.mcp_tools_deferred? : true
@@ -128,9 +147,9 @@ module Legion
           ext_name = derive_extension_name(ext)
           runner_snake = derive_runner_snake(runner_mod)
           {
-            tool_name:    defn&.dig(:mcp_prefix) || "legion.#{ext_name}.#{runner_snake}.#{func_name}",
+            tool_name:    defn&.dig(:mcp_prefix) || "legion-#{ext_name}-#{runner_snake}-#{func_name}",
             description:  meta[:desc] || defn&.dig(:desc) || "#{ext_name}##{func_name}",
-            input_schema: meta[:options] || { properties: {} },
+            input_schema: normalize_schema(meta[:options]),
             mcp_category: defn&.dig(:mcp_category),
             mcp_tier:     defn&.dig(:mcp_tier),
             deferred:     deferred,
@@ -173,6 +192,14 @@ module Legion
           last.gsub(/([A-Z])/, '_\1').sub(/^_/, '').downcase
         end
 
+        def normalize_schema(schema)
+          schema = { properties: {} } if schema.nil? || schema.empty?
+          schema = schema.dup
+          schema[:type] ||= 'object'
+          schema[:properties] ||= {}
+          schema
+        end
+
         def derive_extension_name(ext)
           if ext.respond_to?(:lex_name)
             ext.lex_name.delete_prefix('lex-').tr('-', '_')

data/lib/legion/tools/do.rb

@@ -9,6 +9,7 @@ module Legion
       description 'Execute a Legion action by describing what you want to do in natural language. ' \
                   'Routes to the best matching tool automatically.'
       input_schema(
+        type:       'object',
         properties: {
           intent:  {
             type:        'string',

data/lib/legion/tools/registry.rb

@@ -51,7 +51,10 @@ module Legion
           end
         end
 
-        # Catalog queries - replaces Catalog::Registry
+        def always_loaded_names
+          tools.map(&:tool_name)
+        end
+
         def for_extension(ext_name)
           all_tools.select { |t| t.respond_to?(:extension) && t.extension == ext_name }
         end

data/lib/legion/tools/status.rb

@@ -5,7 +5,7 @@ module Legion
     class Status < Base
       tool_name 'legion.get_status'
       description 'Get Legion service health status and component info.'
-      input_schema(properties: {})
+      input_schema(type: 'object', properties: {})
 
       class << self
         include Legion::Logging::Helper

data/lib/legion/tools.rb

@@ -2,7 +2,6 @@
 
 module Legion
   module Tools
-    # Static tool classes accumulate here at require time for reload safety
     @tool_classes = []
     @mutex = Mutex.new
 
@@ -17,7 +16,6 @@ module Legion
         end
       end
 
-      # Called by Service#register_core_tools on boot AND reload
       def register_all
         @mutex.synchronize { @tool_classes.dup }.each do |klass|
           Legion::Tools::Registry.register(klass)
@@ -32,7 +30,6 @@ require_relative 'tools/base'
 require_relative 'tools/discovery'
 require_relative 'tools/embedding_cache'
 
-# Static tools with custom orchestration logic
 Dir[File.join(__dir__, 'tools', '*.rb')].each do |f|
   require f unless f.end_with?('/base.rb', '/registry.rb', '/discovery.rb', '/embedding_cache.rb')
 end

data/lib/legion/version.rb

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

metadata

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