legionio 1.7.8 → 1.7.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6741515579e2c24f64b301136e023fb6ddd73b27f41779caace7df02cd15f667
-  data.tar.gz: c90f66af48bd6705b58c6c31344dd0a9486b8519cc48b98f3b1965d2571527db
+  metadata.gz: 60c67de284b066264f07c3ad829b8d193b66d85ae900af468dd7a13165695da8
+  data.tar.gz: 8fd7ab97436343722619c6c77e0aaff9b6f664609db1b81a0daff97c6692f419
 SHA512:
-  metadata.gz: 5409680125318327c866c9f59dde8ce2b7b5a33cea5082bf2d654c763184c25e4658a24ef43d4b292f12546b314692da1b5d71ca6e25ca55e6095ea376d66d5f
-  data.tar.gz: 68a9358035224f600dfc673272d2cc82ecdfc7236a7225a2974721ad61b081571dbb190c77d25c8442bc3ff13c7cea44274b8331fd2942213a714167c56017c4
+  metadata.gz: 2fde83c468f409a35fc9e02d1dc39d969a0229d32c8b592162789683f21afa31df90763792a1c4c74cb74f13ef21f1288e125d78b2b68ac2f9d724a08eee1e77
+  data.tar.gz: d10be584f4e30e1f164545c5c6e72f2e3cfa627e19675021edaf18ee6224d3f66d92ce50fcaf44b40caf0e47515e61d137e921f3903e5cab34254245fcd84bfa

data/.rubocop.yml

@@ -5,6 +5,8 @@ AllCops:
 
 Layout/LineLength:
   Max: 160
+  Exclude:
+    - 'Gemfile'
 
 Layout/SpaceAroundEqualsInParameterDefault:
   EnforcedStyle: space
@@ -65,7 +67,7 @@ Metrics/BlockLength:
     - 'lib/legion/cli/mode_command.rb'
 
 Metrics/AbcSize:
-  Max: 60
+  Max: 62
   Exclude:
     - 'lib/legion/cli/chat_command.rb'
     - 'lib/legion/api/llm.rb'

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [1.7.12] - 2026-04-03
+
+### Fixed
+- Fixes #110: normal daemon boot now prefers library-owned LLM and Apollo API routes, `/api/tenants` uses canonical JSON parsing with correct status codes, SSE listeners drain worker threads on disconnect, paginated collections avoid unconditional `COUNT(*)` unless explicitly requested, and service startup skips duplicate settings loads once configuration is already bootstrapped
+
+## [1.7.11] - 2026-04-02
+
+### Fixed
+- Fixes #113: webhook deliveries now retry non-2xx responses and transport exceptions up to `max_retries`, record per-attempt delivery rows, dead-letter terminal failures, and cache active webhook pattern matching to reduce per-event dispatch overhead
+
+## [1.7.10] - 2026-04-02
+
+### Changed
+- Bumped minimum dependency floors for Legion core gems, including `legion-logging >= 1.5.0`, `legion-settings >= 1.3.25`, and updated transport, data, cache, crypt, Apollo, and MCP minimums
+- Stabilized the `LegionIO` spec suite by fixing the OAuth callback, catalog, and service shutdown regression specs
+- CLI startup now honors settings-driven log levels, normalizes `start --help` into the standard Thor help flow, and routes chat/error logging through the newer helper-backed logger path
+- `Legion::Service`, telemetry, and webhook runtime paths now use structured helper logging more consistently, respect configured logging when no CLI override is passed, and avoid brittle settings reads during boot
+- Extension runtime wiring now deep-dups merged settings, lazily registers the local `extension_catalog` migration, publishes catalog transitions directly to transport, and surfaces auto-binding failures more clearly
+- Secret, region, and task-outcome helpers now use canonical Vault connectivity checks, cache metadata misses more safely, and create meta-learning domains on demand before recording learning episodes
+
 ## [1.7.8] - 2026-04-01
 
 ### Added

data/legionio.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = %w[legion legionio]
 
-  spec.add_dependency 'legion-mcp', '>= 0.5.1'
+  spec.add_dependency 'legion-mcp', '>= 0.7.1'
 
   spec.add_dependency 'kramdown', '>= 2.0'
 
@@ -52,15 +52,15 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'thor', '>= 1.3'
   spec.add_dependency 'tty-spinner', '~> 0.9'
 
