legionio 1.4.192 → 1.4.197

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5df6894cf4d95b284ae6941616de97dd340f587b7cdff3bacf4747e82dcbd59
-  data.tar.gz: dae8d3572fa9a72eeb38a77c180b1c020df29d3db5183686143c3f94af13a1f6
+  metadata.gz: 547bcf88727783f2d13346201194840fac26054686d646f4c357bbd366302187
+  data.tar.gz: 90801baaf55c27542bee67621c343ef5aacb0801f245ba78291e19dc6c867c92
 SHA512:
-  metadata.gz: 035d06ce47e12222cf7cd96a8bb0d2b2f4aef9db8b20d78068890d63fc6e5d97e984fa2403e4e29567361fe43c98d332b0b09c688c8358d20867e5e0e5ce3ed7
-  data.tar.gz: 0fbec6e0c903c4d9831b7802e34ba4699e7a4e0cc76353b7cc2793fa36c80c89a311955dca920394f01c857e71b93cd2e28c19577c24467ceee97593d1c6fc5e
+  metadata.gz: 19a98825568321c1dc9fd1c78aa6d1b621aab3eb8d0e17e5fe7073192508a0e8f892276f82e7d7c45a7c952f07f645a8bfa670f9d4f3d3b0f0760fee2955c0fe
+  data.tar.gz: 3a9dd4466bf92e96b860f6b38e0976e1c5a48526b4bded1150847449e96745207baa452de506fb44dedda93eaac1f6bee9120ad3aa015a8a99bbc0db70cb9af1

data/.github/workflows/publish-homebrew.yml

@@ -0,0 +1,31 @@
+name: Publish to Homebrew
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  trigger-homebrew:
+    runs-on: ubuntu-latest
+    if: startsWith(github.event.release.tag_name, 'v')
+    steps:
+      - name: Extract version from tag
+        id: version
+        run: |
+          TAG="${RELEASE_TAG}"
+          VERSION="${TAG#v}"
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "Extracted version: $VERSION"
+        env:
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+
+      - name: Trigger build-legion on homebrew-tap
+        run: |
+          gh api repos/LegionIO/homebrew-tap/dispatches \
+            -f event_type=build-legion \
+            -f "client_payload[legionio_version]=${LEGIONIO_VERSION}" \
+            -f "client_payload[ruby_version]=3.4.8" \
+            -f "client_payload[package_revision]=1"
+        env:
+          GH_TOKEN: ${{ secrets.HOMEBREW_DISPATCH_TOKEN }}
+          LEGIONIO_VERSION: ${{ steps.version.outputs.version }}

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Legion Changelog
 
+## [1.4.197] - 2026-03-24
+
+### Changed
+- Add debug logging to 8 swallowed `rescue StandardError` blocks in chat tools and session store: ModelComparison, SystemStatus (fetch_health, fetch_ready), SessionStore (generate_summary, read_session_meta), SaveMemory (ingest_to_apollo), GenerateInsights (scheduling_status, llm_status)
+
+## [1.4.196] - 2026-03-24
+
+### Added
+- LLM fallback in `legion do` command: when keyword matching (`find_by_intent`) returns no results, classifies intent via `Legion::LLM.ask` against the full Capability Registry catalog
+- Graceful degradation: LLM path only activates when both `Legion::LLM` and `Catalog::Registry` are loaded; errors fall through silently
+
+## [1.4.195] - 2026-03-24
+
+### Added
+- `legion do "TEXT"` CLI command: natural language intent router that matches free-text to Capability Registry entries and dispatches via daemon API or in-process Ingress
+- `DoCommand` module with two resolution paths: daemon HTTP dispatch (like `dream`) and in-process `Registry.find_by_intent` + `Ingress.run` fallback
+
+## [1.4.194] - 2026-03-24
+
+### Added
+- `--lite` flag on `legion start` command: sets `LEGION_MODE=lite` and `LEGION_LOCAL=true` env vars, assigns `:lite` process role
+- `:lite` process role in `ProcessRole::ROLES`: all subsystems enabled except `crypt: false` (Vault not needed in lite mode)
+- `Service#lite_mode?` checks `LEGION_MODE` env var and `settings[:mode]`
+- `setup_local_mode` handles lite mode: sets dev flag, loads Transport::Local, loads mock_vault if Crypt is defined
+
+## [1.4.193] - 2026-03-24
+
+### Added
+- `legion mind-growth` CLI subcommand with 10 commands: status, propose, approve, reject, build, proposals, profile, health, report, history
+- Delegates to `Legion::Extensions::MindGrowth::Client` (lex-mind-growth extension)
+- Guards with `require_mind_growth!` — raises `CLI::Error` when extension is not loaded
+- Supports `--json` and `--no-color` class options on all subcommands
+
 ## [1.4.192] - 2026-03-24
 
 ### Fixed

