legionio 1.4.70 → 1.4.71

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f924192ddb882e9dd08fa0ada9088c4f9f468ef8d782df7a06888774ebe5b9d
-  data.tar.gz: f7eab58ceaf4f9119dad859f9b5d47945b57854a2e65e7f68484660da9c2f3a9
+  metadata.gz: 0e16727aaa70a3ffc2da0e6d3f3a6bce498e0052876e280c1d6cb42d50b3d594
+  data.tar.gz: 57042f5deb5a35dd8456850606e7a1bf42e0e4d5235385a4abb7987d13831894
 SHA512:
-  metadata.gz: 5b120a8843d8626da5508cfef24fa2791539c135d090a83a1519e9db99d3fb78aac7b52fde48b2c844435687114dada9b9622d73f6ab204607e73f422f2a9b90
-  data.tar.gz: 6965a20d9389f2b8e16be7e83fdac2835c6b18d47269bb9bf9f102588d03ed7df72b62cc119afeb1f7b0c29695efd0654e60af093bff4e00d3e2eefc76f76723
+  metadata.gz: b2c90fb0ba93a569c0dbd6c72f6e199fcebd6201fa4d003a114bc2d0f9bced639c28364ccb92aaf78f6ea1d226d1fa78b4a1c92538fa1002274f8656f1a8e0e1
+  data.tar.gz: 47dd1c952fcf6fd5f0f70d277b7c03ced2632dfa13cf9c47db2d1e0e03d6f90c005a8f13776a03ed900cbdf2c5e27aa7ec8d62e36751260f207c561878ef78ba

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Legion Changelog
 
+## [1.4.71] - 2026-03-19
+
+### Added
+- `POST /api/llm/chat` daemon endpoint with async (202) and sync (201) response paths
+- `ContextCompiler` module: categorizes 35 MCP tools into 9 groups with keyword matching
+- `legion.do` meta-tool: natural language intent routing to best-matching MCP tool
+- `legion.tools` meta-tool: compressed catalog, category browsing, and intent-matched discovery
+
+### Fixed
+- `ContextCompiler.build_tool_index` now handles `MCP::Tool::InputSchema` objects (not just hashes)
+
 ## [1.4.70] - 2026-03-19
 
 ### Added

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.4.67
+**Version**: 1.4.70
 **License**: Apache-2.0
 **Docker**: `legionio/legion`
 **Ruby**: >= 3.4
@@ -39,21 +39,26 @@ Before any Legion code loads, `exe/legion` applies three performance optimizatio
 ```
 Legion.start
   └── Legion::Service.new
-      ├── 1. setup_logging      (legion-logging)
-      ├── 2. setup_settings     (legion-settings, loads /etc/legionio, ~/legionio, ./settings)
-      ├── 3. Legion::Crypt.start (legion-crypt, Vault connection)
-      ├── 4. setup_transport    (legion-transport, RabbitMQ connection)
-      ├── 5. require legion-cache
-      ├── 6. setup_data         (legion-data, MySQL/SQLite + migrations, optional)
-      ├── 7. setup_llm          (legion-llm, optional)
-      ├── 8. setup_supervision  (process supervision)
-      ├── 9. load_extensions    (discover + load LEX gems, filtered by role profile)
-      ├── 10. Legion::Crypt.cs  (distribute cluster secret)
-      └── 11. setup_api         (start Sinatra/Puma on port 4567)
+      ├── 1.  setup_logging      (legion-logging)
+      ├── 2.  setup_settings     (legion-settings, loads /etc/legionio, ~/legionio, ./settings)
+      ├── 3.  Legion::Crypt.start (legion-crypt, Vault connection)
+      ├── 4.  setup_transport    (legion-transport, RabbitMQ connection)
+      ├── 5.  require legion-cache
+      ├── 6.  setup_data         (legion-data, MySQL/SQLite + migrations, optional)
+      ├── 7.  setup_rbac         (legion-rbac, optional)
+      ├── 8.  setup_llm          (legion-llm, optional)
+      ├── 9.  setup_gaia         (legion-gaia, cognitive layer, optional)
+      ├── 10. setup_telemetry    (OpenTelemetry, optional)
+      ├── 11. setup_supervision  (process supervision)
+      ├── 12. load_extensions    (two-phase: require+autobuild all, then hook_all_actors)
+      ├── 13. Legion::Crypt.cs   (distribute cluster secret)
+      └── 14. 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: all extensions are `require`d and `autobuild` runs first, collecting actors into `@pending_actors`. After all extensions are loaded, `hook_all_actors` starts AMQP subscriptions, timers, and other actor types. This prevents race conditions where early extensions start ticking while later ones haven't loaded yet.
+
 ### Reload Sequence
 
 `Legion.reload` shuts down all subsystems in reverse order, waits for them to drain, then re-runs setup from settings onward. Extensions and API are re-loaded fresh.
@@ -66,7 +71,7 @@ Legion (lib/legion.rb)
 │                      # Entry points: Legion.start, .shutdown, .reload
 ├── Process            # Daemonization: PID management, signal traps (SIGINT=quit), main loop
 ├── Readiness          # Startup readiness tracking
-│                      # COMPONENTS: settings, crypt, transport, cache, data, extensions, api
+│                      # COMPONENTS: settings, crypt, transport, cache, data, gaia, extensions, api
 │                      # Readiness.ready? checks all; /api/ready returns JSON status
 ├── Events             # In-process pub/sub event bus
 │                      # Events.on(name) / .emit(name, **payload) / .once / .off
@@ -723,8 +728,8 @@ rack-test, rake, rspec, rubocop, rubocop-rspec, simplecov
 
 ```bash
 bundle install