-  spec.add_dependency 'legion-cache', '>= 1.3.16'
-  spec.add_dependency 'legion-crypt', '>= 1.4.17'
-  spec.add_dependency 'legion-data', '>= 1.6.7'
+  spec.add_dependency 'legion-cache', '>= 1.3.21'
+  spec.add_dependency 'legion-crypt', '>= 1.5.0'
+  spec.add_dependency 'legion-data', '>= 1.6.19'
   spec.add_dependency 'legion-json', '>= 1.2.1'
-  spec.add_dependency 'legion-logging', '>= 1.4.0'
-  spec.add_dependency 'legion-settings', '>= 1.3.19'
-  spec.add_dependency 'legion-transport', '>= 1.4.4'
+  spec.add_dependency 'legion-logging', '>= 1.5.0'
+  spec.add_dependency 'legion-settings', '>= 1.3.25'
+  spec.add_dependency 'legion-transport', '>= 1.4.13'
 
-  spec.add_dependency 'legion-apollo', '>= 0.3.1'
+  spec.add_dependency 'legion-apollo', '>= 0.4.0'
   spec.add_dependency 'legion-gaia', '>= 0.9.26'
   spec.add_dependency 'legion-llm', '>= 0.5.8'
   spec.add_dependency 'legion-tty', '>= 0.4.35'

data/lib/legion/api/audit.rb

@@ -4,7 +4,7 @@ module Legion
   class API < Sinatra::Base
     module Routes
       module Audit
-        def self.registered(app) # rubocop:disable Metrics/AbcSize
+        def self.registered(app)
           app.get '/api/audit' do
             require_data!
             dataset = Legion::Data::Model::AuditLog.order(Sequel.desc(:id))

data/lib/legion/api/events.rb

@@ -5,6 +5,7 @@ module Legion
     module Routes
       module Events
         BUFFER_SIZE = 100
+        SSE_STOP = Object.new.freeze
 
         class << self
           def event_buffer
@@ -38,6 +39,42 @@ module Legion
             @listener_installed = true
           end
 
+          def write_sse_event(out, event)
+            payload = event.transform_keys(&:to_s)
+            out << "event: #{payload['event']}\ndata: #{Legion::JSON.dump(payload)}\n\n"
+          end
+
+          def stop_queue_stream(queue:, worker:, listener:)
+            Legion::Events.off('*', listener) if defined?(Legion::Events)
+            return unless worker&.alive?
+
+            queue.push(SSE_STOP)
+            worker.join(0.1)
+          rescue ThreadError, IOError, Errno::EPIPE => e
+            Legion::Logging.debug("Events SSE cleanup failed: #{e.message}") if defined?(Legion::Logging)
+          end
+
+          def stream_queue(out:, queue:, listener:)
+            worker = Thread.new do
+              loop do
+                event = queue.pop
+                break if event.equal?(SSE_STOP)
+
+                write_sse_event(out, event)
+              rescue IOError, Errno::EPIPE => e
+                Legion::Logging.debug("Events SSE stream broken for #{event[:event]}: #{e.message}") if defined?(Legion::Logging)
+                break
+              end
+            ensure
+              Legion::Events.off('*', listener) if defined?(Legion::Events)
+            end
+
+            cleanup = proc { stop_queue_stream(queue: queue, worker: worker, listener: listener) }
+            out.callback(&cleanup)
+            out.errback(&cleanup)
+            worker
+          end
+
           def registered(app)
             install_listener if defined?(Legion::Events)
 
@@ -53,21 +90,7 @@ module Legion
               end
 
               stream do |out|
-                Thread.new do
-                  loop do
-                    event = queue.pop
-                    data = Legion::JSON.dump(event.transform_keys(&:to_s))
-                    out << "event: #{event[:event]}\ndata: #{data}\n\n"
-                  rescue IOError, Errno::EPIPE => e
-                    Legion::Logging.debug "Events SSE stream broken for #{event[:event]}: #{e.message}" if defined?(Legion::Logging)
-                    break
-                  end
-                ensure
-                  Legion::Events.off('*', listener)
-                end
-
-                out.callback { Legion::Events.off('*', listener) }
-                out.errback { Legion::Events.off('*', listener) }
+                stream_queue(out: out, queue: queue, listener: listener)
               end
             end
 

data/lib/legion/api/helpers.rb

@@ -16,17 +16,20 @@ module Legion
         content_type :json
         status status_code
 
