legionio 1.6.3 → 1.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72cd45444eead02f6fe56c876cc25c42c4f74111beaf76e5d898cbe94dbf2ea6
-  data.tar.gz: f9f69b056a77e373eff39813f96f79882509dfdf7273bc81afee92dc556d84f6
+  metadata.gz: cd3587ed7997208005a0a8746aca477701811f8e506c1d8d9345a40d180317fc
+  data.tar.gz: e805096f6577c2b1317807d50beab27bbb91527e2a02807231596fbd6a1d91ca
 SHA512:
-  metadata.gz: e86e061031320558c96fddc8bfabf2380a97cd51ee27a87d61cd7758e7cb432f8dc2b45257447146ad93ba16f4fd7100de3a90b2f3ecb95d41535a08efaf53af
-  data.tar.gz: 40420f889daf45ddf2f75533e981063b33501423ae330e59114b40dfff899e345c1deeb82c9244183842c78a952b9ad1a39d9b10ad54056afd3a7f7b3a59f0ec
+  metadata.gz: 5d6c20753f9803fc34cd4bb577304bc31d708df54f9e49f266dbb32073c3d06835e2d625efbed610244b5888085d823222627fb07ad889c1ff85d37d028f603a
+  data.tar.gz: 0a1dbbff5e24580f3b8b97fb434c626f029f449501b138d0a29f9fcb0eb15edd05808c5b34353260a6bdc4808d4f747362d8f4e6e9f3afdd47362b56035c1e0f

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Legion Changelog
 
+## [1.6.8] - 2026-03-26
+
+### Added
+- `legionio bootstrap SOURCE` command: combines `config import`, `config scaffold`, and `setup agentic` into one command
+- Pre-flight checks for klist (Kerberos ticket), brew availability, and legionio binary
+- `--skip-packs`, `--start`, `--force`, `--json` flags for bootstrap command
+- Self-awareness system prompt enrichment: `Context.to_system_prompt` appends live metacognition self-narrative from `lex-agentic-self` when loaded; guarded with `defined?()` and `rescue StandardError`
+
+## [1.6.7] - 2026-03-26
+
+### Fixed
+- `setup_generated_functions` now runs only when `extensions: true` (inside the extensions gate) preventing unexpected boot side-effects in CLI flows that disable extensions
+- Consumer tag entropy upgraded from `SecureRandom.hex(4)` (32-bit) to `SecureRandom.uuid` (122-bit) in both `prepare` and `subscribe` paths of subscription actor, eliminating the theoretical RabbitMQ `NOT_ALLOWED` tag collision
+
+## [1.6.4] - 2026-03-26
+
+### Fixed
+- fix consumer tag collision on boot: subscription actors using `Thread.current.object_id` produced duplicate tags when `FixedThreadPool` reused threads, causing RabbitMQ `NOT_ALLOWED` connection kill and cascading errors; replaced with `SecureRandom.hex(4)`
+
 ## [1.6.3] - 2026-03-26
 
 ### Changed
@@ -24,6 +43,12 @@
 ## [1.6.0] - 2026-03-26
 
 ### Added
+- `legion codegen` CLI subcommand (status, list, show, approve, reject, retry, gaps, cycle)
+- `/api/codegen/*` API routes for generated function management
+- Boot loading for generated functions via GeneratedRegistry
+- Function metadata DSL (function_outputs, function_category, function_tags, function_risk_tier, function_idempotent, function_requires, function_expose)
+- ClassMethods for MCP tool exposure (expose_as_mcp_tool, mcp_tool_prefix)
+- End-to-end integration test for self-generating functions
 - `legion knowledge monitor add/list/remove/status` — multi-directory corpus monitor management
 - `legion knowledge capture commit` — capture git commit as knowledge (hook-compatible)
 - `legion knowledge capture session` — capture session summary as knowledge (hook-compatible)

