legionio 1.7.16 → 1.7.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60d6e7e501be5410e50a0096185b33af3f10b500ac766d2138efa67bb80908e0
-  data.tar.gz: 10d105942a000d3eb726125a6e55c3dbe1c70474623671ac09a69278a5c998db
+  metadata.gz: c2114c2b32ae4dbc1650bef546391f6abb1499a0b9d96d577739503c47caba79
+  data.tar.gz: 1e95267b23de0b635ffb32c9f745f58fe0bac63aa7d806a6581e3557b9b1aad6
 SHA512:
-  metadata.gz: c3d0342c0a3131bf421c7139ed2917eb94e037713e8d3cb6183680d1c3a04ffcd1bdca68679fadaa3c68237f5c0a994b33814776e56ea9bcdb865c0931b0c5f5
-  data.tar.gz: 0df1adc61ab111c31b1c6a87ed5b3e15d4243bf112b9914b01f7e9e0d9c6dc2ac6272708ddc4337187443d028da80447fc33a97a69e296f110f95b83404b1065
+  metadata.gz: 56c140c38d73a16c97574b405c4f27bdb91de199758692e76aecd0ec55afad66acab08fc011cf31a658df408cfcf8506e5e2971f4fbe92a4276e8856153a7481
+  data.tar.gz: 903faf2b78e2f27e1176e03558138f58ee9e6bdfcc34ac3f61c8c933424a0f7a0c641ba97d38d27c527b41cad93c9d8f69bffb64fed8a032a5d1aeb2bd6cb5ff

data/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 ## [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
+- `Legion::Tools::Discovery` - auto-discovers tools from extension runners with hierarchical DSL
+- `Legion::Tools::EmbeddingCache` - 5-tier persistent embedding cache (L0 memory + Cache + Data)
+- `mcp_tools?` and `mcp_tools_deferred?` extension Core DSL
+- `runner_modules` accessor on extension builders
+- `loaded_extension_modules` accessor on `Legion::Extensions`
+- Static tools: `Do`, `Status`, `Config` with `Legion::Logging::Helper`
+
+### Changed
+- Boot registers tools into Tools::Registry after extension load
+- Embedding index build is async (non-blocking)
+- API inference reads from Tools::Registry instead of MCP
+- Capability registration methods are now no-ops (replaced by Tools::Discovery)
+
+### Removed
+- Direct MCP dependency for tool access in API inference
+
 ## [1.7.16] - 2026-04-03
 
 ### Fixed

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/api/llm.rb

@@ -3,36 +3,6 @@
 require 'securerandom'
 require 'open3'
 
-begin
-  require 'legion/cli/chat/tools/search_traces'
-  if defined?(Legion::LLM::ToolRegistry) && defined?(Legion::CLI::Chat::Tools::SearchTraces)
-    Legion::LLM::ToolRegistry.register(Legion::CLI::Chat::Tools::SearchTraces)
-  end
-rescue LoadError => e
-  Legion::Logging.log_exception(e, payload_summary: 'SearchTraces not available for API', component_type: :api) if defined?(Legion::Logging)
-end
-
-ALWAYS_LOADED_TOOLS = %w[
-  legion_do
-  legion_get_status
-  legion_run_task
-  legion_describe_runner
-  legion_list_extensions
-  legion_get_extension
-  legion_list_tasks
-  legion_get_task
-  legion_get_task_logs
-  legion_query_knowledge
-  legion_knowledge_health
-  legion_knowledge_context
-  legion_list_workers
-  legion_show_worker
-  legion_mesh_status
-  legion_list_peers
-  legion_tools
-  legion_search_sessions
-].freeze
-
 module Legion
   class API < Sinatra::Base
     module Routes
@@ -59,44 +29,6 @@ module Legion
               defined?(Legion::Extensions::LLM::Gateway::Runners::Inference)
             end
 
