legionio 1.8.16 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7565dee1ffc3d39358bae7bcde3e0c3af8368ede4f8948b6f9c1c618b7a96001
-  data.tar.gz: 033d14bde74d0b753da46cc5cc45e2f600655a1be402c157b64f36284e9aa88c
+  metadata.gz: 45c36457fa18952ae68b86d8b1d230a5166bdf119338ce9c9e23791b413f822b
+  data.tar.gz: 380124a7e0321717dc18751d5de61bf83b2cd255d50efa5cf07a920c7d115f5a
 SHA512:
-  metadata.gz: b70ac4808b1322dffc0b58d169140ce3d2ea7b524658097b16fae4f9a563245e38be2116854f75decdecd58b1eda72cec9448193168110d485a9b00887ac544b
-  data.tar.gz: 6b929b04626948f04993aac61d41da43231e4c66f6a1b6e60196e69b7cf71acc45bb34cf7fb8b3c5c7bcc60ca60a1bcc5c667fbc1101b11b37aaf247a7817db9
+  metadata.gz: 4bbc31826f903cbc0753fb79ed0745b1322d0acc86009a7b88586cd7ca4f520bc5e97d81f7c777bb7ba72be89d7d894565403cc413eda5b6934eadf35161f1b3
+  data.tar.gz: b546b6d4bd2f78e5a5d87c4acc253c1d849bd59adbd45af28781f16ab56c1895c389145576bf9ddae0af14b0907e32a4ee560817c34d2b2a83d11ab1a05bb10a

data/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 ## [Unreleased]
 
+## [1.9.1] - 2026-04-25
+
+### Added
+- Extension runtime handles now expose authoritative active/latest versions, reload state, pending-reload status, hot-reload eligibility, and owned runtime resources through `/api/extension_catalog`.
+- Extension dispatch quiescing now blocks API, ingress, and subscription runner dispatch while an extension is stopping or actively reloading.
+- `Legion::Tools::Registry.unregister_extension` removes callable tools owned by an extension during unload/reload cleanup.
+
+### Fixed
+- Runtime handle `loaded?` no longer reports `stopped` or `failed` extensions as loaded.
+- Extension registration publication now happens after extension autobuild and runtime side effects complete, avoiding durable registration of failed loads.
+- Extension runtime handles now transition to loaded only after `require` and extension side effects succeed, and multi-segment extension modules keep their hyphenated lex identity.
+
+## [1.9.0] - 2026-04-24
+
+### Added
+- `Legion::Identity::Resolver` — composite identity resolution chain with parallel provider execution, DB persistence, and transport event publishing
+- `Legion::Identity::Trust` — trust level enum (verified, authenticated, configured, cached, unverified)
+- `Legion::Identity::Grant` — frozen value object for credential access auditing
+- `Identity::Process` extended with trust, aliases, providers, profile composite state
+- `Identity::Broker` upgraded to `[provider, qualifier]` tuple-keyed multi-instance storage with `for_context` routing and bounded async audit queue
+- `Resolver.upgrade!` for post-boot identity trust escalation with canonical_name change support
+- Settings client name updated from resolved identity for correct queue naming
+
+### Changed
+- `setup_identity` gate relaxed to run with DB-only nodes (not just transport)
+- `register_credential_providers` gate relaxed for DB-only nodes
+- Reload lifecycle: `Resolver.reset!` preserves providers, re-resolves with existing registrations
+- Middleware `system_principal` uses Resolver identity when available
+
+### Fixed
+- `Request.from_auth_context` canonical normalization now matches DB constraint `^[a-z0-9][a-z0-9_-]*$`
+- `/api/identity/audit` reads from `identity_audit_log` table instead of `AuditRecord`
+
+### Removed
+- Legacy tree-walk identity discovery (`resolve_identity_providers`, `find_identity_providers`, `collect_identity_providers`)
+- `identity_provider?` and `register_identity_provider` from extensions.rb
 
 ## [1.8.16] - 2026-04-22
 

data/lib/legion/api/extensions.rb

@@ -22,33 +22,21 @@ module Legion
 
         def self.register_extension_routes(app)
           app.get '/api/extension_catalog' do