-        total = dataset.respond_to?(:count) ? dataset.count : dataset.length
         paginated = paginate(dataset)
-        items = paginated.respond_to?(:all) ? paginated.all : paginated
+        items = paginated.respond_to?(:all) ? paginated.all : Array(paginated)
+        total = collection_total(dataset, items)
+        meta = response_meta.merge(
+          count:  items.length,
+          limit:  page_limit,
+          offset: page_offset
+        )
+        meta[:total] = total unless total.nil?
+        meta[:has_more] = collection_has_more?(items, total)
 
         Legion::JSON.dump({
                             data: items.map { |r| r.respond_to?(:values) ? r.values : r },
-                            meta: response_meta.merge(
-                              total:  total,
-                              limit:  page_limit,
-                              offset: page_offset
-                            )
+                            meta: meta
                           })
       end
 
@@ -198,6 +201,25 @@ module Legion
           dataset
         end
       end
+
+      def include_total_count?
+        params[:include_total].to_s == 'true'
+      end
+
+      def collection_total(dataset, items)
+        return dataset.count if include_total_count? && dataset.respond_to?(:count)
+        return dataset.length if dataset.respond_to?(:length) && !dataset.respond_to?(:limit)
+
+        return page_offset + items.length if items.length < page_limit
+
+        nil
+      end
+
+      def collection_has_more?(items, total)
+        return (page_offset + items.length) < total if total
+
+        items.length == page_limit
+      end
     end
   end
 end

data/lib/legion/api/library_routes.rb

@@ -11,6 +11,9 @@ module Legion
     # @param gem_name [String] short name for the library (e.g. 'llm', 'apollo')
     # @param routes_module [Module] a Sinatra::Extension module to register
     def self.register_library_routes(gem_name, routes_module)
+      existing = router.library_routes[gem_name.to_s]
+      return routes_module if existing == routes_module
+
       router.register_library(gem_name, routes_module)
       register routes_module
     end

data/lib/legion/api/tenants.rb

@@ -13,14 +13,13 @@ module Legion
           end
 
           app.post '/api/tenants' do
-            params = parsed_body
+            body = parse_request_body
             result = Legion::Tenants.create(
-              tenant_id:   params['tenant_id'],
-              name:        params['name'],
-              max_workers: params['max_workers'] || 10
+              tenant_id:   body[:tenant_id],
+              name:        body[:name],
+              max_workers: body[:max_workers] || 10
             )
-            status result[:error] ? 409 : 201
-            json_response(data: result)
+            json_response(result, status_code: result[:error] ? 409 : 201)
           end
 
           app.get '/api/tenants/:tenant_id' do

data/lib/legion/api/workers.rb

@@ -167,20 +167,7 @@ module Legion
               end
 
               stream do |out|
-                Thread.new do
-                  loop do
-                    event = queue.pop
-                    data = Legion::JSON.dump({ **event.transform_keys(&:to_s) })
-                    out << "event: #{event[:event]}\ndata: #{data}\n\n"
-                  rescue IOError, Errno::EPIPE
-                    break
-                  end
-                ensure
-                  Legion::Events.off('*', listener)
-                end
-
-                out.callback { Legion::Events.off('*', listener) }
-                out.errback { Legion::Events.off('*', listener) }
+                Routes::Events.stream_queue(out: out, queue: queue, listener: listener)
               end
             else
               count = (params[:count] || 25).to_i

data/lib/legion/api.rb

@@ -149,6 +149,25 @@ module Legion
       def router
         @router ||= Legion::API::Router.new
       end
+
+      def mount_library_routes(gem_name, fallback_module, preferred_constant_path)
+        preferred = constant_from_path(preferred_constant_path)
+        if preferred.is_a?(Module)
+          register_library_routes(gem_name, preferred)
+        elsif router.library_names.include?(gem_name)
+          register_library_routes(gem_name, router.library_routes.fetch(gem_name))
+        else
+          register fallback_module
+        end
+      end
+
+      private
+
+      def constant_from_path(path)
+        path.to_s.split('::').reject(&:empty?).reduce(Object) { |scope, name| scope.const_get(name) }
+      rescue NameError
+        nil
+      end
     end
 
     # Mount route modules
@@ -175,14 +194,14 @@ module Legion
     register Routes::Capacity
     register Routes::Audit
     register Routes::Metrics