data/lib/legion/api/codegen.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Codegen
+        def self.registered(app) # rubocop:disable Metrics/MethodLength
+          app.get '/api/codegen/status' do
+            halt 503, json_error('codegen_unavailable', 'codegen not available', status_code: 503) unless defined?(Legion::MCP::SelfGenerate)
+
+            json_response(Legion::MCP::SelfGenerate.status)
+          end
+
+          app.get '/api/codegen/generated' do
+            unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
+              halt 503, json_error('codegen_unavailable', 'codegen not available', status_code: 503)
+            end
+
+            status_filter = params[:status]
+            records = Legion::Extensions::Codegen::Helpers::GeneratedRegistry.list(status: status_filter)
+            json_response(records)
+          end
+
+          app.get '/api/codegen/generated/:id' do |id|
+            unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
+              halt 503, json_error('codegen_unavailable', 'codegen not available', status_code: 503)
+            end
+
+            record = Legion::Extensions::Codegen::Helpers::GeneratedRegistry.get(id: id)
+            halt 404, json_error('not_found', 'record not found', status_code: 404) unless record
+
+            json_response(record)
+          end
+
+          app.post '/api/codegen/generated/:id/approve' do |id|
+            unless defined?(Legion::Extensions::Codegen::Runners::ReviewHandler)
+              halt 503, json_error('codegen_unavailable', 'review handler not available', status_code: 503)
+            end
+
+            result = Legion::Extensions::Codegen::Runners::ReviewHandler.handle_verdict(
+              review: { generation_id: id, verdict: :approve, confidence: 1.0 }
+            )
+            json_response(result)
+          end
+
+          app.post '/api/codegen/generated/:id/reject' do |id|
+            unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
+              halt 503, json_error('codegen_unavailable', 'codegen not available', status_code: 503)
+            end
+
+            Legion::Extensions::Codegen::Helpers::GeneratedRegistry.update_status(id: id, status: 'rejected')
+            json_response({ id: id, status: 'rejected' })
+          end
+
+          app.post '/api/codegen/generated/:id/retry' do |id|
+            unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
+              halt 503, json_error('codegen_unavailable', 'codegen not available', status_code: 503)
+            end
+
+            Legion::Extensions::Codegen::Helpers::GeneratedRegistry.update_status(id: id, status: 'pending')
+            json_response({ id: id, status: 'pending' })
+          end
+
+          app.get '/api/codegen/gaps' do
+            data = if defined?(Legion::MCP::GapDetector)
+                     Legion::MCP::GapDetector.detect_gaps
+                   else
+                     []
+                   end
+            json_response(data)
+          end
+
+          app.post '/api/codegen/cycle' do
+            return json_response({ triggered: false, reason: 'self_generate not available' }) unless defined?(Legion::MCP::SelfGenerate)
+
+            Legion::MCP::SelfGenerate.instance_variable_set(:@last_cycle_at, nil)
+            result = Legion::MCP::SelfGenerate.run_cycle
+            json_response(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -46,6 +46,7 @@ require_relative 'api/apollo'
 require_relative 'api/costs'
 require_relative 'api/traces'
 require_relative 'api/stats'
+require_relative 'api/codegen'
 require_relative 'api/graphql' if defined?(GraphQL)
 
 module Legion
@@ -137,6 +138,7 @@ module Legion
     register Routes::Costs
     register Routes::Traces
     register Routes::Stats
+    register Routes::Codegen
     register Routes::GraphQL if defined?(Routes::GraphQL)
 
     use Legion::API::Middleware::RequestLogger

data/lib/legion/cli/bootstrap_command.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'json'
+require 'fileutils'
+require 'rbconfig'
+require 'thor'
+require 'legion/cli/output'
+
+module Legion
+  module CLI
+    class Bootstrap < Thor
+      namespace 'bootstrap'
+
+      def self.exit_on_failure?
+        true
+      end
+
+      class_option :json,       type: :boolean, default: false, desc: 'Machine-readable output'
+      class_option :no_color,   type: :boolean, default: false, desc: 'Disable color output'
+      class_option :skip_packs, type: :boolean, default: false, desc: 'Skip gem pack installation (config only)'
+      class_option :start,      type: :boolean, default: false, desc: 'Start redis + legionio via brew services after bootstrap'
+      class_option :force,      type: :boolean, default: false, desc: 'Overwrite existing config files'
+
+      desc 'SOURCE', 'Bootstrap Legion from a URL or local config file (fetch config, scaffold, install packs)'
+      long_desc <<~DESC
+        Combines three manual steps into one:
+
+          legionio config import SOURCE   (fetch + write config)
+          legionio config scaffold        (fill gaps with env-detected defaults)
+          legionio setup agentic          (install cognitive gem packs)
+
+        SOURCE may be an HTTPS URL or a local file path to a bootstrap JSON file.
+        The JSON may include a "packs" array (e.g. ["agentic"]) which controls which
+        gem packs are installed. That key is removed before the config is written.
+
+        Options:
+          --skip-packs   Skip gem pack installation entirely
+          --start        After bootstrap, run: brew services start redis && brew services start legionio
+          --force        Overwrite existing config files
+          --json         Machine-readable JSON output
+      DESC
+      def execute(source)
+        require_relative 'config_import'
+        require_relative 'config_scaffold'
+        require_relative 'setup_command'
+
+        out     = formatter
+        results = {}
+        warns   = []
+
+        # 1. Pre-flight checks
+        print_step(out, 'Pre-flight checks')
+        results[:preflight] = run_preflight_checks(out, warns)
+
+        # 2. Fetch + parse config
+        print_step(out, "Fetching config from #{source}")
+        body   = ConfigImport.fetch_source(source)
+        config = ConfigImport.parse_payload(body)
+
+        # 3. Extract packs before writing (bootstrap-only directive)
+        pack_names = Array(config.delete(:packs)).map(&:to_s).reject(&:empty?)
+        results[:packs_requested] = pack_names
+
+        # 4. Write config
+        path = ConfigImport.write_config(config, force: options[:force])
+        results[:config_written] = path
+        out.success("Config written to #{path}") unless options[:json]
+
+        # 5. Scaffold missing subsystem files
+        results[:scaffold] = run_scaffold(out)
+
+        # 6. Install packs (unless --skip-packs)
+        results[:packs_installed] = install_packs_step(pack_names, out)
+
+        # 7. Post-bootstrap summary
+        summary = build_summary(config, results, warns)
+        results[:summary] = summary
+        print_summary(out, summary)
+
+        # 8. Optional --start
+        if options[:start]
+          print_step(out, 'Starting services')
+          results[:services_started] = start_services(out)
+        end
+
+        out.json(results) if options[:json]
+      rescue CLI::Error => e
+        formatter.error(e.message)
+        raise SystemExit, 1
+      end
+
+      default_task :execute
+
+      no_commands do # rubocop:disable Metrics/BlockLength
+        def formatter
+          @formatter ||= Output::Formatter.new(
+            json:  options[:json],
+            color: !options[:no_color]
+          )
+        end
+
+        private
+
+        def print_step(out, message)
+          return if options[:json]
+
+          out.spacer
+          out.header(message)
+        end
+
+        # Wraps backtick execution, returning [output, success_bool].
+        # Extracted as a method so specs can stub it cleanly.
+        def shell_capture(cmd)
+          output = `#{cmd} 2>&1`
+          [output, $CHILD_STATUS.success?]
+        end
+
+        # -----------------------------------------------------------------------
+        # Pre-flight checks
+        # -----------------------------------------------------------------------
+
+        def run_preflight_checks(out, warns)
+          {
+            klist:    check_klist(out, warns),
+            brew:     check_brew(out, warns),
+            legionio: check_legionio_binary(out, warns)
+          }
+        end
+
+        def check_klist(out, warns)
+          output, success = shell_capture('klist')
+          if success && output.match?(/principal|Credentials/i)
+            out.success('Kerberos ticket valid') unless options[:json]
+            { status: :ok }
+          else
+            msg = 'No valid Kerberos ticket found. Run `kinit` before bootstrapping.'
+            warns << msg
+            out.warn(msg) unless options[:json]
+            { status: :warn, message: msg }
+          end
+        rescue StandardError => e
+          msg = "klist check failed: #{e.message}"
+          warns << msg
+          out.warn(msg) unless options[:json]
+          { status: :warn, message: msg }
+        end
+
+        def check_brew(out, warns)
+          _, success = shell_capture('brew --version')
+          if success
+            out.success('Homebrew available') unless options[:json]
+            { status: :ok }
+          else
+            msg = 'Homebrew not found. Install from https://brew.sh'
+            warns << msg
+            out.warn(msg) unless options[:json]
+            { status: :warn, message: msg }
+          end
+        rescue StandardError => e
+          msg = "brew check failed: #{e.message}"
+          warns << msg
+          out.warn(msg) unless options[:json]
+          { status: :warn, message: msg }
+        end
+
+        def check_legionio_binary(out, warns)
+          _, success = shell_capture('legionio version')
+          if success
+            out.success('legionio binary works') unless options[:json]
+            { status: :ok }
+          else
+            msg = 'legionio binary not responding. Try reinstalling: brew reinstall legionio'
+            warns << msg
+            out.warn(msg) unless options[:json]
+            { status: :warn, message: msg }
+          end
+        rescue StandardError => e
+          msg = "legionio binary check failed: #{e.message}"
+          warns << msg
+          out.warn(msg) unless options[:json]
+          { status: :warn, message: msg }
+        end
+
+        def run_scaffold(out)
+          print_step(out, 'Scaffolding missing subsystem files')
+          silent_out    = Output::Formatter.new(json: false, color: false)
+          scaffold_opts = build_scaffold_opts
+          scaffold_opts[:json] = false if options[:json]
+          ConfigScaffold.run(options[:json] ? silent_out : out, scaffold_opts)
+          :done
+        end
+
+        def install_packs_step(pack_names, out)
+          if options[:skip_packs]
+            out.warn('Skipping pack installation (--skip-packs)') unless options[:json]
+            []
+          else
+            print_step(out, "Installing packs: #{pack_names.join(', ')}") unless pack_names.empty?
+            install_packs(pack_names, out)
+          end
+        end
+
+        # -----------------------------------------------------------------------
+        # Scaffold options
+        # -----------------------------------------------------------------------
+
+        def build_scaffold_opts
+          {
+            force: options[:force],
+            json:  options[:json],
+            only:  options[:only],
+            full:  options[:full],
+            dir:   options[:dir]
+          }
+        end
+
+        # -----------------------------------------------------------------------
+        # Pack installation
+        # -----------------------------------------------------------------------
+
+        def install_packs(pack_names, out)
+          return [] if pack_names.empty?
+
+          gem_bin  = File.join(RbConfig::CONFIG['bindir'], 'gem')
+          results  = []
+
+          pack_names.each do |pack_name|
+            pack_sym = pack_name.to_sym
+            pack     = Setup::PACKS[pack_sym]
+            unless pack
+              out.warn("Unknown pack: #{pack_name} (valid: #{Setup::PACKS.keys.join(', ')})") unless options[:json]
+              next
+            end
+
+            out.header("Installing pack: #{pack_name}") unless options[:json]
+            gem_results = install_pack_gems(pack[:gems], gem_bin, out)
+            Gem::Specification.reset
+            results << { pack: pack_name, results: gem_results }
+          end
+
+          results
+        end
+
+        def install_pack_gems(gem_names, gem_bin, out)
+          already_installed = []
+          to_install        = []
+
+          gem_names.each do |name|
+            Gem::Specification.find_by_name(name)
+            already_installed << name
+          rescue Gem::MissingSpecError
+            to_install << name
+          end
+
+          gem_results = to_install.map { |g| install_single_gem(g, gem_bin, out) }
+
+          already_installed.each do |g|
+            out.success("  #{g} already installed") unless options[:json]
+          end
+
+          gem_results
+        end
+
+        def install_single_gem(name, gem_bin, out)
+          puts "  Installing #{name}..." unless options[:json]
+          output, success = shell_capture("#{gem_bin} install #{name} --no-document")
+          if success
+            out.success("  #{name} installed") unless options[:json]
+            { name: name, status: 'installed' }
+          else
+            out.error("  #{name} failed") unless options[:json]
+            { name: name, status: 'failed', error: output.strip.lines.last&.strip }
+          end
+        end
+
+        # -----------------------------------------------------------------------
+        # Summary
+        # -----------------------------------------------------------------------
+
+        def build_summary(config, results, warns)
+          settings_dir = ConfigImport::SETTINGS_DIR
+          subsystem_files = ConfigScaffold::SUBSYSTEMS.to_h do |s|
+            path = File.join(settings_dir, "#{s}.json")
+            [s, File.exist?(path)]
+          end
+
+          {
+            config_sections: config.keys.map(&:to_s),
+            packs_requested: results[:packs_requested] || [],
+            packs_installed: results[:packs_installed] || [],
+            subsystem_files: subsystem_files,
+            warnings:        warns,
+            preflight:       results[:preflight] || {}
+          }
+        end
+
+        def print_summary(out, summary)
+          return if options[:json]
+
+          out.spacer
+          out.header('Bootstrap Summary')
+          out.spacer
+
+          print_config_sections(summary)
+          print_subsystem_files(summary)
+          print_packs_summary(out, summary)
+          print_warnings_section(out, summary)
+          print_next_steps(out)
+        end
+
+        def print_config_sections(summary)
+          puts "  Config sections: #{summary[:config_sections].join(', ')}" if summary[:config_sections].any?
+        end
+
+        def print_subsystem_files(summary)
+          present = summary[:subsystem_files].select { |_, v| v }.keys
+          absent  = summary[:subsystem_files].reject { |_, v| v }.keys
+          puts "  Subsystem files present: #{present.join(', ')}" if present.any?
+          puts "  Subsystem files missing: #{absent.join(', ')}"  if absent.any?
+        end
+
+        def print_packs_summary(out, summary)
+          summary[:packs_installed].each do |pack_result|
+            successes = (pack_result[:results] || []).count { |r| r[:status] == 'installed' }
+            failures  = (pack_result[:results] || []).count { |r| r[:status] == 'failed' }
+            if failures.zero?
+              out.success("Pack #{pack_result[:pack]}: #{successes} gem(s) installed")
+            else
+              out.warn("Pack #{pack_result[:pack]}: #{successes} installed, #{failures} failed")
+            end
+          end
+          out.warn('Pack installation skipped') if options[:skip_packs]
+        end
+
+        def print_warnings_section(out, summary)
+          return unless summary[:warnings].any?
+
+          out.spacer
+          out.header('Attention')
+          summary[:warnings].each { |w| out.warn(w) }
+        end
+
+        def print_next_steps(out)
+          return if options[:start]
+
+          out.spacer
+          puts '  Next steps:'
+          puts '    brew services start redis && brew services start legionio'
+          puts '    legion'
+        end
+
+        # -----------------------------------------------------------------------
+        # Service startup (--start)
+        # -----------------------------------------------------------------------
+
+        def start_services(out)
+          redis_ok   = run_brew_service('redis', out)
+          legion_ok  = run_brew_service('legionio', out)
+          poll_daemon_ready(out) if redis_ok && legion_ok
+          { redis: redis_ok, legionio: legion_ok }
+        end
+
+        def run_brew_service(service, out)
+          output, success = shell_capture("brew services start #{service}")
+          if success
+            out.success("#{service} started") unless options[:json]
+            true
+          else
+            out.warn("#{service} failed to start: #{output.strip.lines.last&.strip}") unless options[:json]
+            false
+          end
+        rescue StandardError => e
+          out.warn("brew services start #{service} raised: #{e.message}") unless options[:json]
+          false
+        end
+
+        def poll_daemon_ready(out, port: 4567, timeout: 30)
+          require 'net/http'
+          deadline = ::Time.now + timeout
+          until ::Time.now > deadline
+            begin
+              resp = Net::HTTP.get_response(URI("http://localhost:#{port}/api/ready"))
+              if resp.is_a?(Net::HTTPSuccess)
+                out.success("Daemon ready on port #{port}") unless options[:json]
+                return true
+              end
+            rescue StandardError
+              # not ready yet — keep polling
+            end
+            sleep 1
+          end
+          out.warn("Daemon did not become ready within #{timeout}s") unless options[:json]
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -61,6 +61,7 @@ module Legion
           end
 
           parts << cognitive_awareness(directory)
+          parts << self_awareness_hint
 
           extra_dirs.each do |dir|
             expanded = File.expand_path(dir)
@@ -181,6 +182,16 @@ module Legion
           end
           nil
         end
+
+        def self.self_awareness_hint
+          return nil unless defined?(Legion::Extensions::Agentic::Self::Metacognition::Runners::Metacognition)
+
+          result = Legion::Extensions::Agentic::Self::Metacognition::Runners::Metacognition.self_narrative
+          narrative = result[:prose] if result.is_a?(Hash) && result[:prose]
+          narrative ? "\nCurrent self-awareness:\n#{narrative}" : nil
+        rescue StandardError
+          nil
+        end
       end
     end
   end

data/lib/legion/cli/codegen_command.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Legion
+  module CLI
+    class CodegenCommand < Thor
+      namespace :codegen
+
+      desc 'status', 'Show codegen cycle stats, pending gaps, registry counts'
+      def status
+        if defined?(Legion::MCP::SelfGenerate)
+          data = Legion::MCP::SelfGenerate.status
+          say Legion::JSON.dump({ data: data })
+        else
+          say Legion::JSON.dump({ error: 'codegen not available' })
+        end
+      end
+
+      desc 'list', 'List generated functions'
+      method_option :status, type: :string, desc: 'Filter by status'
+      def list
+        unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
+          say Legion::JSON.dump({ error: 'codegen registry not available' })
+          return
+        end
+
+        records = Legion::Extensions::Codegen::Helpers::GeneratedRegistry.list(status: options[:status])
+        say Legion::JSON.dump({ data: records })
+      end
+
+      desc 'show ID', 'Show details of a generated function'
+      def show(id)
+        unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
+          say Legion::JSON.dump({ error: 'codegen registry not available' })
+          return
+        end
+
+        record = Legion::Extensions::Codegen::Helpers::GeneratedRegistry.get(id: id)
+        if record
+          say Legion::JSON.dump({ data: record })
+        else
+          say Legion::JSON.dump({ error: 'not found' })
+        end
+      end
+
+      desc 'approve ID', 'Manually approve a parked generated function'
+      def approve(id)
+        unless defined?(Legion::Extensions::Codegen::Runners::ReviewHandler)
+          say Legion::JSON.dump({ error: 'review handler not available' })
+          return
+        end
+
+        result = Legion::Extensions::Codegen::Runners::ReviewHandler.handle_verdict(
+          review: { generation_id: id, verdict: :approve, confidence: 1.0 }
+        )
+        say Legion::JSON.dump({ data: result })
+      end
+
+      desc 'reject ID', 'Manually reject a generated function'
+      def reject(id)
+        unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
+          say Legion::JSON.dump({ error: 'codegen registry not available' })
+          return
+        end
+
+        Legion::Extensions::Codegen::Helpers::GeneratedRegistry.update_status(id: id, status: 'rejected')
+        say Legion::JSON.dump({ data: { id: id, status: 'rejected' } })
+      end
+
+      desc 'retry ID', 'Re-queue a generated function for regeneration'
+      def retry_generation(id)
+        unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
+          say Legion::JSON.dump({ error: 'codegen registry not available' })
+          return
+        end
+
+        Legion::Extensions::Codegen::Helpers::GeneratedRegistry.update_status(id: id, status: 'pending')
+        say Legion::JSON.dump({ data: { id: id, status: 'pending' } })
+      end
+      map 'retry' => :retry_generation
+
+      desc 'gaps', 'List detected capability gaps with priorities'
+      def gaps
+        if defined?(Legion::MCP::GapDetector)
+          detected = Legion::MCP::GapDetector.detect_gaps
+          say Legion::JSON.dump({ data: detected })
+        else
+          say Legion::JSON.dump({ error: 'gap detector not available' })
+        end
+      end
+
+      desc 'cycle', 'Manually trigger a generation cycle (bypass cooldown)'
+      def cycle
+        unless defined?(Legion::MCP::SelfGenerate)
+          say Legion::JSON.dump({ error: 'self_generate not available' })
+          return
+        end
+
+        Legion::MCP::SelfGenerate.instance_variable_set(:@last_cycle_at, nil)
+        result = Legion::MCP::SelfGenerate.run_cycle
+        say Legion::JSON.dump({ data: result })
+      end
+    end
+  end
+end

data/lib/legion/cli.rb

@@ -64,6 +64,8 @@ module Legion
     autoload :TraceCommand, 'legion/cli/trace_command'
     autoload :Features,     'legion/cli/features_command'
     autoload :Debug,        'legion/cli/debug_command'
+    autoload :CodegenCommand, 'legion/cli/codegen_command'
+    autoload :Bootstrap,      'legion/cli/bootstrap_command'
 
     module Groups
       autoload :Ai,       'legion/cli/groups/ai_group'
@@ -235,6 +237,9 @@ module Legion
       desc 'setup SUBCOMMAND', 'Install feature packs and configure IDE integrations'
       subcommand 'setup', Legion::CLI::Setup
 
+      desc 'bootstrap SOURCE', 'One-command setup: fetch config, scaffold, and install packs'
+      subcommand 'bootstrap', Legion::CLI::Bootstrap
+
       desc 'update', 'Update Legion gems to latest versions'
       subcommand 'update', Legion::CLI::Update
 
@@ -242,6 +247,9 @@ module Legion
       subcommand 'init', Legion::CLI::Init
 
       # --- Interactive & shortcuts ---
+      desc 'codegen SUBCOMMAND', 'Manage self-generating functions'
+      subcommand 'codegen', CodegenCommand
+
       desc 'tty', 'Rich terminal UI (onboarding, AI chat, dashboard)'
       subcommand 'tty', Legion::CLI::Tty
 

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

@@ -2,6 +2,7 @@
 
 require_relative 'base'
 require 'date'
+require 'securerandom'
 
 module Legion
   module Extensions
@@ -50,7 +51,7 @@ module Legion
         def prepare # rubocop:disable Metrics/AbcSize
           @queue = queue.new
           @queue.channel.prefetch(prefetch) if defined? prefetch
-          consumer_tag = "#{Legion::Settings[:client][:name]}_#{lex_name}_#{runner_name}_#{Thread.current.object_id}"
+          consumer_tag = "#{Legion::Settings[:client][:name]}_#{lex_name}_#{runner_name}_#{SecureRandom.uuid}"
           @consumer = Bunny::Consumer.new(@queue.channel, @queue, consumer_tag, false, false)
           @consumer.on_delivery do |delivery_info, metadata, payload|
             message = process_message(payload, metadata, delivery_info)
@@ -150,7 +151,7 @@ module Legion
         def subscribe # rubocop:disable Metrics/AbcSize
           log.info "[Subscription] subscribing: #{lex_name}/#{runner_name}"
           sleep(delay_start) if delay_start.positive?
-          consumer_tag = "#{Legion::Settings[:client][:name]}_#{lex_name}_#{runner_name}_#{Thread.current.object_id}"
+          consumer_tag = "#{Legion::Settings[:client][:name]}_#{lex_name}_#{runner_name}_#{SecureRandom.uuid}"
           on_cancellation = block { cancel }
 
           @consumer = @queue.subscribe(manual_ack: manual_ack, block: false, consumer_tag: consumer_tag, on_cancellation: on_cancellation) do |*rmq_message|

data/lib/legion/service.rb

@@ -126,6 +126,7 @@ module Legion
       if extensions
         load_extensions
         Legion::Readiness.mark_ready(:extensions)
+        setup_generated_functions
       end
 
       Legion::Gaia.registry&.rediscover if gaia && defined?(Legion::Gaia) && Legion::Gaia.started?
@@ -612,6 +613,15 @@ module Legion
       Legion::Extensions.hook_extensions
     end
 
+    def setup_generated_functions
+      return unless defined?(Legion::Extensions::Codegen::Helpers::GeneratedRegistry)
+
+      loaded = Legion::Extensions::Codegen::Helpers::GeneratedRegistry.load_on_boot
+      Legion::Logging.info("Loaded #{loaded} generated functions") if defined?(Legion::Logging) && loaded.to_i.positive?
+    rescue StandardError => e
+      Legion::Logging.warn("setup_generated_functions failed: #{e.message}") if defined?(Legion::Logging)
+    end
+
     def setup_mtls_rotation
       enabled = Legion::Settings[:security]&.dig(:mtls, :enabled)
       return unless enabled

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.6.8
 platform: ruby
 authors:
 - Esity
@@ -447,6 +447,7 @@ files:
 - lib/legion/api/capacity.rb
 - lib/legion/api/catalog.rb
 - lib/legion/api/chains.rb
+- lib/legion/api/codegen.rb
 - lib/legion/api/coldstart.rb
 - lib/legion/api/costs.rb
 - lib/legion/api/events.rb
@@ -511,6 +512,7 @@ files:
 - lib/legion/cli/apollo_command.rb
 - lib/legion/cli/audit_command.rb
 - lib/legion/cli/auth_command.rb
+- lib/legion/cli/bootstrap_command.rb
 - lib/legion/cli/chain.rb
 - lib/legion/cli/chain_command.rb
 - lib/legion/cli/chat/agent_delegator.rb
@@ -576,6 +578,7 @@ files:
 - lib/legion/cli/chat_command.rb
 - lib/legion/cli/check/privacy_check.rb
 - lib/legion/cli/check_command.rb
+- lib/legion/cli/codegen_command.rb
 - lib/legion/cli/cohort.rb
 - lib/legion/cli/coldstart_command.rb
 - lib/legion/cli/commit_command.rb