-            entries = Legion::Extensions::Catalog.all.map do |name, entry|
-              { name: name, state: entry[:state].to_s,
-                registered_at: entry[:registered_at]&.iso8601,
-                started_at: entry[:started_at]&.iso8601 }
-            end
+            entries = Routes::Extensions.extension_entries
             entries = entries.select { |e| e[:state] == params[:state] } if params[:state]
             json_response(entries)
           end
 
           app.get '/api/extension_catalog/:name' do
             name = params[:name]
-            entry = Legion::Extensions::Catalog.entry(name)
+            entry = Routes::Extensions.extension_entry(name)
             halt_not_found("extension '#{name}' not found") unless entry
 
             ext_mod = find_extension_module(name)
-            version = ext_mod&.const_defined?(:VERSION) ? ext_mod::VERSION : nil
 
             runners = ext_mod ? runner_summaries(ext_mod) : []
 
-            json_response({
-              name:          name,
-              state:         entry[:state].to_s,
-              version:       version,
-              registered_at: entry[:registered_at]&.iso8601,
-              started_at:    entry[:started_at]&.iso8601,
-              runners:       runners
-            }.compact)
+            json_response(entry.merge(runners: runners).compact)
           end
         end
 
@@ -154,6 +142,52 @@ module Legion
         end
 
         class << self
+          def extension_entries
+            handles = if Legion::Extensions.respond_to?(:extension_handles)
+                        Legion::Extensions.extension_handles
+                      else
+                        []
+                      end
+            return handles.map { |handle| serialize_handle(handle) } unless handles.empty?
+
+            Legion::Extensions::Catalog.all.filter_map do |name, entry|
+              serialize_catalog_entry(name, entry)
+            end
+          end
+
+          def extension_entry(name)
+            handle = Legion::Extensions.extension_handle(name) if Legion::Extensions.respond_to?(:extension_handle)
+            return serialize_handle(handle) if handle
+
+            serialize_catalog_entry(name, Legion::Extensions::Catalog.entry(name))
+          end
+
+          def serialize_handle(handle)
+            {
+              name:                     handle.lex_name,
+              state:                    handle.state.to_s,
+              active_version:           handle.active_version&.to_s,
+              latest_installed_version: handle.latest_installed_version&.to_s,
+              reload_state:             handle.reload_state.to_s,
+              pending_reload:           handle.pending_reload?,
+              hot_reloadable:           handle.hot_reloadable,
+              loaded_at:                handle.loaded_at&.iso8601,
+              last_error:               handle.last_error,
+              routes:                   handle.routes,
+              tools:                    handle.tools,
+              absorbers:                handle.absorbers,
+              owned_runners:            handle.runners
+            }.compact
+          end
+
+          def serialize_catalog_entry(name, entry)
+            return nil unless entry
+
+            { name: name, state: entry[:state].to_s,
+              registered_at: entry[:registered_at]&.iso8601,
+              started_at: entry[:started_at]&.iso8601 }
+          end
+
           private :register_available_route, :register_extension_routes,
                   :register_runner_routes, :register_function_routes, :register_invoke_route
         end

data/lib/legion/api/identity_audit.rb

@@ -8,12 +8,23 @@ module Legion
           app.helpers IdentityAuditHelpers
 
           app.get '/api/identity/audit' do
-            halt 503, json_error('unavailable', 'audit records not available') unless defined?(Legion::Data::Model::AuditRecord)
+            require_data!
+            halt 503, json_error('unavailable', 'identity audit log not available') unless defined?(Legion::Data::Model::IdentityAuditLog)
 
-            dataset = Legion::Data::Model::AuditRecord.where(entity_type: 'identity')
+            dataset = Legion::Data::Model::IdentityAuditLog.dataset
 
             principal = params[:principal]
-            dataset = dataset.where(Sequel.lit("metadata->>'principal' = ?", principal)) if principal
+            if principal && defined?(Legion::Data::Model::Principal)
+              principal_record = Legion::Data::Model::Principal.where(canonical_name: principal).first
+              halt 404, json_error('not_found', "principal '#{principal}' not found") unless principal_record
+              dataset = dataset.where(principal_id: principal_record.id)
+            end
+
+            provider = params[:provider]
+            dataset = dataset.where(provider_name: provider) if provider
+
+            event_type = params[:event_type]
+            dataset = dataset.where(event_type: event_type) if event_type
 
             since = params[:since]
             if since