data/lib/legion/api/apollo.rb

@@ -123,7 +123,8 @@ module Legion
 
         def apollo_data_connected?
           defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && !Legion::Data.connection.nil?
-        rescue StandardError
+        rescue StandardError => e
+          Legion::Logging.debug("Apollo#apollo_data_connected? check failed: #{e.message}") if defined?(Legion::Logging)
           false
         end
 

data/lib/legion/api/costs.rb

@@ -46,7 +46,8 @@ module Legion
       module CostHelpers
         def metering_available?
           defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && !Legion::Data.connection.nil?
-        rescue StandardError
+        rescue StandardError => e
+          Legion::Logging.debug("CostHelpers#metering_available? check failed: #{e.message}") if defined?(Legion::Logging)
           false
         end
 

data/lib/legion/cli/chat/session_store.rb

@@ -90,7 +90,8 @@ module Legion
             first_msg = user_messages.first[:content].to_s.strip
             first_msg = "#{first_msg[0..120]}..." if first_msg.length > 120
             first_msg
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("SessionStore#generate_summary failed: #{e.message}") if defined?(Legion::Logging)
             nil
           end
 
@@ -102,7 +103,8 @@ module Legion
               summary:       data[:summary],
               model:         data[:model]
             }
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("SessionStore#read_session_meta failed: #{e.message}") if defined?(Legion::Logging)
             { message_count: nil, summary: nil, model: nil }
           end
         end

data/lib/legion/cli/chat/tools/generate_insights.rb

@@ -166,7 +166,8 @@ module Legion
             end
             result[:batch] = Legion::LLM::Batch.status if defined?(Legion::LLM::Batch)
             result.empty? ? nil : result
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("GenerateInsights#scheduling_status failed: #{e.message}") if defined?(Legion::Logging)
             nil
           end
 
@@ -181,7 +182,8 @@ module Legion
               result[:shadow_evals] = s[:total_evaluations]
             end
             result.empty? ? nil : result
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("GenerateInsights#llm_status failed: #{e.message}") if defined?(Legion::Logging)
             nil
           end
 

data/lib/legion/cli/chat/tools/model_comparison.rb

@@ -40,7 +40,8 @@ module Legion
             Legion::LLM::CostTracker::DEFAULT_PRICING.transform_values do |v|
               { input: v[:input], output: v[:output] }
             end
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("ModelComparison#cost_tracker_pricing failed: #{e.message}") if defined?(Legion::Logging)
             {}
           end
 

data/lib/legion/cli/chat/tools/save_memory.rb

@@ -54,7 +54,8 @@ module Legion
             return nil if data[:error]
 
             'Also ingested into Apollo knowledge graph.'
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("SaveMemory#ingest_to_apollo failed: #{e.message}") if defined?(Legion::Logging)
             nil
           end
 

data/lib/legion/cli/chat/tools/system_status.rb

@@ -39,7 +39,8 @@ module Legion
             api_get('/api/health')
           rescue Errno::ECONNREFUSED
             raise
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("SystemStatus#fetch_health failed: #{e.message}") if defined?(Legion::Logging)
             nil
           end
 
@@ -47,7 +48,8 @@ module Legion
             api_get('/api/ready')
           rescue Errno::ECONNREFUSED
             raise
-          rescue StandardError
+          rescue StandardError => e
+            Legion::Logging.debug("SystemStatus#fetch_ready failed: #{e.message}") if defined?(Legion::Logging)
             nil
           end
 