-bundle exec rspec       # 1379 examples, 0 failures
-bundle exec rubocop     # 396 files, 0 offenses
+bundle exec rspec       # 1433 examples, 0 failures
+bundle exec rubocop     # 418 files, 0 offenses
 ```
 
 Specs use `rack-test` for API testing. `Legion::JSON.load` returns symbol keys — use `body[:data]` not `body['data']` in specs.

data/lib/legion/api/llm.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Llm
+        def self.registered(app)
+          app.helpers do
+            define_method(:require_llm!) do
+              return if defined?(Legion::LLM) &&
+                        Legion::LLM.respond_to?(:started?) &&
+                        Legion::LLM.started?
+
+              halt 503, { 'Content-Type' => 'application/json' },
+                   Legion::JSON.dump({ error: { code:    'llm_unavailable',
+                                                message: 'LLM subsystem is not available' } })
+            end
+
+            define_method(:cache_available?) do
+              defined?(Legion::Cache) &&
+                Legion::Cache.respond_to?(:connected?) &&
+                Legion::Cache.connected?
+            end
+          end
+
+          register_chat(app)
+        end
+
+        def self.register_chat(app)
+          app.post '/api/llm/chat' do # rubocop:disable Metrics/BlockLength
+            require_llm!
+
+            body = parse_request_body
+            validate_required!(body, :message)
+
+            request_id = body[:request_id] || SecureRandom.uuid
+            message    = body[:message]
+            model      = body[:model]
+            provider   = body[:provider]
+
+            if cache_available?
+              llm = Legion::LLM
+              rc  = Legion::LLM::ResponseCache
+              rc.init_request(request_id)
+
+              Thread.new do
+                session  = llm.chat_direct(model: model, provider: provider)
+                response = session.ask(message)
+                rc.complete(
+                  request_id,
+                  response: response.content,
+                  meta:     {
+                    model:      session.model.to_s,
+                    tokens_in:  response.respond_to?(:input_tokens) ? response.input_tokens : nil,
+                    tokens_out: response.respond_to?(:output_tokens) ? response.output_tokens : nil
+                  }
+                )
+              rescue StandardError => e
+                rc.fail_request(request_id, code: 'llm_error', message: e.message)
+              end
+
+              json_response({ request_id: request_id, poll_key: "llm:#{request_id}:status" },
+                            status_code: 202)
+            else
+              session  = Legion::LLM.chat_direct(model: model, provider: provider)
+              response = session.ask(message)
+              json_response(
+                {
+                  response: response.content,
+                  meta:     {
+                    model:      session.model.to_s,
+                    tokens_in:  response.respond_to?(:input_tokens) ? response.input_tokens : nil,
+                    tokens_out: response.respond_to?(:output_tokens) ? response.output_tokens : nil
+                  }
+                },
+                status_code: 201
+              )
+            end
+          end
+        end
+
+        class << self
+          private :register_chat
+        end
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -33,6 +33,7 @@ require_relative 'api/auth_kerberos'
 require_relative 'api/capacity'
 require_relative 'api/audit'
 require_relative 'api/metrics'
+require_relative 'api/llm'
 
 module Legion
   class API < Sinatra::Base
@@ -108,6 +109,7 @@ module Legion
     register Routes::Capacity
     register Routes::Audit
     register Routes::Metrics
+    register Routes::Llm
 
     use Legion::Rbac::Middleware if defined?(Legion::Rbac::Middleware)
 

data/lib/legion/mcp/context_compiler.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module ContextCompiler
+      CATEGORIES = {
+        tasks:         {
+          tools:   %w[legion.run_task legion.list_tasks legion.get_task legion.delete_task legion.get_task_logs],
+          summary: 'Create, list, query, and delete tasks. Run functions via dot-notation task identifiers.'
+        },
+        chains:        {
+          tools:   %w[legion.list_chains legion.create_chain legion.update_chain legion.delete_chain],
+          summary: 'Manage task chains - ordered sequences of tasks that execute in series.'
+        },
+        relationships: {
+          tools:   %w[legion.list_relationships legion.create_relationship legion.update_relationship
+                      legion.delete_relationship],
+          summary: 'Manage trigger-action relationships between functions.'
+        },
+        extensions:    {
+          tools:   %w[legion.list_extensions legion.get_extension legion.enable_extension
+                      legion.disable_extension],
+          summary: 'Manage LEX extensions - list installed, inspect details, enable/disable.'
+        },
+        schedules:     {
+          tools:   %w[legion.list_schedules legion.create_schedule legion.update_schedule legion.delete_schedule],
+          summary: 'Manage scheduled tasks - cron-style recurring task execution.'
+        },
+        workers:       {
+          tools:   %w[legion.list_workers legion.show_worker legion.worker_lifecycle legion.worker_costs],
+          summary: 'Manage digital workers - list, inspect, lifecycle transitions, cost tracking.'
+        },
+        rbac:          {
+          tools:   %w[legion.rbac_check legion.rbac_assignments legion.rbac_grants],
+          summary: 'Role-based access control - check permissions, view assignments and grants.'
+        },
+        status:        {
+          tools:   %w[legion.get_status legion.get_config legion.team_summary legion.routing_stats],
+          summary: 'System status, configuration, team overview, and routing statistics.'
+        },
+        describe:      {
+          tools:   %w[legion.describe_runner],
+          summary: 'Inspect a specific runner function - parameters, return type, metadata.'
+        }
+      }.freeze
+
+      module_function
+
+      # Returns a compressed summary of all categories with tool counts and tool name lists.
+      # @return [Array<Hash>] array of { category:, summary:, tool_count:, tools: }
+      def compressed_catalog
+        CATEGORIES.map do |category, config|
+          tool_names = config[:tools]
+          {
+            category:   category,
+            summary:    config[:summary],
+            tool_count: tool_names.length,
+            tools:      tool_names
+          }
+        end
+      end
+
+      # Returns tools for a specific category, filtered to only those present in TOOL_CLASSES.
+      # @param category_sym [Symbol] one of the CATEGORIES keys
+      # @return [Hash, nil] { category:, summary:, tools: [{ name:, description:, params: }] } or nil
+      def category_tools(category_sym)
+        config = CATEGORIES[category_sym]
+        return nil unless config
+
+        index = tool_index
+        tools = config[:tools].filter_map { |name| index[name] }
+        return nil if tools.empty?
+
+        {
+          category: category_sym,
+          summary:  config[:summary],
+          tools:    tools
+        }
+      end
+
+      # Keyword-match intent against tool names and descriptions.
+      # @param intent_string [String] natural language intent
+      # @return [Class, nil] best matching tool CLASS from Server::TOOL_CLASSES or nil
+      def match_tool(intent_string)
+        scored = scored_tools(intent_string)
+        return nil if scored.empty?
+
+        best = scored.max_by { |entry| entry[:score] }
+        return nil if best[:score].zero?
+
+        Server::TOOL_CLASSES.find { |klass| klass.tool_name == best[:name] }
+      end
+
+      # Returns top N keyword-matched tools ranked by score.
+      # @param intent_string [String] natural language intent
+      # @param limit [Integer] max results (default 5)
+      # @return [Array<Hash>] array of { name:, description:, score: }
+      def match_tools(intent_string, limit: 5)
+        scored = scored_tools(intent_string)
+                 .select { |entry| entry[:score].positive? }
+                 .sort_by { |entry| -entry[:score] }
+        scored.first(limit)
+      end
+
+      # Returns a hash keyed by tool_name with compressed param info.
+      # Memoized — call reset! to clear.
+      # @return [Hash<String, Hash>] { name:, description:, params: [String] }
+      def tool_index
+        @tool_index ||= build_tool_index
+      end
+
+      # Clears the memoized tool_index.
+      def reset!
+        @tool_index = nil
+      end
+
+      def build_tool_index
+        Server::TOOL_CLASSES.each_with_object({}) do |klass, idx|
+          raw_schema = klass.input_schema
+          schema = raw_schema.is_a?(Hash) ? raw_schema : raw_schema.to_h
+          properties = schema[:properties] || {}
+          idx[klass.tool_name] = {
+            name:        klass.tool_name,
+            description: klass.description,
+            params:      properties.keys.map(&:to_s)
+          }
+        end
+      end
+
+      def scored_tools(intent_string)
+        keywords = intent_string.downcase.split
+        return [] if keywords.empty?
+
+        tool_index.values.map do |entry|
+          haystack = "#{entry[:name].downcase} #{entry[:description].downcase}"
+          score    = keywords.count { |kw| haystack.include?(kw) }
+          { name: entry[:name], description: entry[:description], score: score }
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/server.rb

@@ -33,6 +33,9 @@ require_relative 'tools/routing_stats'
 require_relative 'tools/rbac_check'
 require_relative 'tools/rbac_assignments'
 require_relative 'tools/rbac_grants'
+require_relative 'context_compiler'
+require_relative 'tools/do_action'
+require_relative 'tools/discover_tools'
 require_relative 'resources/runner_catalog'
 require_relative 'resources/extension_info'
 
@@ -72,7 +75,9 @@ module Legion
         Tools::RoutingStats,
         Tools::RbacCheck,
         Tools::RbacAssignments,
-        Tools::RbacGrants
+        Tools::RbacGrants,
+        Tools::DoAction,
+        Tools::DiscoverTools
       ].freeze
 
       class << self

data/lib/legion/mcp/tools/discover_tools.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class DiscoverTools < ::MCP::Tool
+        tool_name 'legion.tools'
+        description 'Discover available Legion tools by category or intent. Returns compressed definitions to reduce context.'
+
+        input_schema(
+          properties: {
+            category: {
+              type:        'string',
+              description: 'Tool category: tasks, chains, relationships, extensions, schedules, workers, rbac, status, describe'
+            },
+            intent:   {
+              type:        'string',
+              description: 'Describe what you want to do and relevant tools will be ranked'
+            }
+          }
+        )
+
+        class << self
+          def call(category: nil, intent: nil)
+            if category
+              result = ContextCompiler.category_tools(category.to_sym)
+              return error_response("Unknown category: #{category}") if result.nil?
+
+              text_response(result)
+            elsif intent
+              results = ContextCompiler.match_tools(intent, limit: 5)
+              text_response({ matched_tools: results })
+            else
+              text_response(ContextCompiler.compressed_catalog)
+            end
+          rescue StandardError => e
+            error_response("Failed: #{e.message}")
+          end
+
+          private
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/do_action.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class DoAction < ::MCP::Tool
+        tool_name 'legion.do'
+        description 'Execute a Legion action by describing what you want to do in natural language. Routes to the best matching tool automatically.'
+
+        input_schema(
+          properties: {
+            intent: {
+              type:        'string',
+              description: 'Natural language description (e.g., "list all running tasks")'
+            },
+            params: {
+              type:                 'object',
+              description:          'Parameters to pass to the matched tool',
+              additionalProperties: true
+            }
+          },
+          required:   ['intent']
+        )
+
+        class << self
+          def call(intent:, params: {})
+            matched = ContextCompiler.match_tool(intent)
+            return error_response("No matching tool found for intent: #{intent}") if matched.nil?
+
+            Legion::MCP::Observer.record_intent(intent, matched) if defined?(Legion::MCP::Observer)
+
+            tool_params = params.transform_keys(&:to_sym)
+            if tool_params.empty?
+              matched.call
+            else
+              matched.call(**tool_params)
+            end
+          rescue StandardError => e
+            error_response("Failed: #{e.message}")
+          end
+
+          private
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.70
+  version: 1.4.71
 platform: ruby
 authors:
 - Esity
@@ -353,6 +353,7 @@ files:
 - lib/legion/api/gaia.rb
 - lib/legion/api/helpers.rb
 - lib/legion/api/hooks.rb
+- lib/legion/api/llm.rb
 - lib/legion/api/metrics.rb
 - lib/legion/api/middleware/api_version.rb
 - lib/legion/api/middleware/auth.rb
@@ -508,9 +509,6 @@ files:
 - lib/legion/cli/theme.rb
 - lib/legion/cli/trace_command.rb
 - lib/legion/cli/trigger.rb
-- lib/legion/cli/tty/chat_ui.rb
-- lib/legion/cli/tty/palette.rb
-- lib/legion/cli/tty/splash.rb
 - lib/legion/cli/tty_command.rb
 - lib/legion/cli/update_command.rb
 - lib/legion/cli/version.rb
@@ -560,6 +558,7 @@ files:
 - lib/legion/lex.rb
 - lib/legion/mcp.rb
 - lib/legion/mcp/auth.rb
+- lib/legion/mcp/context_compiler.rb
 - lib/legion/mcp/resources/extension_info.rb
 - lib/legion/mcp/resources/runner_catalog.rb
 - lib/legion/mcp/server.rb
@@ -573,6 +572,8 @@ files:
 - lib/legion/mcp/tools/delete_task.rb
 - lib/legion/mcp/tools/describe_runner.rb
 - lib/legion/mcp/tools/disable_extension.rb
+- lib/legion/mcp/tools/discover_tools.rb
+- lib/legion/mcp/tools/do_action.rb
 - lib/legion/mcp/tools/enable_extension.rb
 - lib/legion/mcp/tools/get_config.rb
 - lib/legion/mcp/tools/get_extension.rb

data/lib/legion/cli/tty/chat_ui.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-require 'tty-box'
-require 'tty-markdown'
-require 'tty-reader'
-require 'tty-screen'
-require 'tty-cursor'
-require_relative 'palette'
-
-module Legion
-  module CLI
-    module TTY
-      module ChatUI
-        SLASH_COMMANDS = {
-          '/help'    => 'Show available commands',
-          '/quit'    => 'Exit chat',
-          '/clear'   => 'Clear conversation',
-          '/status'  => 'Show system status',
-          '/cost'    => 'Show session token usage',
-          '/model'   => 'Switch model',
-          '/compact' => 'Compact conversation history'
-        }.freeze
-
-        class << self
-          def run
-            p = Palette
-            reader = ::TTY::Reader.new(interrupt: :exit, track_history: true)
-
-            render_chat_header
-            puts
-            render_welcome
-            puts
-
-            token_count = 0
-            turn = 0
-
-            loop do
-              prompt_text = "  #{p.fg(:cardinal)}\u276f#{p.reset} "
-              input = reader.read_line(prompt_text)&.strip
-
-              break if input.nil?
-              next if input.empty?
-              break if input == '/quit'
-
-              result = handle_slash_command(input, turn, token_count)
-              if result
-                turn        = result[:turn]        if result.key?(:turn)
-                token_count = result[:token_count] if result.key?(:token_count)
-                next
-              end
-
-              turn += 1
-              token_count += input.split.size * 3
-
-              response     = simulate_response(input, turn)
-              token_count += response.split.size * 4
-
-              render_response(response)
-              puts
-            end
-
-            puts
-            puts "  #{p.muted('Session ended.')} #{p.disabled("#{turn} turns, ~#{token_count} tokens")}"
-            puts
-          end
-
-          private
-
-          def handle_slash_command(input, turn, token_count)
-            cursor = ::TTY::Cursor
-            case input
-            when '/help'
-              render_help
-              {}
-            when '/clear'
-              print cursor.clear_screen + cursor.move_to(0, 0)
-              render_chat_header
-              puts
-              render_system_message('Conversation cleared.')
-              puts
-              { turn: 0, token_count: 0 }
-            when '/status'
-              render_status(turn, token_count)
-              {}
-            when '/cost'
-              render_cost(token_count)
-              {}
-            else
-              if input.start_with?('/')
-                render_system_message("Unknown command: #{input}. Type /help for available commands.")
-                puts
-                {}
-              end
-            end
-          end
-
-          def render_chat_header
-            p = Palette
-            width = [::TTY::Screen.width, 80].min
-
-            puts "  #{p.border('─' * (width - 4))}"
-            puts "  #{p.heading('Legion Chat')}  #{p.muted('(TTY Toolkit POC)')}"
-            puts "  #{p.border('─' * (width - 4))}"
-          end
-
-          def render_welcome
-            p = Palette
-            puts "  #{p.body('Type a message to chat. Use')} #{p.accent('/help')} #{p.body('for commands.')}"
-          end
-
-          def render_help
-            p = Palette
-            puts
-            puts "  #{p.heading('Commands')}"
-            puts
-            SLASH_COMMANDS.each do |cmd, desc|
-              puts "  #{p.accent(cmd.ljust(12))} #{p.body(desc)}"
-            end
-            puts
-          end
-
-          def render_system_message(text)
-            p = Palette
-            puts "  #{p.muted("\u00b7")} #{p.body(text)}"
-          end
-
-          def render_status(turn, tokens)
-            p = Palette
-            puts
-
-            w = 48
-            lines = [
-              "#{p.label('Turns')}       #{p.body(turn.to_s)}",
-              "#{p.label('Tokens')}      #{p.body("~#{tokens}")}",
-              "#{p.label('Model')}       #{p.body('claude-opus-4-6')}",
-              "#{p.label('Provider')}    #{p.body('anthropic')}",
-              "#{p.label('Session')}     #{p.success('active')}"
-            ]
-
-            puts "  #{p.border('┌')} #{p.heading('Status')} #{p.border('─' * (w - 12))}#{p.border('┐')}"
-            puts "  #{p.border('│')}#{' ' * w}#{p.border('│')}"
-            lines.each do |line|
-              puts "  #{p.border('│')}  #{line}#{' ' * 4}#{p.border('│')}"
-            end
-            puts "  #{p.border('│')}#{' ' * w}#{p.border('│')}"
-            puts "  #{p.border('└')}#{p.border('─' * w)}#{p.border('┘')}"
-            puts
-          end
-
-          def render_cost(tokens)
-            p = Palette
-            cost_estimate = (tokens / 1000.0 * 0.015).round(4)
-            puts
-            puts "  #{p.label('Tokens')}  #{p.body("~#{tokens}")}  #{p.muted('|')}  #{p.label('Cost')}  #{p.body("~$#{cost_estimate}")}"
-            puts
-          end
-
-          def render_response(text)
-            puts
-
-            # Render as markdown
-            rendered = ::TTY::Markdown.parse(
-              text,
-              width: [::TTY::Screen.width - 6, 74].min,
-              theme: {
-                em:     :italic,
-                header: %i[bold],
-                hr:     :dim,
-                link:   [:underline],
-                list:   [],
-                strong: [:bold],
-                table:  [],
-                quote:  [:italic]
-              }
-            )
-
-            rendered.each_line do |line|
-              puts "  #{line}"
-            end
-          end
-
-          def simulate_response(_input, turn)
-            responses = [
-              "I can help with that. Here's what I found:\n\n" \
-              'The LegionIO extension system uses **auto-discovery** via `Bundler.load.specs` ' \
-              "to find all `lex-*` gems. Each extension defines:\n\n" \
-              "- **Runners** — the actual functions that execute\n" \
-              "- **Actors** — execution modes (subscription, polling, interval)\n" \
-              "- **Helpers** — shared utilities for the extension\n\n" \
-              "```ruby\nmodule Legion::Extensions::MyExtension\n  module Runners\n    module Process\n      " \
-              "def handle(payload)\n        # Your logic here\n      end\n    end\n  end\nend\n```\n\n" \
-              'Would you like me to scaffold a new extension?',
-
-              "Looking at the current GAIA tick cycle, here's the phase breakdown:\n\n" \
-              "| Phase | Name | Purpose |\n" \
-              "|-------|------|---------|\n" \
-              "| 1 | sensory_input | Gather raw input signals |\n" \
-              "| 2 | perception | Pattern recognition |\n" \
-              "| 3 | memory_retrieval | Query lex-memory traces |\n" \
-              "| 4 | knowledge_retrieval | Query Apollo knowledge base |\n" \
-              "| 5 | working_memory | Integrate context |\n\n" \
-              "The tick cycle runs at **configurable intervals** via `legion-gaia` settings.\n\n" \
-              '> Note: Apollo knowledge retrieval requires a running PostgreSQL instance with pgvector.',
-
-              "Here's a quick summary of what changed:\n\n" \
-              "### Modified Files\n\n" \
-              "1. `lib/legion/cli/tty/splash.rb` — New splash screen with TTY toolkit\n" \
-              "2. `lib/legion/cli/tty/chat_ui.rb` — Chat mode proof of concept\n" \
-              "3. `lib/legion/cli/tty/palette.rb` — Pastel-based palette wrapper\n\n" \
-              "All rendering uses the **17-shade single-hue** palette. No colors outside the system.\n\n" \
-              "```bash\nbundle exec exe/legion-tty\n```"
-            ]
-
-            responses[(turn - 1) % responses.length]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/cli/tty/palette.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module CLI
-    module TTY
-      module Palette
-        # LegionIO canonical palette: 17 shades, one hue, no exceptions.
-        COLORS = {
-          void:           [7,   6,   15],
-          background:     [14,  13,  26],
-          deep:           [18,  16,  41],
-          core_shell:     [24,  22,  58],
-          glow_center:    [26,  22,  64],
-          guide_rings:    [30,  28,  58],
-          core_mid:       [33,  30,  80],
-          skip:           [42,  39,  96],
-          inner_tier:     [49,  46,  128],
-          mid_arcs:       [61,  56,  138],
-          diagonal_nodes: [74,  68,  168],
-          cardinal:       [95,  87,  196],
-          mid_nodes:      [127, 119, 221],
-          inner_nodes:    [139, 131, 230],
-          innermost:      [160, 154, 232],
-          near_white:     [184, 178, 239],
-          self_point:     [197, 194, 245]
-        }.freeze
-
-        RESET = "\e[0m"
-        BOLD  = "\e[1m"
-        DIM   = "\e[2m"
-
-        class << self
-          def c(name, text)
-            rgb = COLORS[name]
-            return text.to_s unless rgb
-
-            "#{fg(name)}#{text}#{RESET}"
-          end
-
-          def bold(name, text)
-            rgb = COLORS[name]
-            return text.to_s unless rgb
-
-            "#{BOLD}#{fg(name)}#{text}#{RESET}"
-          end
-
-          def dim(name, text)
-            rgb = COLORS[name]
-            return text.to_s unless rgb
-
-            "#{DIM}#{fg(name)}#{text}#{RESET}"
-          end
-
-          def fg(name)
-            rgb = COLORS[name]
-            return '' unless rgb
-
-            "\e[38;2;#{rgb[0]};#{rgb[1]};#{rgb[2]}m"
-          end
-
-          def reset
-            RESET
-          end
-
-          # Semantic shortcuts
-          def title(text)     = bold(:self_point, text)
-          def heading(text)   = bold(:near_white, text)
-          def body(text)      = c(:inner_nodes, text)
-          def label(text)     = c(:cardinal, text)
-          def accent(text)    = c(:mid_nodes, text)
-          def muted(text)     = c(:diagonal_nodes, text)
-          def disabled(text)  = c(:skip, text)
-          def border(text)    = c(:inner_tier, text)
-          def success(text)   = c(:cardinal, text)
-          def caution(text)   = c(:innermost, text)
-          def critical(text)  = bold(:self_point, text)
-        end
-      end
-    end
-  end
-end