-            define_method(:cached_mcp_tools) do
-              @@cached_mcp_tools ||= begin # rubocop:disable Style/ClassVars
-                all = []
-                begin
-                  require 'legion/mcp' unless defined?(Legion::MCP) && Legion::MCP.respond_to?(:server)
-                  Legion::MCP.server if defined?(Legion::MCP) && Legion::MCP.respond_to?(:server)
-                rescue LoadError => e
-                  Legion::Logging.log_exception(e, payload_summary: 'cached_mcp_tools: failed to require legion/mcp', component_type: :api)
-                end
-                if defined?(Legion::MCP::Server) && Legion::MCP::Server.respond_to?(:tool_registry)
-                  require 'legion/llm/pipeline/mcp_tool_adapter' unless defined?(Legion::LLM::Pipeline::McpToolAdapter)
-                  Legion::Logging.info "[llm][api] cached_mcp_tools building from #{Legion::MCP::Server.tool_registry.size} MCP tools"
-                  Legion::MCP::Server.tool_registry.each do |tc|
-                    all << Legion::LLM::Pipeline::McpToolAdapter.new(tc)
-                  rescue StandardError => e
-                    Legion::Logging.log_exception(e, payload_summary: "cached_mcp_tools: failed to adapt #{tc}", component_type: :api)
-                  end
-                end
-                {
-                  always:   all.select { |t| ALWAYS_LOADED_TOOLS.include?(t.name) }.freeze,
-                  deferred: all.reject { |t| ALWAYS_LOADED_TOOLS.include?(t.name) }.freeze,
-                  all:      all.freeze
-                }.freeze
-              end
-            end
-
-            define_method(:inject_mcp_tools) do |session, requested_tools: []|
-              cache = cached_mcp_tools
-              cache[:always].each { |t| session.with_tool(t) }
-
-              return if requested_tools.empty?
-
-              requested = requested_tools.map { |n| n.to_s.tr('.', '_') }
-              cache[:deferred].each do |t|
-                session.with_tool(t) if requested.include?(t.name)
-              end
-            end
-
             define_method(:build_client_tool_class) do |tname, tdesc, tschema|
               klass = Class.new(RubyLLM::Tool) do
                 description tdesc
@@ -185,7 +117,7 @@ module Legion
 
             message = body[:message]
 