data/lib/legion/cli/do_command.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Legion
+  module CLI
+    module DoCommand
+      class << self
+        def run(intent, formatter, options)
+          if intent.strip.empty?
+            formatter.error('Usage: legion do "describe what you want"')
+            raise SystemExit, 1
+          end
+
+          formatter.detail("Routing intent: #{intent}")
+
+          result = try_daemon(intent, options) || try_in_process(intent) || try_llm_classify(intent)
+
+          if result.nil?
+            formatter.error('No matching capability found')
+            formatter.detail('Try: legion lex list  (to see available extensions)')
+            raise SystemExit, 1
+          end
+
+          display_result(result, formatter, options)
+        end
+
+        private
+
+        def try_daemon(intent, options)
+          require 'net/http'
+          require 'json'
+
+          port = daemon_port(options)
+          uri = URI("http://localhost:#{port}/api/tasks")
+          body = ::JSON.generate({
+                                   runner_class:  resolve_runner_class(intent) || return,
+                                   function:      resolve_function(intent) || return,
+                                   payload:       { intent: intent },
+                                   source:        'cli:do',
+                                   check_subtask: false,
+                                   generate_task: true
+                                 })
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.open_timeout = 3
+          http.read_timeout = 30
+          request = Net::HTTP::Post.new(uri.path, 'Content-Type' => 'application/json')
+          request.body = body
+
+          response = http.request(request)
+          ::JSON.parse(response.body, symbolize_names: true)
+        rescue Errno::ECONNREFUSED, Net::OpenTimeout
+          nil
+        end
+
+        def try_in_process(intent)
+          return nil unless defined?(Legion::Extensions::Catalog::Registry)
+
+          matches = Legion::Extensions::Catalog::Registry.find_by_intent(intent)
+          return nil if matches.empty?
+
+          best = matches.first
+          runner_class = build_runner_class(best.extension, best.runner)
+
+          if defined?(Legion::Ingress)
+            Legion::Ingress.run(
+              payload:      { intent: intent },
+              runner_class: runner_class,
+              function:     best.function,
+              source:       'cli:do'
+            )
+          else
+            { matched: best.name, runner_class: runner_class, function: best.function,
+              status: 'resolved', note: 'Daemon not running; cannot execute. Start with: legion start' }
+          end
+        end
+
+        def try_llm_classify(intent)
+          return nil unless defined?(Legion::Extensions::Catalog::Registry) && defined?(Legion::LLM)
+
+          caps = Legion::Extensions::Catalog::Registry.capabilities
+          return nil if caps.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). ' \
+                   'If none match, reply NONE.'
+
+          response = Legion::LLM.ask(
+            message: prompt,
+            caller:  { extension: 'legionio', tool: 'do_command', tier: 'cli' }
+          )
+          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
+
+          runner_class = build_runner_class(cap.extension, cap.runner)
+          { matched: cap.name, runner_class: runner_class, function: cap.function,
+            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)
+          nil
+        end
+
+        def resolve_runner_class(intent)
+          return nil unless defined?(Legion::Extensions::Catalog::Registry)
+
+          matches = Legion::Extensions::Catalog::Registry.find_by_intent(intent)
+          return nil if matches.empty?
+
+          build_runner_class(matches.first.extension, matches.first.runner)
+        end
+
+        def resolve_function(intent)
+          return nil unless defined?(Legion::Extensions::Catalog::Registry)
+
+          matches = Legion::Extensions::Catalog::Registry.find_by_intent(intent)
+          return nil if matches.empty?
+
+          matches.first.function
+        end
+
+        def build_runner_class(extension, runner)
+          ext_part = extension.delete_prefix('lex-').split(/[-_]/).map(&:capitalize).join
+          "Legion::Extensions::#{ext_part}::Runners::#{runner}"
+        end
+
+        def daemon_port(options)
+          options[:http_port] || begin
+            require 'legion/settings'
+            Legion::Settings.load unless Legion::Settings.loaded?
+            Legion::Settings.dig(:api, :port) || 4567
+          rescue StandardError
+            4567
+          end
+        end
+
+        def display_result(result, formatter, options)
+          if options[:json]
+            formatter.json(result)
+          elsif result.is_a?(Hash) && result[:error]
+            formatter.error(result.dig(:error, :message) || result[:error].to_s)
+          elsif result.is_a?(Hash) && result[:data]
+            formatter.success('Task dispatched')
+            formatter.detail(result[:data])
+          elsif result.is_a?(Hash) && result[:matched]
+            formatter.success("Matched: #{result[:matched]}")
+            formatter.detail(result.except(:matched))
+          else
+            formatter.success('Done')
+            formatter.detail(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/mind_growth_command.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'thor'
+
+module Legion
+  module CLI
+    class MindGrowth < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      class_option :json,     type: :boolean, default: false, desc: 'Output as JSON'
+      class_option :no_color, type: :boolean, default: false, desc: 'Disable color output'
+      class_option :verbose,  type: :boolean, default: false, aliases: ['-V'], desc: 'Verbose logging'
+
+      desc 'status', 'Show mind-growth cycle status'
+      def status
+        require_mind_growth!
+        result = mind_growth_client.growth_status
+        out = formatter
+        if options[:json]
+          out.json(result)
+        else
+          out.header('Mind-Growth Status')
+          out.spacer
+          out.detail(result)
+        end
+      end
+
+      desc 'propose', 'Propose a new cognitive concept'
+      option :category,    type: :string, desc: 'Cognitive category'
+      option :description, type: :string, desc: 'Concept description'
+      option :name,        type: :string, desc: 'Concept name'
+      def propose
+        require_mind_growth!
+        result = mind_growth_client.propose_concept(
+          category:    options[:category]&.to_sym,
+          description: options[:description],
+          name:        options[:name]
+        )
+        out = formatter
+        if options[:json]
+          out.json(result)
+        elsif result[:success]
+          out.success("Proposal created: #{result.dig(:proposal, :id)}")
+        else
+          out.warn("Proposal failed: #{result[:error]}")
+        end
+      end
+
+      desc 'approve ID', 'Approve a proposal'
+      def approve(proposal_id)
+        require_mind_growth!
+        result = mind_growth_client.evaluate_proposal(proposal_id: proposal_id)
+        out = formatter
+        if options[:json]
+          out.json(result)
+        elsif result[:success]
+          status_label = result[:approved] ? 'approved' : 'rejected'
+          out.success("Proposal #{proposal_id[0, 8]} #{status_label}")
+        else
+          out.warn("Evaluation failed: #{result[:error]}")
+        end
+      end
+
+      desc 'reject ID', 'Reject a proposal'
+      map 'reject' => :reject_proposal
+      option :reason, type: :string, desc: 'Rejection reason'
+      def reject_proposal(proposal_id)
+        require_mind_growth!
+        proposal = Legion::Extensions::MindGrowth::Runners::Proposer.get_proposal_object(proposal_id)
+        out = formatter
+        if proposal.nil?
+          out.warn("Proposal #{proposal_id[0, 8]} not found")
+          return
+        end
+        proposal.transition!(:rejected)
+        if options[:json]
+          out.json({ success: true, proposal_id: proposal_id, status: 'rejected',
+                     reason: options[:reason] })
+        else
+          out.success("Proposal #{proposal_id[0, 8]} rejected")
+        end
+      rescue ArgumentError => e
+        formatter.warn("Cannot reject: #{e.message}")
+      end
+
+      desc 'build ID', 'Force-build an approved proposal'
+      def build(proposal_id)
+        require_mind_growth!
+        result = mind_growth_client.build_extension(proposal_id: proposal_id)
+        out = formatter
+        if options[:json]
+          out.json(result)
+        elsif result[:success]
+          out.success("Build pipeline started for #{proposal_id[0, 8]}")
+          out.detail(result[:pipeline]) if result[:pipeline]
+        else
+          out.warn("Build failed: #{result[:error]}")
+        end
+      end
+
+      desc 'proposals', 'List proposals'
+      option :status, type: :string, desc: 'Filter by status'
+      option :limit,  type: :numeric, default: 20, desc: 'Max results'
+      def proposals
+        require_mind_growth!
+        result = mind_growth_client.list_proposals(
+          status: options[:status]&.to_sym,
+          limit:  options[:limit]
+        )
+        out = formatter
+        if options[:json]
+          out.json(result)
+        else
+          rows = (result[:proposals] || []).map do |p|
+            [p[:id].to_s[0, 8], p[:name].to_s, p[:category].to_s,
+             p[:status].to_s, p[:created_at].to_s]
+          end
+          if rows.empty?
+            out.warn('No proposals found')
+          else
+            out.table(%w[id name category status created_at], rows)
+          end
+        end
+      end
+
+      desc 'profile', 'Show cognitive architecture profile'
+      def profile
+        require_mind_growth!
+        result = mind_growth_client.cognitive_profile
+        out = formatter
+        if options[:json]
+          out.json(result)
+        else
+          out.header('Cognitive Architecture Profile')
+          out.spacer
+          out.detail({ total_extensions: result[:total_extensions],
+                       overall_coverage: result[:overall_coverage] })
+          out.spacer
+          coverage = result[:model_coverage] || {}
+          rows = coverage.map { |model, data| [model.to_s, data[:coverage].to_s, data[:missing].to_s] }
+          out.table(%w[model coverage missing], rows) unless rows.empty?
+        end
+      end
+
+      desc 'health', 'Show extension health and fitness scores'
+      def health
+        require_mind_growth!
+        result = mind_growth_client.validate_fitness(extensions: [])
+        out = formatter
+        if options[:json]
+          out.json(result)
+        else
+          out.header('Extension Fitness')
+          out.spacer
+          ranked = result[:ranked] || []
+          if ranked.empty?
+            out.warn('No extensions to score')
+          else
+            rows = ranked.map { |e| [e[:name].to_s, format('%.3f', e[:fitness].to_f)] }
+            out.table(%w[extension fitness], rows)
+          end
+        end
+      end
+
+      desc 'report', 'Generate retrospective report'
+      def report
+        require_mind_growth!
+        result = mind_growth_client.session_report
+        out = formatter
+        if options[:json]
+          out.json(result)
+        else
+          out.header('Mind-Growth Report')
+          out.spacer
+          out.detail(result)
+        end
+      end
+
+      desc 'history', 'Show recent proposal history'
+      option :limit, type: :numeric, default: 50, desc: 'Max results'
+      def history
+        require_mind_growth!
+        result = mind_growth_client.list_proposals(limit: options[:limit])
+        out = formatter
+        if options[:json]
+          out.json(result)
+        else
+          rows = (result[:proposals] || []).map do |p|
+            [p[:id].to_s[0, 8], p[:name].to_s, p[:category].to_s,
+             p[:status].to_s, p[:created_at].to_s]
+          end
+          if rows.empty?
+            out.warn('No proposals found')
+          else
+            out.table(%w[id name category status created_at], rows)
+          end
+        end
+      end
+
+      no_commands do
+        def formatter
+          @formatter ||= Output::Formatter.new(
+            json:  options[:json],
+            color: !options[:no_color]
+          )
+        end
+
+        def require_mind_growth!
+          return if defined?(Legion::Extensions::MindGrowth::Client)
+
+          raise CLI::Error, 'lex-mind-growth extension is not loaded. Install and enable it first.'
+        end
+
+        def mind_growth_client
+          @mind_growth_client ||= Legion::Extensions::MindGrowth::Client.new
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/start.rb

@@ -5,6 +5,11 @@ module Legion
     module Start
       class << self
         def run(options)
+          if options[:lite]
+            ENV['LEGION_MODE'] = 'lite'
+            ENV['LEGION_LOCAL'] = 'true'
+          end
+
           log_level = options[:log_level] || 'info'
 
           require 'legion'
@@ -16,6 +21,7 @@ module Legion
           api = options.fetch(:api, true)
           service_opts = { log_level: log_level, api: api }
           service_opts[:http_port] = options[:http_port] if options[:http_port]
+          service_opts[:role] = :lite if options[:lite]
           Legion.instance_variable_set(:@service, Legion::Service.new(**service_opts))
           Legion::Logging.info("Started Legion v#{Legion::VERSION}")
 

data/lib/legion/cli.rb

@@ -24,7 +24,8 @@ module Legion
     autoload :Commit,    'legion/cli/commit_command'
     autoload :Pr,        'legion/cli/pr_command'
     autoload :Review,    'legion/cli/review_command'
-    autoload :Memory,    'legion/cli/memory_command'
+    autoload :Memory,      'legion/cli/memory_command'
+    autoload :MindGrowth,  'legion/cli/mind_growth_command'
     autoload :Plan,      'legion/cli/plan_command'
     autoload :Swarm,     'legion/cli/swarm_command'
     autoload :Gaia,       'legion/cli/gaia_command'
@@ -54,6 +55,7 @@ module Legion
     autoload :Tty,            'legion/cli/tty_command'
     autoload :ObserveCommand, 'legion/cli/observe_command'
     autoload :Payroll,        'legion/cli/payroll_command'
+    autoload :DoCommand,   'legion/cli/do_command'
     autoload :Interactive, 'legion/cli/interactive'
     autoload :Docs,        'legion/cli/docs_command'
     autoload :Failover,    'legion/cli/failover_command'
@@ -122,6 +124,7 @@ module Legion
       option :log_level, type: :string, default: 'info', desc: 'Log level (debug, info, warn, error)'
       option :api, type: :boolean, default: true, desc: 'Start the HTTP API server'
       option :http_port, type: :numeric, desc: 'HTTP API port (overrides settings)'
+      option :lite, type: :boolean, default: false, desc: 'Start in lite mode (no external services)'
       def start
         Legion::CLI::Start.run(options)
       end
@@ -218,6 +221,9 @@ module Legion
       desc 'memory SUBCOMMAND', 'Persistent project memory across sessions'
       subcommand 'memory', Legion::CLI::Memory
 
+      desc 'mind-growth SUBCOMMAND', 'Autonomous cognitive architecture expansion'
+      subcommand 'mind-growth', Legion::CLI::MindGrowth
+
       desc 'plan', 'Start plan mode (read-only exploration, no writes)'
       subcommand 'plan', Legion::CLI::Plan
 
@@ -325,6 +331,21 @@ module Legion
         Legion::CLI::Chat.start(['prompt', text.join(' ')] + ARGV.select { |a| a.start_with?('--') })
       end
 
+      desc 'do TEXT', 'Route a natural language intent to the right extension'
+      long_desc <<~DESC
+        Describe what you want in plain English. Legion routes to the best
+        matching extension and runner automatically.
+
+        Examples:
+          legion do "check consul health"
+          legion do "list running tasks"
+          legion do "review the latest PR"
+      DESC
+      def do_action(*text)
+        Legion::CLI::DoCommand.run(text.join(' '), formatter, options)
+      end
+      map 'do' => :do_action
+
       desc 'dream', 'Trigger a dream cycle on the running daemon'
       option :wait, type: :boolean, default: false, desc: 'Wait for dream cycle to complete'
       def dream

data/lib/legion/process_role.rb

@@ -6,7 +6,8 @@ module Legion
       full:   { transport: true,  cache: true, data: true,  extensions: true,  api: true,  llm: true,  gaia: true,  crypt: true, supervision: true  },
       api:    { transport: true,  cache: true, data: true,  extensions: false, api: true,  llm: false, gaia: false, crypt: true, supervision: false },
       worker: { transport: true,  cache: true, data: true,  extensions: true,  api: false, llm: true,  gaia: true,  crypt: true, supervision: true  },
-      router: { transport: true,  cache: true, data: false, extensions: true,  api: false, llm: false, gaia: false, crypt: true, supervision: false }
+      router: { transport: true,  cache: true, data: false, extensions: true,  api: false, llm: false, gaia: false, crypt: true, supervision: false },
+      lite:   { transport: true,  cache: true, data: true,  extensions: true,  api: true,  llm: true,  gaia: true,  crypt: false, supervision: true }
     }.freeze
 
     def self.resolve(role_name)