@@ -23,7 +34,9 @@ module Legion
 
             records = dataset.order(Sequel.desc(:created_at)).limit(100).all
             json_collection(records.map do |r|
-              { id: r.id, action: r.action, entity_type: r.entity_type, metadata: r.parsed_metadata, created_at: r.created_at }
+              { id: r.id, event_type: r.event_type, provider_name: r.provider_name,
+                trust_level: r.trust_level, detail: r.detail,
+                node_id: r.node_id, session_id: r.session_id, created_at: r.created_at }
             end)
           end
         end

data/lib/legion/api/stats.rb

@@ -20,21 +20,23 @@ module Legion
           end
         end
 
-        EXTENSION_IVARS = {
-          loaded:       :@loaded_extensions,
+        EXTENSION_TASK_IVARS = {
           discovered:   :@extensions,
           subscription: :@subscription_tasks,
           every:        :@timer_tasks,
           poll:         :@poll_tasks,
           once:         :@once_tasks,
           loop:         :@loop_tasks,
-          running:      :@running_instances
+          actors:       :@running_instances
         }.freeze
 
         class << self
           def collect_extensions
             ext = Legion::Extensions
-            EXTENSION_IVARS.transform_values { |ivar| ext.instance_variable_get(ivar)&.count || 0 }
+            {
+              loaded:  ext.extension_handle_registry.loaded.count,
+              running: ext.extension_handle_registry.running.count
+            }.merge(EXTENSION_TASK_IVARS.transform_values { |ivar| ext.instance_variable_get(ivar)&.count || 0 })
           rescue StandardError => e
             { error: e.message }
           end

data/lib/legion/cli.rb

@@ -267,6 +267,9 @@ module Legion
       desc 'init', 'Initialize a new Legion workspace'
       subcommand 'init', Legion::CLI::Init
 
+      desc 'detect SUBCOMMAND', 'Scan environment and recommend extensions'
+      subcommand 'detect', Legion::CLI::Detect
+
       # --- Interactive & shortcuts ---
       desc 'knowledge SUBCOMMAND', 'Search and manage the document knowledge base'
       subcommand 'knowledge', Legion::CLI::Knowledge

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

@@ -214,6 +214,11 @@ module Legion
         end
 
         def dispatch_runner(message, runner_cls, function, check_subtask, generate_task)
+          unless extension_dispatch_allowed?
+            log.warn "[Subscription] rejecting #{lex_name}/#{function}: extension is not accepting new work" if defined?(log)
+            return { success: false, status: 'task.blocked', error: { code: 'extension_quiescing' } }
+          end
+
           run_block = lambda {
             ctx = message.merge(runner_class: runner_cls.to_s, function: function.to_s)
             Legion::Context.with_task_context(ctx) do
@@ -232,6 +237,12 @@ module Legion
           end
         end
 
+        def extension_dispatch_allowed?
+          return true unless defined?(Legion::Extensions) && Legion::Extensions.respond_to?(:dispatch_allowed?)
+
+          Legion::Extensions.dispatch_allowed?(lex_name)
+        end
+
         def reject_or_retry(delivery_info, metadata, payload)
           headers = metadata&.headers || {}
           retry_count = RetryPolicy.extract_retry_count(headers)

data/lib/legion/extensions/handle.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    class Handle
+      STATES = %i[registered loaded starting running stopping stopped failed].freeze
+      LOADED_STATES = %i[loaded starting running stopping].freeze
+      DISPATCHABLE_STATES = %i[loaded starting running].freeze
+      RELOAD_STATES = %i[idle pending updating rolling_back failed].freeze
+      DISPATCH_BLOCKING_RELOAD_STATES = %i[updating rolling_back].freeze
+
+      attr_reader :lex_name, :gem_name, :active_version, :state, :reload_state, :hot_reloadable,
+                  :latest_installed_version, :spec, :gem_dir, :loaded_features, :actors, :routes, :tools, :absorbers,
+                  :runners, :loaded_at, :last_error
+
+      def initialize(**attrs)
+        lex_name = attrs.fetch(:lex_name)
+        spec = attrs[:spec]
+        @lex_name = lex_name.to_s
+        @gem_name = (attrs[:gem_name] || lex_name).to_s
+        @spec = spec
+        @active_version = normalize_version(attrs[:active_version] || spec&.version)
+        @latest_installed_version = normalize_version(attrs[:latest_installed_version] || attrs[:installed_version] || @active_version)
+        @state = normalize_state(attrs.fetch(:state, :registered))
+        @reload_state = normalize_reload_state(attrs.fetch(:reload_state, :idle))
+        @hot_reloadable = attrs[:hot_reloadable] == true
+        @gem_dir = attrs[:gem_dir] || spec&.gem_dir
+        @loaded_features = Array(attrs.fetch(:loaded_features, [])).dup.freeze
+        @actors = Array(attrs.fetch(:actors, [])).dup.freeze
+        @routes = Array(attrs.fetch(:routes, [])).dup.freeze
+        @tools = Array(attrs.fetch(:tools, [])).dup.freeze
+        @absorbers = Array(attrs.fetch(:absorbers, [])).dup.freeze
+        @runners = Array(attrs.fetch(:runners, [])).dup.freeze
+        @loaded_at = attrs.fetch(:loaded_at, Time.now)
+        @last_error = attrs[:last_error]
+      end
+
+      def loaded?
+        LOADED_STATES.include?(state)
+      end
+
+      def running?
+        state == :running
+      end
+
+      def pending_reload?
+        return false if active_version.nil? || latest_installed_version.nil?
+
+        latest_installed_version > active_version
+      end
+
+      def dispatchable?
+        DISPATCHABLE_STATES.include?(state) && !DISPATCH_BLOCKING_RELOAD_STATES.include?(reload_state)
+      end
+
+      def with(**attrs)
+        self.class.new(**to_h, **attrs)
+      end
+
+      def to_h
+        {
+          lex_name:                 lex_name,
+          gem_name:                 gem_name,
+          active_version:           active_version,
+          latest_installed_version: latest_installed_version,
+          state:                    state,
+          reload_state:             reload_state,
+          hot_reloadable:           hot_reloadable,
+          spec:                     spec,
+          gem_dir:                  gem_dir,
+          loaded_features:          loaded_features,
+          actors:                   actors,
+          routes:                   routes,
+          tools:                    tools,
+          absorbers:                absorbers,
+          runners:                  runners,
+          loaded_at:                loaded_at,
+          last_error:               last_error
+        }
+      end
+
+      private
+
+      def normalize_version(value)
+        return nil if value.nil?
+        return value if value.is_a?(Gem::Version)
+
+        Gem::Version.new(value.to_s)
+      end
+
+      def normalize_state(value)
+        normalized = value.to_sym
+        return normalized if STATES.include?(normalized)
+
+        raise ArgumentError, "unknown extension state: #{value.inspect}"
+      end
+
+      def normalize_reload_state(value)
+        normalized = value.to_sym
+        return normalized if RELOAD_STATES.include?(normalized)
+
+        raise ArgumentError, "unknown extension reload state: #{value.inspect}"
+      end
+    end
+  end
+end

data/lib/legion/extensions/handle_registry.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/handle'
+
+module Legion
+  module Extensions
+    class HandleRegistry
+      def initialize
+        @handles = {}
+        @mutex = Mutex.new
+      end
+
+      def register(lex_name, **attrs)
+        key = normalize_name(lex_name)
+        @mutex.synchronize do
+          current = @handles[key]
+          @handles[key] = current ? current.with(**attrs) : Handle.new(lex_name: key, **attrs)
+        end
+      end
+
+      def transition(lex_name, state)
+        update(lex_name, state: state)
+      end
+
+      def update(lex_name, **attrs)
+        key = normalize_name(lex_name)
+        @mutex.synchronize do
+          current = @handles[key] || Handle.new(lex_name: key)
+          @handles[key] = current.with(**attrs)
+        end
+      end
+
+      def fetch(lex_name)
+        @mutex.synchronize { @handles[normalize_name(lex_name)] }
+      end
+
+      def all
+        @mutex.synchronize { @handles.values.dup }
+      end
+
+      def running
+        all.select(&:running?)
+      end
+
+      def loaded
+        all.select(&:loaded?)
+      end
+
+      def dispatch_allowed?(lex_name)
+        handle = fetch(lex_name)
+        return true unless handle
+
+        handle.dispatchable?
+      end
+
+      def delete(lex_name)
+        @mutex.synchronize { @handles.delete(normalize_name(lex_name)) }
+      end
+
+      def reset!
+        @mutex.synchronize { @handles.clear }
+      end
+
+      private
+
+      def normalize_name(lex_name)
+        lex_name.to_s
+      end
+    end
+  end
+end