legionio 1.6.2 → 1.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49e219b9a9c790b6ec63903daee3a26194a5a1611cccd0013a05bb7a34a3d7c9
-  data.tar.gz: eedbb6e81c2ba386cee0718eb3aed307a021d25959579bb2a02c8bd011ca4fa5
+  metadata.gz: e025887526f8b9e258eb168a14a83d5c34e60668eadbe9e1ccd5c995e27d725c
+  data.tar.gz: a85e52dc5ec39293461e7df402f2ea8f1a410d293c28141fc935cfb6023b71df
 SHA512:
-  metadata.gz: 141f1ad15ae3595a411e4e1ddaf7fa4544bd1fd5aa23be7425574e783a55581773d0a860ace1d7f6dce97bf3004b6fc42998374cdfe8b3555b01547e98be5f1e
-  data.tar.gz: a05b2f2cb76d9237dc785b396af6f72b03657866ba4f57fd9b7673594d3212634e9c920d90529c5134544cbdb8d32e9994b188e155366f6f69f7df803355dc90
+  metadata.gz: 6ecefca3ab028b370f8e590cf4fa81290e3a9e106f53a5655d11928f40ec99a0d48451ab94c9516086fd81bd5c42d4523eae4d975b9df667d8db7010656884c6
+  data.tar.gz: c5f4aa31b5431e6fb012991fe0048ac75c0d25d95e6402983590d7954491ad53e78b18d2911cb7969427cd60e63a47975d7ca89ff7642857cd857328dec559e3

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Legion Changelog
 
+## [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.6] - 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` flag to skip gem pack installation (config-only mode)
+- `--start` flag to start redis + legionio via brew services after bootstrap
+- `--force` flag to overwrite existing config files during bootstrap
+- `--json` flag for machine-readable bootstrap output
+- `shell_capture` helper extracted to make shell invocations stubbable in specs
+- 62 specs covering preflight checks, pack extraction, config fetch/write delegation, pack install, summary output, all flags, and error handling
+
+## [1.6.5] - 2026-03-26
+
+### Added
+- `Context.to_system_prompt` appends a live self-awareness section from `lex-agentic-self` Metacognition when the gem is loaded; logic extracted into `self_awareness_hint` helper to keep `to_system_prompt` within Metrics/CyclomaticComplexity limits; guarded with `defined?()` and `rescue StandardError`
+
+## [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
+- `legionio update` now uses `gem outdated` instead of custom HTTP client to check rubygems.org
+- Remove `concurrent-ruby`, `net/http`, `json` dependencies from update command
+- 4 persistent keep-alive connections replaced by single `gem outdated` call (~8s, 100% reliable)
+
 ## [1.6.2] - 2026-03-26
 
 ### Fixed
@@ -17,6 +52,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/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/update_command.rb

@@ -3,9 +3,6 @@
 require 'English'
 require 'thor'
 require 'rbconfig'
-require 'concurrent'
-require 'net/http'
-require 'json'
 require 'rubygems/uninstaller'
 
 module Legion
@@ -81,83 +78,60 @@ module Legion
 
         def update_gems(gem_names, gem_bin, dry_run: false)
           local_versions = snapshot_versions(gem_names)
-          remote_versions = fetch_remote_versions_parallel(gem_names)
+          outdated_map = fetch_outdated(gem_bin, gem_names)
 
-          outdated = gem_names.select do |name|
-            remote = remote_versions[name]
-            local = local_versions[name]
-            remote && local && Gem::Version.new(remote) > Gem::Version.new(local)
+          results = gem_names.map do |name|
+            info = outdated_map[name]
+            if info
+              { name: name, from: local_versions[name], to: info[:remote], status: dry_run ? 'available' : 'pending' }
+            else
+              { name: name, from: local_versions[name], status: 'current' }
+            end
           end
 
-          return dry_run_results(gem_names, local_versions, remote_versions, outdated) if dry_run
+          return results if dry_run
 
-          return current_results(gem_names, remote_versions) if outdated.empty?
+          pending = results.select { |r| r[:status] == 'pending' }
+          return results.each { |r| r[:status] = 'current' if r[:status] == 'pending' } if pending.empty?
 
-          install_results(gem_names, gem_bin, remote_versions, outdated)
+          install_outdated(gem_bin, pending, results)
         end
 