data/lib/legion/service.rb

@@ -97,6 +97,14 @@ module Legion
     end
 
     def setup_local_mode
+      if lite_mode?
+        Legion::Logging.info 'Starting in lite mode (zero infrastructure)'
+        Legion::Settings[:dev] = true
+        require 'legion/transport/local'
+        require 'legion/crypt/mock_vault' if defined?(Legion::Crypt)
+        return
+      end
+
       return unless local_mode?
 
       Legion::Logging.info 'Starting in local development mode'
@@ -111,6 +119,11 @@ module Legion
         Legion::Settings[:local_mode] == true
     end
 
+    def lite_mode?
+      ENV['LEGION_MODE'] == 'lite' ||
+        Legion::Settings[:mode].to_s == 'lite'
+    end
+
     def setup_data
       Legion::Logging.info 'Setting up Legion::Data'
       require 'legion/data'

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.192
+  version: 1.4.197
 platform: ruby
 authors:
 - Esity
@@ -361,6 +361,7 @@ files:
 - ".github/workflow-templates/eval-gate.yml"
 - ".github/workflows/ci-cd.yml"
 - ".github/workflows/ci.yml"
+- ".github/workflows/publish-homebrew.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - CHANGELOG.md
@@ -548,6 +549,7 @@ files:
 - lib/legion/cli/dashboard_command.rb
 - lib/legion/cli/dataset_command.rb
 - lib/legion/cli/detect_command.rb
+- lib/legion/cli/do_command.rb
 - lib/legion/cli/docs_command.rb
 - lib/legion/cli/doctor.rb
 - lib/legion/cli/doctor/bundle_check.rb
@@ -628,6 +630,7 @@ files:
 - lib/legion/cli/marketplace_command.rb
 - lib/legion/cli/mcp_command.rb
 - lib/legion/cli/memory_command.rb
+- lib/legion/cli/mind_growth_command.rb
 - lib/legion/cli/notebook_command.rb
 - lib/legion/cli/observe_command.rb
 - lib/legion/cli/openapi_command.rb