-            # Tier 0 check — serve from PatternStore if available
+            # Tier 0 check - serve from PatternStore if available
             if defined?(Legion::MCP::TierRouter)
               tier_result = Legion::MCP::TierRouter.route(
                 intent:  message,
@@ -206,8 +138,7 @@ module Legion
             model      = body[:model]
             provider   = body[:provider]
 
-            # Route through full Legion pipeline when gateway is available:
-            #   Ingress -> RBAC -> Events -> Task -> Gateway (metering + fleet) -> LLM
+            # Route through full Legion pipeline when gateway is available
             if gateway_available?
               ingress_result = Legion::Ingress.run(
                 payload:      { message: message, model: model, provider: provider,
@@ -315,7 +246,7 @@ module Legion
 
             caller_identity = env['legion.tenant_id'] || 'api:inference'
 
-            # GAIA bridge — push InputFrame to sensory buffer
+            # GAIA bridge - push InputFrame to sensory buffer
             last_user = messages.select { |m| (m[:role] || m['role']).to_s == 'user' }.last
             prompt    = (last_user || {})[:content] || (last_user || {})['content'] || ''
 
@@ -345,18 +276,7 @@ module Legion
             # Detect streaming mode
             streaming = body[:stream] == true && env['HTTP_ACCEPT']&.include?('text/event-stream')
 
-            # Inject MCP tools from daemon alongside client tools
-            all_tools = tool_classes.dup
-            begin
-              mcp_cache = cached_mcp_tools
-              mcp_to_inject = requested_tools.empty? ? mcp_cache[:always] : mcp_cache[:all]
-              all_tools.concat(mcp_to_inject) if mcp_to_inject&.any?
-              Legion::Logging.debug "[llm][api] inference mcp_injected=#{mcp_to_inject&.size || 0} total_tools=#{all_tools.size}"
-            rescue StandardError => e
-              Legion::Logging.log_exception(e, payload_summary: 'mcp tool injection failed', component_type: :api)
-            end
-
-            # Build pipeline request
+            # Executor handles all registry tool injection — API only passes client-defined tools
             require 'legion/llm/pipeline/request' unless defined?(Legion::LLM::Pipeline::Request)
             require 'legion/llm/pipeline/executor' unless defined?(Legion::LLM::Pipeline::Executor)
 
@@ -364,7 +284,7 @@ module Legion
               messages:        messages,
               system:          body[:system],
               routing:         { provider: provider, model: model },
-              tools:           all_tools,
+              tools:           tool_classes,
               caller:          { requested_by: { identity: caller_identity, type: :user, credential: :api } },
               conversation_id: body[:conversation_id],
               metadata:        { requested_tools: requested_tools },

data/lib/legion/cli/do_command.rb

@@ -15,7 +15,7 @@ module Legion
           result = try_daemon(intent, options) || try_in_process(intent) || try_llm_classify(intent)
 
           if result.nil?
-            formatter.error('No matching capability found')
+            formatter.error('No matching tool found')
             formatter.detail('Try: legion lex list  (to see available extensions)')
             raise SystemExit, 1
           end
@@ -53,37 +53,73 @@ module Legion
         end
 
         def try_in_process(intent)
-          return nil unless defined?(Legion::Extensions::Catalog::Registry)
+          return nil unless defined?(Legion::Tools::Registry)
 
-          matches = Legion::Extensions::Catalog::Registry.find_by_intent(intent)
-          return nil if matches.empty?
+          matched = Legion::Tools::Registry.all_tools.find do |t|
+            t.tool_name.include?(intent.downcase.tr(' ', '_')) ||
+              t.description.downcase.include?(intent.downcase)
+          end
+          return nil unless matched
+
+          begin
+            result = matched.call
+            normalize_in_process_result(result, matched.tool_name)
+          rescue ArgumentError
+            { matched: matched.tool_name, status: 'requires_daemon',
+              note: 'Tool requires arguments; start the daemon and retry: legion start' }
+          end
+        end
+
+        def normalize_in_process_result(result, tool_name)
+          return { matched: tool_name, result: result } unless result.is_a?(Hash)
+
+          normalized = result.dup
+          normalized[:matched] = tool_name
+          extracted = extract_tool_text(normalized)
 
-          best = matches.first
-          runner_class = build_runner_class(best.extension, best.runner)
+          if normalized[:error] == true
+            normalized[:error] = extracted.empty? ? 'Tool execution failed' : extracted
+          elsif !normalized.key?(:result) && !extracted.empty?
+            normalized[:result] = extracted
+          end
+
+          normalized
+        end
 
-          if defined?(Legion::Ingress)
-            Legion::Ingress.run(
-              payload:      { intent: intent },
-              runner_class: runner_class,
-              function:     best.function,
-              source:       'cli:do'
-            )
+        def extract_tool_text(value)
+          case value
+          when Hash
+            error_val = value[:error] || value['error']
+            return error_val.to_s unless error_val == true || error_val.nil? || error_val.to_s.empty?
+
+            %i[message result response detail content].each do |key|
+              extracted = extract_tool_text(value[key] || value[key.to_s])
+              return extracted unless extracted.empty?
+            end
+
+            ''
+          when Array
+            value.filter_map do |item|
+              text = extract_tool_text(item)
+              text unless text.empty?
+            end.join("\n")
+          when String
+            value.strip
           else
-            { matched: best.name, runner_class: runner_class, function: best.function,
-              status: 'resolved', note: 'Daemon not running; cannot execute. Start with: legion start' }
+            value.nil? ? '' : value.to_s
           end
         end
 
         def try_llm_classify(intent)
-          return nil unless defined?(Legion::Extensions::Catalog::Registry) && defined?(Legion::LLM)
+          return nil unless defined?(Legion::Tools::Registry) && defined?(Legion::LLM)
 
-          caps = Legion::Extensions::Catalog::Registry.capabilities
-          return nil if caps.empty?
+          tools = Legion::Tools::Registry.all_tools
+          return nil if tools.empty?
 
-          catalog = caps.map { |c| "#{c.name}: #{c.description || "#{c.extension} #{c.runner}##{c.function}"}" }
-          prompt = "Given these capabilities:\n#{catalog.join("\n")}\n\n" \
-                   "Which capability best matches this intent: \"#{intent}\"?\n" \
-                   'Reply with ONLY the capability name (e.g., lex-consul:health_check:run). ' \
+          catalog = tools.map { |t| "#{t.tool_name}: #{t.description}" }
+          prompt = "Given these tools:\n#{catalog.join("\n")}\n\n" \
+                   "Which tool best matches this intent: \"#{intent}\"?\n" \
+                   'Reply with ONLY the tool name (e.g., legion.do). ' \
                    'If none match, reply NONE.'
 
           response = Legion::LLM.ask(
@@ -93,12 +129,10 @@ module Legion
           chosen = response.is_a?(Hash) ? response[:response].to_s.strip : response.to_s.strip
           return nil if chosen.empty? || chosen.upcase == 'NONE'
 
-          cap = Legion::Extensions::Catalog::Registry.find(name: chosen)
-          return nil unless cap
+          tool = Legion::Tools::Registry.find(chosen)
+          return nil unless tool
 
-          runner_class = build_runner_class(cap.extension, cap.runner)
-          { matched: cap.name, runner_class: runner_class, function: cap.function,
-            status: 'resolved', source: 'llm',
+          { matched: tool.tool_name, status: 'resolved', source: 'llm',
             note: 'Daemon not running; cannot execute. Start with: legion start' }
         rescue StandardError => e
           Legion::Logging.debug("DoCommand#try_llm_classify failed: #{e.message}") if defined?(Legion::Logging)
@@ -106,26 +140,31 @@ module Legion
         end
 
         def resolve_runner_class(intent)
-          return nil unless defined?(Legion::Extensions::Catalog::Registry)
+          return nil unless defined?(Legion::Tools::Registry)
 
-          matches = Legion::Extensions::Catalog::Registry.find_by_intent(intent)
-          return nil if matches.empty?
+          matched = Legion::Tools::Registry.all_tools.find do |t|
+            t.description.downcase.include?(intent.downcase)
+          end
+          return nil unless matched.respond_to?(:extension) && matched.respond_to?(:runner)
 
-          build_runner_class(matches.first.extension, matches.first.runner)
+          build_runner_class(matched.extension, matched.runner)
         end
 
         def resolve_function(intent)
-          return nil unless defined?(Legion::Extensions::Catalog::Registry)
+          return nil unless defined?(Legion::Tools::Registry)
 
-          matches = Legion::Extensions::Catalog::Registry.find_by_intent(intent)
-          return nil if matches.empty?
+          matched = Legion::Tools::Registry.all_tools.find do |t|
+            t.description.downcase.include?(intent.downcase)
+          end
+          return nil unless matched
 
-          matches.first.function
+          matched.tool_name.split(/[-.]/).last
         end
 
         def build_runner_class(extension, runner)
-          ext_part = extension.delete_prefix('lex-').split(/[-_]/).map(&:capitalize).join
-          "Legion::Extensions::#{ext_part}::Runners::#{runner}"
+          ext_part = extension.to_s.delete_prefix('lex-').split(/[-_]/).map(&:capitalize).join
+          runner_part = runner.to_s.split('_').map(&:capitalize).join
+          "Legion::Extensions::#{ext_part}::Runners::#{runner_part}"
         end
 
         def daemon_port(options)

data/lib/legion/extensions/builders/runners.rb

@@ -59,6 +59,12 @@ module Legion
           end
         end
 
+        def runner_modules
+          return [] unless defined?(@runners) && @runners.is_a?(Hash)
+
+          @runners.values.filter_map { |r| r[:runner_module] }
+        end
+
         def runner_files
           @runner_files ||= find_files('runners')
         end

data/lib/legion/extensions/core.rb

@@ -112,6 +112,14 @@ module Legion
         true
       end
 
+      def mcp_tools?
+        true
+      end
+
+      def mcp_tools_deferred?
+        true
+      end
+
       # Auto-generate AMQP message classes for each runner method that has a definition.
       # Explicit Messages::* classes in the transport directory take precedence.
       # Runs after build_runners so definitions are populated.