-    register Routes::Llm unless router.library_names.include?('llm')
+    mount_library_routes('llm', Routes::Llm, 'Legion::LLM::Routes')
     register Routes::ExtensionCatalog
     register Routes::OrgChart
     register Routes::Governance
     register Routes::Acp
     register Routes::Prompts
     register Routes::Marketplace
-    register Routes::Apollo unless router.library_names.include?('apollo')
+    mount_library_routes('apollo', Routes::Apollo, 'Legion::Apollo::Routes')
     register Routes::Costs
     register Routes::Traces
     register Routes::Stats

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

@@ -8,8 +8,14 @@ module Legion
   module CLI
     class Chat
       module ChatLogger
-        LOG_DIR  = File.expand_path('~/.legion')
+        LOG_DIR = File.expand_path('~/.legion')
         LOG_FILE = File.join(LOG_DIR, 'legion-chat.log')
+        LEVELS = {
+          'debug' => ::Logger::DEBUG,
+          'info'  => ::Logger::INFO,
+          'warn'  => ::Logger::WARN,
+          'error' => ::Logger::ERROR
+        }.freeze
 
         class << self
           attr_reader :logger
@@ -22,20 +28,21 @@ module Legion
             @logger
           end
 
-          def debug(msg)  = logger&.debug(msg)
-          def info(msg)   = logger&.info(msg)
-          def warn(msg)   = logger&.warn(msg)
-          def error(msg)  = logger&.error(msg)
+          def debug(msg) = logger&.debug(msg)
+
+          def info(msg) = logger&.info(msg)
+
+          def warn(msg) = logger&.warn(msg)
+
+          def error(msg) = logger&.error(msg)
 
           private
 
-          def parse_level(level)
-            case level.to_s
-            when 'debug' then ::Logger::DEBUG
-            when 'warn'  then ::Logger::WARN
-            when 'error' then ::Logger::ERROR
-            else ::Logger::INFO
-            end
+          def parse_level(level = 'info')
+            normalized_level = level.to_s.strip.downcase
+            return ::Logger::INFO if normalized_level.empty?
+
+            LEVELS.fetch(normalized_level, ::Logger::INFO)
           end
 
           def format_entry(severity, datetime, _progname, msg)

data/lib/legion/cli/config_command.rb

@@ -101,7 +101,7 @@ module Legion
       end
 
       desc 'validate', 'Validate current configuration'
-      def validate # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      def validate # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         out = formatter
         Connection.config_dir = options[:config_dir] if options[:config_dir]
 

data/lib/legion/cli/error_handler.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require 'legion/logging'
+
 module Legion
   module CLI
     module ErrorHandler