-        def dry_run_results(gem_names, local_versions, remote_versions, outdated)
-          gem_names.map do |name|
-            remote = remote_versions[name]
-            status = if outdated.include?(name) then 'available'
-                     elsif remote then 'current'
-                     else 'check_failed'
-                     end
-            { name: name, from: local_versions[name], to: remote, status: status }
-          end
-        end
+        def fetch_outdated(gem_bin, gem_names)
+          output = `#{gem_bin} outdated 2>&1`
+          return {} unless $CHILD_STATUS.success?
 
-        def current_results(gem_names, remote_versions)
-          gem_names.map do |name|
-            { name: name, status: remote_versions[name] ? 'current' : 'check_failed', remote: remote_versions[name] }
-          end
+          parse_outdated(output, gem_names)
         end
 
-        def install_results(gem_names, gem_bin, remote_versions, outdated)
-          output = `#{gem_bin} install #{outdated.join(' ')} --no-document 2>&1`
-          success = $CHILD_STATUS.success?
-          gem_names.map do |name|
-            if outdated.include?(name)
-              { name: name, status: success ? 'installed' : 'failed', remote: remote_versions[name], output: output.strip }
-            else
-              { name: name, status: remote_versions[name] ? 'current' : 'check_failed', remote: remote_versions[name] }
-            end
-          end
-        end
+        def parse_outdated(output, gem_names)
+          allowed = gem_names.to_set
+          output.each_line.with_object({}) do |line, map|
+            match = line.match(/^(\S+) \((\S+) < (\S+)\)/)
+            next unless match && allowed.include?(match[1])
 
-        def fetch_remote_versions_parallel(gem_names)
-          results = Concurrent::Hash.new
-          thread_count = [gem_names.size, 4].min
-          slices = gem_names.each_slice((gem_names.size / thread_count.to_f).ceil).to_a
-          threads = slices.map do |batch|
-            Thread.new(batch) do |names|
-              fetch_batch(names, results)
-            end
+            map[match[1]] = { local: match[2], remote: match[3] }
           end
-          threads.each { |t| t.join(60) }
-          results
         end
 
-        def fetch_batch(names, results)
-          Net::HTTP.start('rubygems.org', 443, use_ssl: true, open_timeout: 10, read_timeout: 10) do |http|
-            names.each do |name|
-              response = http.request(Net::HTTP::Get.new("/api/v1/versions/#{name}/latest.json"))
-              next unless response.is_a?(Net::HTTPSuccess)
-
-              data = ::JSON.parse(response.body)
-              results[name] = data['version'] if data['version']
-            rescue StandardError => e
-              Legion::Logging.debug("UpdateCommand#fetch_batch #{name}: #{e.message}") if defined?(Legion::Logging)
-            end
+        def install_outdated(gem_bin, pending, results)
+          names = pending.map { |r| r[:name] }
+          `#{gem_bin} install #{names.join(' ')} --no-document 2>&1`
+          success = $CHILD_STATUS.success?
+          pending_set = names.to_set
+          results.each do |r|
+            r[:status] = if pending_set.include?(r[:name])
+                           success ? 'installed' : 'failed'
+                         else
+                           'current'
+                         end
           end
-        rescue StandardError => e
-          Legion::Logging.debug("UpdateCommand#fetch_batch connection: #{e.message}") if defined?(Legion::Logging)
+          results
         end
 
         def display_results(out, results, before, after)
           updated = []
           failed = []
-          check_failures = 0
 
           results.each do |r|
             name = r[:name]
@@ -166,11 +140,7 @@ module Legion
               puts "  #{name}: #{r[:from]} -> #{r[:to]}"
               updated << name
             when 'current'
-              local = r[:from] || before[name]
-              puts "  #{name}: #{local || '?'} (already latest)"
-            when 'check_failed'
-              puts "  #{name}: #{before[name]} (remote check failed)"
-              check_failures += 1
+              puts "  #{name}: #{r[:from] || before[name] || '?'} (already latest)"
             when 'installed'
               old_v = before[name]
               new_v = after[name]
@@ -190,8 +160,6 @@ module Legion
           out.spacer
           if updated.any?
             out.success("Updated #{updated.size} gem(s)")
-          elsif check_failures.positive?
-            puts "#{check_failures} gem(s) could not be checked - retry or use --dry-run for details"
           else
             puts 'All gems are up to date'
           end

data/lib/legion/cli.rb

@@ -64,6 +64,7 @@ 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'
 
     module Groups
       autoload :Ai,       'legion/cli/groups/ai_group'
@@ -242,6 +243,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.2'
+  VERSION = '1.6.7'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.6.7
 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
@@ -576,6 +577,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