data/lib/legion/cli/tty/splash.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require 'tty-box'
-require 'tty-progressbar'
-require 'tty-screen'
-require 'tty-font'
-require 'tty-cursor'
-require_relative 'palette'
-
-module Legion
-  module CLI
-    module TTY
-      module Splash
-        BOOT_PHASES = [
-          { name: 'settings',   label: 'legion-settings',  version: '1.3.2',  delay: 0.15 },
-          { name: 'crypt',      label: 'legion-crypt',     version: '1.4.3',  delay: 0.20 },
-          { name: 'transport',  label: 'legion-transport', version: '1.2.1', delay: 0.30 },
-          { name: 'cache',      label: 'legion-cache',     version: '1.3.0',  delay: 0.15 },
-          { name: 'data',       label: 'legion-data',      version: '1.4.2',  delay: 0.20 },
-          { name: 'llm',        label: 'legion-llm',       version: '0.3.3',  delay: 0.15 },
-          { name: 'gaia',       label: 'legion-gaia',      version: '0.8.0',  delay: 0.10 }
-        ].freeze
-
-        EXTENSIONS = %w[
-          lex-node lex-health lex-tasker lex-scheduler lex-telemetry
-          lex-memory lex-coldstart lex-apollo lex-dream lex-reflection
-          lex-perception lex-attention lex-emotion lex-motivation
-        ].freeze
-
-        class << self
-          def run(version: '0.0.0')
-            cursor = ::TTY::Cursor
-            print cursor.hide
-
-            render_banner(version)
-            puts
-            boot_core_libraries
-            puts
-            load_extensions
-            puts
-            render_ready_line(version)
-            puts
-
-            print cursor.show
-          end
-
-          private
-
-          def render_banner(version)
-            p = Palette
-            width = [::TTY::Screen.width, 60].min
-
-            font = ::TTY::Font.new(:standard)
-            ascii_lines = font.write('LEGION').split("\n")
-
-            # Gradient the ASCII art across palette shades
-            gradient = %i[inner_tier cardinal mid_nodes inner_nodes innermost near_white]
-
-            puts
-            ascii_lines.each_with_index do |line, i|
-              shade = gradient[i % gradient.size]
-              puts "  #{p.c(shade, line)}"
-            end
-
-            puts "  #{p.border('─' * (width - 4))}"
-            puts "  #{p.accent('Async Job Engine & Cognitive Mesh')}  #{p.muted("v#{version}")}"
-            puts "  #{p.border('─' * (width - 4))}"
-          end
-
-          def boot_core_libraries
-            p = Palette
-            puts "  #{p.heading('Core Libraries')}"
-            puts
-
-            BOOT_PHASES.each do |phase|
-              puts "  #{p.success('✔')} #{p.label(phase[:label].ljust(20))} #{p.muted(phase[:version])}  #{p.success('ready')}"
-            end
-          end
-
-          def load_extensions
-            p = Palette
-            puts "  #{p.heading('Extensions')}  #{p.muted("(#{EXTENSIONS.size} discovered)")}"
-            puts
-
-            bar = ::TTY::ProgressBar.new(
-              "  #{p.fg(:cardinal)}:bar#{p.reset} :current/:total  #{p.fg(:diagonal_nodes)}:eta#{p.reset}",
-              total:      EXTENSIONS.size,
-              width:      30,
-              complete:   "\u2588",
-              incomplete: "\u2591",
-              head:       "\u2588",
-              output:     $stdout
-            )
-
-            EXTENSIONS.each { |_ext| bar.advance(1) }
-
-            puts
-            EXTENSIONS.each_slice(4) do |group|
-              line = group.map { |ext| p.muted(ext.ljust(18)) }.join
-              puts "  #{line}"
-            end
-          end
-
-          def render_ready_line(version)
-            p = Palette
-            width = [::TTY::Screen.width, 60].min
-
-            puts "  #{p.border('─' * (width - 4))}"
-
-            content = "#{p.success('Ready')} #{p.body("#{EXTENSIONS.size} extensions")} " \
-                      "#{p.muted('|')} #{p.body("#{BOOT_PHASES.size} libraries")} " \
-                      "#{p.muted('|')} #{p.accent("v#{version}")}"
-            puts "  #{p.border('┌')}#{p.border('─' * (width - 6))}#{p.border('┐')}"
-            puts "  #{p.border('│')}  #{content}  #{p.border('│')}"
-            puts "  #{p.border('└')}#{p.border('─' * (width - 6))}#{p.border('┘')}"
-          end
-        end
-      end
-    end
-  end
-end