+      extend Legion::Logging::Helper
+
       PATTERNS = [
         {
           match:       /connection refused.*5672|ECONNREFUSED.*5672|bunny.*not connected/i,
@@ -71,11 +75,13 @@ module Legion
       def wrap(error)
         pattern = PATTERNS.find { |p| error.message.match?(p[:match]) }
         unless pattern
-          Legion::Logging.error("[CLI] unhandled error: #{error.class} — #{error.message}") if logging_available?
+          handle_exception(error, level: :error, handled: true, operation: :wrap_cli_error, matched: false) if logging_available?
+          log.error("[CLI] unhandled error: #{error.class} - #{error.message}") if logging_available?
           return error
         end
 
-        Legion::Logging.warn("[CLI] matched error pattern :#{pattern[:code]} — #{error.message}") if logging_available?
+        handle_exception(error, level: :warn, handled: true, operation: :wrap_cli_error, code: pattern[:code]) if logging_available?
+        log.warn("[CLI] matched error pattern :#{pattern[:code]} - #{error.message}") if logging_available?
         Error.actionable(
           code:        pattern[:code],
           message:     "#{pattern[:message]}: #{error.message}",

data/lib/legion/cli/start.rb

@@ -10,7 +10,7 @@ module Legion
             ENV['LEGION_LOCAL'] = 'true'
           end
 
-          log_level = options[:log_level] || 'info'
+          log_level = options[:log_level]
 
           # Load settings early, before any legion-* gem requires can trigger auto-load.
           # This ensures DNS bootstrap and config file loading happen exactly once.
@@ -26,7 +26,8 @@ module Legion
           clear_log_file unless options[:daemonize]
 
           api = options.fetch(:api, true)
-          service_opts = { log_level: log_level, api: api }
+          service_opts = { api: api }
+          service_opts[:log_level] = log_level if log_level
           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))

data/lib/legion/cli.rb

@@ -90,7 +90,7 @@ module Legion
       end
 
       def self.start(given_args = ARGV, config = {})
-        super
+        super(normalize_help_args(given_args), config)
       rescue Legion::CLI::Error => e
         Legion::Logging.error("CLI::Main.start CLI error: #{e.message}") if defined?(Legion::Logging)
         formatter = Output::Formatter.new(json: given_args.include?('--json'), color: !given_args.include?('--no-color'))
@@ -106,6 +106,17 @@ module Legion
         exit(1)
       end
 
+      def self.normalize_help_args(given_args)
+        args = Array(given_args).dup
+        return args unless args.length == 2
+        return args unless %w[--help -h].include?(args.last)
+
+        command = args.first
+        return args if command.start_with?('-') || command == 'help'
+
+        ['help', command]
+      end
+
       LEGION_GEMS = %w[
         legion-transport legion-cache legion-crypt legion-data
         legion-json legion-logging legion-settings
@@ -163,7 +174,7 @@ module Legion
       option :pidfile, type: :string, aliases: ['-p'], desc: 'PID file path'
       option :logfile, type: :string, aliases: ['-l'], desc: 'Log file path'
       option :time_limit, type: :numeric, aliases: ['-t'], desc: 'Run for N seconds then exit'
-      option :log_level, type: :string, default: 'info', desc: 'Log level (debug, info, warn, error)'
+      option :log_level, type: :string, 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)'

data/lib/legion/extensions/catalog.rb

@@ -56,6 +56,9 @@ module Legion
 
         def reset!
           @entries = {}
+          @extension_catalog_available = nil
+          @extension_catalog_connection_id = nil
+          @warned_missing_extension_catalog = false
         end
 
         private
@@ -69,13 +72,17 @@ module Legion
                         Legion::Transport::Connection.respond_to?(:session_open?) &&
                         Legion::Transport::Connection.session_open?
 
-          Legion::Transport::Messages::Dynamic.new(
-            function:    'catalog_transition',
-            routing_key: "legion.catalog.#{lex_name}.#{new_state}",
-            args:        { lex_name: lex_name, state: new_state.to_s, timestamp: Time.now.to_i }
-          ).publish
+          payload = Legion::JSON.dump(
+            lex_name:  lex_name,
+            state:     new_state.to_s,
+            timestamp: Time.now.to_i
+          )
+
+          exchange = Legion::Transport::Exchange.new('legion.catalog')
+          exchange.publish(payload, routing_key: "legion.catalog.#{lex_name}.#{new_state}",
+                                    content_type: 'application/json', persistent: true)
         rescue StandardError => e
-          Legion::Logging.debug { "Catalog publish failed: #{e.message}" } if defined?(Legion::Logging)
+          Legion::Logging.warn { "Catalog publish failed for #{lex_name}=#{new_state}: #{e.class}: #{e.message}" } if defined?(Legion::Logging)
         end
 
         def persist_transition(lex_name, new_state)
@@ -83,6 +90,9 @@ module Legion
                         Legion::Data::Local.respond_to?(:connected?) &&
                         Legion::Data::Local.connected?
 
+          ensure_local_migration_registered!
+          return warn_missing_extension_catalog_once unless extension_catalog_table_available?
+
           model = Legion::Data::Local.model(:extension_catalog)
           existing = model.where(lex_name: lex_name).first
           if existing
@@ -91,14 +101,70 @@ module Legion
             model.insert(lex_name: lex_name, state: new_state.to_s, created_at: Time.now, updated_at: Time.now)
           end
         rescue StandardError => e
-          Legion::Logging.debug { "Catalog persist failed: #{e.message}" } if defined?(Legion::Logging)
+          Legion::Logging.warn { "Catalog persist failed for #{lex_name}=#{new_state}: #{e.class}: #{e.message}" } if defined?(Legion::Logging)
+        end
+
+        def extension_catalog_table_available?
+          connection = Legion::Data::Local.connection
+          return false unless connection
+
+          connection_id = connection.object_id
+          return true if @extension_catalog_connection_id == connection_id && @extension_catalog_available == true
+
+          available =
+            if connection.respond_to?(:tables)
+              connection.tables.include?(:extension_catalog)
+            else
+              connection.respond_to?(:table_exists?) && connection.table_exists?(:extension_catalog)
+            end
+
+          if available
+            @extension_catalog_connection_id = connection_id
+            @extension_catalog_available = true
+          else
+            @extension_catalog_connection_id = nil if @extension_catalog_connection_id == connection_id
+            @extension_catalog_available = nil
+          end
+
+          available
+        rescue StandardError => e
+          Legion::Logging.warn { "Catalog table availability check failed: #{e.class}: #{e.message}" } if defined?(Legion::Logging)
+          false
         end
-      end
 
-      if defined?(Legion::Data::Local)
-        migrations_path = File.expand_path('../../data/local_migrations', __dir__)
-        Legion::Data::Local.register_migrations(name: :extension_catalog, path: migrations_path) if Dir.exist?(migrations_path)
+        def ensure_local_migration_registered!
+          return unless defined?(Legion::Data::Local) &&
+                        Legion::Data::Local.respond_to?(:register_migrations)
+
+          path = extension_catalog_migrations_path
+          return unless Dir.exist?(path)
+
+          registered = if Legion::Data::Local.respond_to?(:registered_migrations)
+                         Legion::Data::Local.registered_migrations
+                       else
+                         {}
+                       end
+          return if registered.is_a?(Hash) && registered.key?(:extension_catalog)
+
+          Legion::Data::Local.register_migrations(name: :extension_catalog, path: path)
+        rescue StandardError => e
+          Legion::Logging.warn { "Catalog migration registration failed: #{e.class}: #{e.message}" } if defined?(Legion::Logging)
+        end
+
+        def extension_catalog_migrations_path
+          File.expand_path('../data/local_migrations', __dir__)
+        end
+
+        def warn_missing_extension_catalog_once
+          return false if @warned_missing_extension_catalog
+
+          @warned_missing_extension_catalog = true
+          Legion::Logging.warn('Catalog persist skipped: extension_catalog table is missing in Legion::Data::Local') if defined?(Legion::Logging)
+          false
+        end
       end
+
+      send(:ensure_local_migration_registered!) if defined?(Legion::Data::Local)
     end
   end
 end

data/lib/legion/extensions/core.rb

@@ -189,23 +189,25 @@ module Legion
       end
 
       def build_settings
+        defaults = deep_dup_settings_value(Legion::Settings[:default_extension_settings] || {})
+
         if Legion::Settings[:extensions].key?(lex_name.to_sym)
-          Legion::Settings[:default_extension_settings].each do |key, value|
+          defaults.each do |key, value|
             Legion::Settings[:extensions][lex_name.to_sym][key.to_sym] = if Legion::Settings[:extensions][lex_name.to_sym].key?(key.to_sym)
-                                                                           value.merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
+                                                                           deep_dup_settings_value(value).merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
                                                                          else
-                                                                           value
+                                                                           deep_dup_settings_value(value)
                                                                          end
           end
         else
-          Legion::Settings[:extensions][lex_name.to_sym] = Legion::Settings[:default_extension_settings]
+          Legion::Settings[:extensions][lex_name.to_sym] = defaults
         end
 
         default_settings.each do |key, value|
           Legion::Settings[:extensions][lex_name.to_sym][key.to_sym] = if Legion::Settings[:extensions][lex_name.to_sym].key?(key.to_sym)
-                                                                         value.merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
+                                                                         deep_dup_settings_value(value).merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
                                                                        else
-                                                                         value
+                                                                         deep_dup_settings_value(value)
                                                                        end
         end
       end
@@ -237,6 +239,21 @@ module Legion
       rescue StandardError => e
         handle_exception(e, lex: lex_name, operation: 'auto_generate_data')
       end
+
+      def deep_dup_settings_value(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, nested), duplicated|
+            duplicated[key.to_sym] = deep_dup_settings_value(nested)
+          end
+        when Array
+          value.map { |item| deep_dup_settings_value(item) }
+        else
+          value.dup
+        end
+      rescue TypeError
+        value
+      end
     end
   end
 end

data/lib/legion/extensions/helpers/secret.rb

@@ -78,6 +78,8 @@ module Legion
         end
 
         def vault_connected?
+          return Legion::Crypt.vault_connected? if defined?(Legion::Crypt) && Legion::Crypt.respond_to?(:vault_connected?)
+
           defined?(Legion::Settings) &&
             Legion::Settings[:crypt]&.dig(:vault, :connected) == true
         rescue StandardError