diff --git a/dependency.lic b/dependency.lic
index 6001ed98cc..065feb097b 100644
--- a/dependency.lic
+++ b/dependency.lic
@@ -1,10 +1,20 @@
 =begin
   Documentation: https://elanthipedia.play.net/Lich_script_development#dependency
+
+  As of 4.0.0, all gated class definitions (ArgParser, SetupFiles,
+  ScriptManager) and boot-sequence orchestration have been removed.
+  Core lich 5.17.2+ provides these natively via sentinels:
+    CORE_ARGPARSER, CORE_SETUPFILES, CORE_GET_SETTINGS,
+    CORE_SCRIPT_LOADER, CORE_MAP_OVERRIDES, CORE_DR_STARTUP
+
+  What remains are runtime helper functions (bankbot, slackbot,
+  reportbot, hometown, verify_script) that dr-scripts still call
+  and have not yet been upstreamed into core lich.
 =end
 
-$DEPENDENCY_VERSION = '3.1.0'
+$DEPENDENCY_VERSION = '4.0.0'
 $DR_SCRIPTS_DISCORD_LINK = 'https://discord.gg/f8ne99pVva'
-$MIN_LICH_VERSION = '5.17.0'
+$MIN_LICH_VERSION = '5.17.2'
 
 unless Gem::Version.new(LICH_VERSION) >= Gem::Version.new($MIN_LICH_VERSION)
   10.times do
@@ -27,1008 +37,7 @@ end
 
 echo("Dependency version #{$DEPENDENCY_VERSION}")
 
-debug = UserVars.debug_dependency
-
-# --- CORE_ARGPARSER gate ---
-if Lich::Common.const_defined?(:CORE_ARGPARSER, false)
-  # Core provides ArgParser via Lich::Common; include Lich::Common (lich.rbw) makes it top-level
-else
-  class ArgParser
-    def parse_args(data, flex_args = false)
-      raw_args = variable.first
-      baselist = variable.drop(1).dup || Array.new
-
-      unless baselist.size == 1 && baselist.grep(/^help$|^\?$|^h$/).any?
-
-        result = data.map { |definition| check_match(definition, baselist.dup, flex_args) }.compact
-
-        return result.first if result.length == 1
-
-        if result.empty?
-          echo "***INVALID ARGUMENTS DON'T MATCH ANY PATTERN***"
-          respond "Provided Arguments: '#{raw_args}'"
-        elsif result.length > 1
-          echo '***INVALID ARGUMENTS MATCH MULTIPLE PATTERNS***'
-          respond "Provided Arguments: '#{raw_args}'"
-        end
-
-      end
-
-      display_args(data)
-      exit
-    end
-
-    def display_args(data)
-      data.each do |def_set|
-        def_set
-          .select { |x| x[:name].to_s == "script_summary" }
-          .each { |x| respond " SCRIPT SUMMARY: #{x[:description]} " }
-        respond ''
-        respond " SCRIPT CALL FORMAT AND ARG DESCRIPTIONS (arguments in brackets are optional):"
-        respond "  ;#{Script.current.name} " + def_set.map { |x| format_item(x) unless x[:name].to_s == "script_summary" }.join(' ')
-        def_set
-          .reject { |x| x[:name].to_s == "script_summary" }
-          .each { |x| respond "   #{(x[:display] || x[:name]).ljust(12)} #{x[:description]} #{x[:options] ? '[' + x[:options].join(', ') + ']' : ''}" }
-      end
-
-      yaml_data = get_data('help').to_h
-      yaml_settings = yaml_data.select { |_field, info| info["referenced_by"].include?(Script.current.name) }
-
-      unless yaml_settings.empty?
-        respond ''
-        respond " YAML SETTINGS USED:"
-        yaml_settings.each do |field, info|
-          setting_line += "   #{field}: #{info["description"]} #{info["specific_descriptions"][Script.current.name]}"
-          setting_line += " [Ex: #{info["example"]}]" unless info["example"].to_s.nil? || info["example"].to_s.empty?
-          respond setting_line
-        end
-        respond ""
-      end
-    end
-
-    private
-
-    def matches_def(definition, item)
-      echo "#{definition}:#{item}" if UserVars.parse_args_debug
-      return true if definition[:regex] && definition[:regex] =~ item
-      return true if definition[:options] && definition[:options].find { |option| item =~ /^#{option}#{'$' if definition[:option_exact]}/i }
-
-      false
-    end
-
-    def check_match(defs, vars, flex)
-      args = OpenStruct.new
-
-      defs.reject { |x| x[:optional] }.each do |definition|
-        return nil unless matches_def(definition, vars.first)
-
-        args[definition[:name]] = vars.first.downcase
-        vars.shift
-      end
-
-      defs.select { |x| x[:optional] }.each do |definition|
-        if (match = vars.find { |x| matches_def(definition, x) })
-          args[definition[:name]] = match.downcase
-          vars.delete(match)
-        end
-      end
-
-      if flex
-        args.flex = vars
-
-        profiles = Dir[File.join(SCRIPT_DIR, 'profiles/*.*')]
-        profiles.each do |profile|
-          profile = profile[/.*#{Regexp.escape(checkname)}-(\w*).yaml/, 1]
-          args.to_h.values.each do |arg|
-            if arg == profile
-              echo "WARNING: yaml profile '#{checkname}-#{arg}.yaml' matches script argument '#{arg}'."
-              echo "Favoring the script argument. Rename the file if you intend to call it as a flexed settings file."
-            end
-          end
-        end
-      else
-        return nil unless vars.empty?
-      end
-
-      args
-    end
-
-    def format_item(definition)
-      item = definition[:display] || definition[:name]
-      if definition[:optional]
-        item = "[#{item}]"
-      elsif definition[:variable] || definition[:options]
-        item = "<#{item}>"
-      end
-      item
-    end
-  end
-end # CORE_ARGPARSER gate
-
-def parse_args(defn, flex_args = false)
-  ArgParser.new.parse_args(defn, flex_args)
-end
-
-def display_args(defn)
-  ArgParser.new.display_args(defn)
-end
-
-# --- CORE_SETUPFILES gate ---
-if Lich::Common.const_defined?(:CORE_SETUPFILES, false)
-  # Core provides SetupFiles via Lich::Common; include Lich::Common (lich.rbw) makes it top-level
-else
-  class SetupFiles
-    include MonitorMixin
-
-    class FileInfo
-      attr_reader :path, :name, :mtime
-
-      def initialize(path:, name:, data:, mtime:)
-        @path = path
-        @name = name
-        @data = data
-        @mtime = mtime
-      end
-
-      def data
-        Marshal.load(Marshal.dump(@data))
-      end
-
-      def peek(property)
-        Marshal.load(Marshal.dump(@data[property.to_sym]))
-      end
-
-      def to_s
-        File.join(@path, @name)
-      end
-
-      def inspect
-        "#<SetupFiles::FileInfo @name=#{@name}, @path=#{@path}, @mtime=#{@mtime}>"
-      end
-    end
-
-    def initialize(debug = false)
-      super()
-      @files_cache = {}
-      @debug = debug
-    end
-
-    def safe_load_yaml(filepath)
-      OpenStruct.new(YAML.unsafe_load_file(filepath)).to_h
-    rescue => e
-      echo('*** ERROR PARSING YAML FILE ***')
-      echo(e.message)
-      return {}
-    end
-
-    def get_settings(character_suffixes = [])
-      character_suffixes = ['setup', character_suffixes].flatten.compact.uniq
-      character_filenames = character_suffixes_to_filenames(character_suffixes)
-      reload_profiles(character_filenames)
-      initial_include_suffixes = character_filenames.reduce([]) do |result, filename|
-        result + (cache_get_by_filename(filename).peek('include') || [])
-      end
-      initial_include_filenames = initial_include_suffixes.map { |suffix| to_include_filename(suffix) }
-      include_filenames = resolve_includes_recursively(initial_include_filenames)
-      echo "#{self.class}::#{__callee__} resolved include_filenames=#{include_filenames}" if @debug
-      all_files = ['base.yaml', 'base-empty.yaml', include_filenames, character_filenames].flatten
-
-      union_keys = all_files.reduce([]) do |keys, filename|
-        file_keys = cache_get_by_filename(filename)&.peek('union_keys') || []
-        (keys + file_keys).uniq
-      end
-
-      settings = all_files.reduce({}) do |result, filename|
-        result.merge(cache_get_by_filename(filename).data || {}) do |key, old_val, new_val|
-          if union_keys.include?(key.to_s) && old_val.is_a?(Array) && new_val.is_a?(Array)
-            (old_val + new_val).uniq
-          else
-            new_val
-          end
-        end
-      end
-      transform_settings(settings)
-    end
-
-    def get_data(type)
-      filename = to_base_filename(type)
-      reload_data([filename])
-      transform_data(cache_get_by_filename(filename).data)
-    end
-
-    def reload
-      reload_profiles(character_suffixes_to_filenames(['setup']))
-      reload_data
-    end
-
-    private
-
-    SCRIPTS_DATA_PATH = File.join(SCRIPT_DIR, 'data')
-
-    if File.exist?(File.join(DATA_DIR, XMLData.game, "base.yaml")) && File.exist?(File.join(DATA_DIR, XMLData.game, "base-empty.yaml")) && File.exist?(File.join(DATA_DIR, XMLData.game, "#{checkname}-setup.yaml"))
-      echo("Detected game instance-specific files. Loading settings from #{File.join(DATA_DIR, XMLData.game)}")
-      SCRIPTS_PROFILES_PATH = File.join(DATA_DIR, XMLData.game)
-    else
-      SCRIPTS_PROFILES_PATH = File.join(SCRIPT_DIR, 'profiles')
-    end
-
-    def reload_profiles(filenames = [])
-      load_files(get_profiles_glob_patterns(filenames))
-    end
-
-    def reload_data(filenames = [])
-      load_files(get_data_glob_patterns(filenames))
-    end
-
-    def get_profiles_glob_patterns(filenames = [])
-      get_glob_patterns(SCRIPTS_PROFILES_PATH, filenames)
-    end
-
-    def get_data_glob_patterns(filenames = [])
-      get_glob_patterns(SCRIPTS_DATA_PATH, filenames)
-    end
-
-    def get_glob_patterns(basepath = '.', filenames = [])
-      filenames = ["base*.yaml", "include*.yaml", filenames].flatten.compact.uniq
-      filenames.map { |filename| File.join(basepath, File.basename(filename)) }
-    end
-
-    def character_suffixes_to_filenames(character_suffixes)
-      character_suffixes.map { |suffix| to_character_filename(suffix) }
-    end
-
-    def to_character_filename(suffix)
-      "#{checkname}-#{suffix}.yaml"
-    end
-
-    def to_base_filename(suffix)
-      "base-#{suffix}.yaml"
-    end
-
-    def to_include_filename(suffix)
-      "include-#{suffix}.yaml"
-    end
-
-    def resolve_includes_recursively(filenames, visited = Set.new, include_order = [])
-      filenames.each do |filename|
-        next if visited.include?(filename)
-
-        visited << filename
-        reload_profiles([filename])
-        file_info = cache_get_by_filename(filename)
-        next unless file_info
-
-        nested_suffixes = file_info.peek('include') || []
-        echo "#{self.class}::#{__callee__} #{filename} has nested includes: #{nested_suffixes}" if @debug && !nested_suffixes.empty?
-        nested_filenames = nested_suffixes.map { |suffix| to_include_filename(suffix) }
-
-        resolve_includes_recursively(nested_filenames, visited, include_order)
-
-        include_order << filename
-      end
-      include_order
-    end
-
-    def load_files(glob_patterns = [])
-      self.synchronize do
-        echo "#{self.class}::#{__callee__} glob_patterns=#{glob_patterns}" if @debug
-        glob_patterns.each do |glob_pattern|
-          Dir.glob(glob_pattern)
-             .uniq
-             .select { |filepath| File.file?(filepath) }
-             .each do |filepath|
-               filename = File.basename(filepath)
-               last_modified_date = File.mtime(filepath)
-               cached_file = cache_get_by_filename(filename)
-               echo "#{self.class}::#{__callee__} filepath=#{filepath}, last_modified_date=#{last_modified_date}, cached_file=#{cached_file.inspect}" if @debug
-               if cached_file.mtime != last_modified_date
-                 cache_put_by_filepath(filepath)
-               end
-             end
-        end
-      end
-    end
-
-    def cache_put_by_filepath(filepath)
-      self.synchronize do
-        echo "#{self.class}::#{__callee__} filepath=#{filepath}" if @debug
-        @files_cache[File.basename(filepath)] = SetupFiles::FileInfo.new(
-          path: File.dirname(filepath),
-          name: File.basename(filepath),
-          mtime: File.mtime(filepath),
-          data: safe_load_yaml(filepath)
-        )
-      end
-    end
-
-    def cache_get_by_filename(filename)
-      echo "#{self.class}::#{__callee__} filename=#{filename}" if @debug
-      @files_cache[filename]
-    end
-
-    def transform_settings(original_settings)
-      echo "#{self.class}::#{__callee__}" if @debug
-
-      settings = OpenStruct.new(original_settings)
-
-      base_data_items = get_data('items')
-      base_data_spells = get_data('spells')
-      base_data_empty = get_data('empty')
-
-      battle_cries_data = base_data_spells.battle_cries
-      spells_data = base_data_spells.spell_data
-      empty_data = base_data_empty.empty_values
-
-      empty_data.each { |name, value| settings[name] ||= value }
-
-      get_spell_data_by_name = lambda do |name_to_find|
-        spell_matches = spells_data.select { |name, _data| name.casecmp?(name_to_find) }
-        spell_match = spell_matches.first
-        spell_data = spell_match.last
-        spell_data['name'] ||= spell_match.first
-        spell_data
-      end
-
-      get_spell_data_by_abbrev = lambda do |abbrev_to_find|
-        spell_matches = spells_data.select { |_name, data| data['abbrev'].casecmp?(abbrev_to_find) }
-        spell_match = spell_matches.first
-        spell_data = spell_match.last
-        spell_data['name'] ||= spell_match.first
-        spell_data
-      end
-
-      enrich_spells_with_data_block = lambda do |spell_setting|
-        return spell_setting unless spell_setting.is_a?(Hash)
-
-        spell_data = get_spell_data_by_name.call(spell_setting['name']) ||
-                     get_spell_data_by_abbrev.call(spell_setting['abbrev'])
-        (spell_data || {}).merge(spell_setting)
-      end
-
-      enrich_spells_with_name_block = lambda do |spells_map|
-        spells_map.each do |spell_name, spell_setting|
-          if spell_setting.is_a?(Hash)
-            spell_setting['name'] ||= spell_name
-          end
-        end
-      end
-
-      settings.waggle_sets.transform_values! do |spells_map|
-        if spells_map.is_a?(Hash)
-          enrich_spells_with_name_block.call(spells_map)
-          spells_map.transform_values!(&enrich_spells_with_data_block)
-        else
-          spells_map
-        end
-      end
-
-      [
-        settings.buff_spells,
-        settings.necromancer_healing,
-      ].each do |spells_map|
-        enrich_spells_with_name_block.call(spells_map)
-        spells_map.transform_values!(&enrich_spells_with_data_block)
-      end
-
-      [
-        settings.buff_spells,
-        settings.combat_spell_training,
-        settings.cyclic_training_spells,
-        settings.magic_training,
-        settings.training_spells,
-        settings.crafting_training_spells,
-        settings.necromancer_healing,
-      ].each do |spells_map|
-        next unless spells_map.is_a?(Hash)
-
-        spells_map.transform_values!(&enrich_spells_with_data_block)
-      end
-
-      [
-        settings.offensive_spells
-      ].each do |spells_list|
-        spells_list.map!(&enrich_spells_with_data_block)
-      end
-
-      [
-        'crossing_training_sorcery',
-      ].each do |key|
-        settings[key] = enrich_spells_with_data_block.call(settings[key])
-      end
-
-      settings.offensive_spells.each do |spell_setting|
-        next unless spell_setting.is_a?(Hash)
-
-        spell_data = spells_data[spell_setting['name']]
-        is_native_tm = spell_setting['skill'] == 'Targeted Magic'
-        is_sorcery_tm = spell_setting['skill'] == 'Sorcery' && spell_data['skill'] == 'Targeted Magic'
-        if is_native_tm || is_sorcery_tm
-          spell_setting['prep'] ||= 'target'
-        end
-      end
-
-      settings.battle_cries.map! do |battle_cry_setting|
-        next battle_cry_setting unless battle_cry_setting.is_a?(Hash)
-
-        battle_cry_data = battle_cries_data[battle_cry_setting['name']]
-        (battle_cry_data || {}).merge(battle_cry_setting)
-      end
-
-      settings.lootables = (
-        base_data_items.lootables +
-        base_data_items.box_nouns +
-        base_data_items.gem_nouns +
-        base_data_items.scroll_nouns +
-        settings.loot_additions -
-        settings.loot_subtractions
-      ).uniq
-
-      settings.crossing_training_sorcery_room ||= UserVars.crossing_training_sorcery_room
-      settings.compost_room ||= UserVars.compost_room
-      settings.engineering_room ||= UserVars.engineering_room
-      settings.outfitting_room ||= UserVars.outfitting_room
-      settings.alchemy_room ||= UserVars.alchemy_room
-      settings.safe_room ||= UserVars.safe_room
-      settings.safe_room_id ||= UserVars.safe_room_id
-      settings.safe_room_empath ||= UserVars.safe_room_empath
-      settings.safe_room_empaths += (UserVars.safe_room_empaths || [])
-      settings.slack_username ||= UserVars.slack_username
-      settings.bankbot_name ||= UserVars.bankbot_name
-      settings.bankbot_room_id ||= UserVars.bankbot_room_id
-      settings.prehunt_buffs ||= UserVars.prehunt_buffs
-      settings.hometown ||= UserVars.hometown
-      settings.hometown = $HOMETOWN if $HOMETOWN
-
-      disallowed_safe_rooms = [5713]
-      if disallowed_safe_rooms.include?(settings.safe_room) || disallowed_safe_rooms.include?(settings.safe_room_id)
-        _respond("<pushBold/>#{settings.safe_room} is not a valid safe room setting.<popBold/>")
-        _respond("<pushBold/>Exiting.<popBold/>")
-        _respond("<pushBold/>Please edit your yaml to use a different safe room.<popBold/>")
-        exit
-      end
-
-      [
-        'alchemy_room',
-        'bankbot_room_id',
-        'compost_room',
-        'crossing_training_sorcery_room',
-        'enchanting_room',
-        'engineering_room',
-        'feed_cloak_room',
-        'forage_override_room',
-        'lockpick_room_id',
-        'outdoor_room',
-        'outfitting_room',
-        'prehunt_buffing_room',
-        'safe_room',
-        'safe_room_id',
-        'theurgy_prayer_mat_room'
-      ].each do |setting_name|
-        if settings[setting_name].is_a?(Hash)
-          hometown_value = settings[setting_name][settings.hometown]
-          settings[setting_name] = hometown_value if hometown_value
-        end
-      end
-
-      if !settings.appraisal_training.include?('pouches') && settings.train_appraisal_with_pouches
-        settings.appraisal_training.append('pouches')
-      end
-      if !settings.appraisal_training.include?('gear') && settings.train_appraisal_with_gear
-        settings.appraisal_training.append('gear')
-      end
-
-      if !settings.astrology_training.include?('events') && settings.predict_event
-        settings.astrology_training.append('events')
-      end
-      if !settings.astrology_training.include?('ways') && settings.astral_plane_training['train_in_ap']
-        settings.astrology_training.append('ways')
-      end
-
-      return settings
-    rescue => e
-      echo "*** ERROR TRANSFORMING SETTINGS IN DEPENDENCY ***"
-      echo "*** Commonly this due to malformed config in your yaml file ***"
-      echo e.message
-      e.backtrace.each { |msg| echo msg }
-      OpenStruct.new
-    end
-
-    def transform_data(original_data)
-      echo "#{self.class}::#{__callee__}" if @debug
-
-      data = OpenStruct.new(original_data)
-
-      return data
-    rescue => e
-      echo "*** ERROR MODIFYING DATA IN DEPENDENCY ***"
-      echo e.message
-      e.backtrace.each { |msg| echo msg }
-      OpenStruct.new
-    end
-  end
-end # CORE_SETUPFILES gate
-
-# --- CORE_GET_SETTINGS gate ---
-unless Lich::Common.const_defined?(:CORE_GET_SETTINGS, false)
-  $setupfiles = SetupFiles.new(debug)
-
-  def get_settings(character_suffixes = [])
-    $setupfiles.get_settings(character_suffixes)
-  end
-
-  def get_data(type)
-    $setupfiles.get_data(type)
-  end
-end # CORE_GET_SETTINGS gate
-
-# --- CORE_SCRIPT_LOADER gate ---
-unless Lich::Common.const_defined?(:CORE_SCRIPT_LOADER, false)
-  def custom_require
-    lambda do |script_names|
-      script_names = [script_names] unless script_names.is_a?(Array)
-
-      return if script_names.empty?
-
-      script_names.each do |script_name|
-        next if Script.running?(script_name)
-        next unless Script.exists?(script_name)
-        start_script(script_name)
-        pause 0.05
-        snapshot = Time.now
-        until !Script.running?(script_name) || Time.now - snapshot > 0.25
-          pause 0.05
-        end
-      end
-    end
-  end
-end # CORE_SCRIPT_LOADER gate
-
-# --- CORE_MAP_OVERRIDES gate ---
-unless Lich::Common.const_defined?(:CORE_MAP_OVERRIDES, false)
-  def make_map_edits
-    echo("Applying personal map overrides")
-    base_wayto_overrides = get_settings.base_wayto_overrides
-    personal_wayto_overrides = get_settings.personal_wayto_overrides
-    wayto_overrides = base_wayto_overrides.merge(personal_wayto_overrides)
-    wayto_overrides.each do |_key, values|
-      start_room_id = values['start_room'].to_i
-      end_room_id = values['end_room'].to_i
-      start_room = Map.list[start_room_id]
-      old_wayto = start_room.wayto["#{end_room_id}"]
-      old_timeto = start_room.timeto["#{end_room_id}"]
-      new_wayto = old_wayto
-      new_timeto = old_timeto
-      if values['str_proc']
-        new_wayto = StringProc.new("#{values['str_proc']}")
-      end
-      if values['travel_time']
-        new_timeto = Float(values['travel_time'], exception: false)
-        new_timeto ||= StringProc.new("#{values['travel_time']}")
-      end
-      start_room.wayto["#{end_room_id}"] = new_wayto
-      start_room.timeto["#{end_room_id}"] = new_timeto
-    end
-    personal_map_targets = get_settings.personal_map_targets
-    if personal_map_targets
-      custom_targets = (GameSettings['custom targets'] || Hash.new)
-      custom_targets.merge!(personal_map_targets)
-      GameSettings['custom targets'] = custom_targets
-    end
-  end
-end # CORE_MAP_OVERRIDES gate
-
-# --- ScriptManager gate (replaced by ScriptSync in core) ---
-unless Lich::Common.const_defined?(:CORE_GET_SETTINGS, false)
-  class ScriptManager
-    def initialize(debug)
-      @debug = debug
-      @status_url = 'https://api.github.com/repos/elanthia-online/dr-scripts/git/trees/main?recursive=1'
-      @raw_base_url = 'https://raw.githubusercontent.com/elanthia-online/dr-scripts/main'
-
-      UserVars.autostart_scripts ||= []
-      UserVars.autostart_scripts.uniq!
-      UserVars.autostart_scripts -= ['dependency']
-
-      Settings['base_versions'] ||= {}
-
-      @request_authorization = load_personal_github_token
-      @versions = nil
-      @dependency_updated = false
-      @downloads_occurred = false
-    end
-
-    def dependency_updated?
-      @dependency_updated
-    end
-
-    def autostarts
-      (UserVars.autostart_scripts.to_a + SetupFiles.new.get_settings.autostarts.to_a).uniq
-    end
-
-    def get_versions
-      @versions ||= build_version_hash
-    end
-
-    def build_version_hash
-      Dir[File.join(SCRIPT_DIR, '*.lic')].each_with_object({}) do |path, versions|
-        file = File.basename(path)
-        body = File.binread(File.join(SCRIPT_DIR, file))
-        sha = Digest::SHA1.hexdigest('blob' + " #{body.size}" + "\0" + body)
-        versions[file] = sha
-      end
-    end
-
-    def get_script(filename, force = false)
-      filename = filename.dup
-      download_script(filename, force)
-    end
-
-    def repo_scripts
-      $manager.get_status['tree'].map { |element| element['path'] }.select { |file| file =~ /^[^\/]+\.lic$/ && !file.include?('-setup') }
-    end
-
-    def start_scripts(force = false)
-      start_time = Time.now
-      @versions = nil
-      scripts = repo_scripts
-      echo("Checking #{scripts.length} scripts for updates...")
-      updated = 0
-      scripts.each do |(name, _)|
-        updated += 1 if get_script(name, force)
-      end
-      if updated > 0
-        echo("Updated #{updated} script#{updated == 1 ? '' : 's'}.")
-        invalidate_status_cache
-      else
-        echo("All scripts are up to date.")
-      end
-      autostarts.each do |script|
-        custom_require.call(script)
-      end
-      finish_time = Time.now
-      run_time = finish_time - start_time
-      echo("Time spent in start_scripts is #{run_time}") if @debug
-    end
-
-    def download_script(filename, force = false)
-      return false if filename.nil? || filename.empty?
-
-      echo("downloading:#{filename}") if @debug
-      info = get_file_status(filename)
-      return false unless info
-      return false if get_versions[filename] == info['sha'] && !force
-
-      echo("info:#{info}") if @debug
-      content = download_raw_file(filename)
-      return false unless content
-
-      File.open(File.join(SCRIPT_DIR, "#{filename}"), 'wb') { |file| file.print(content) }
-      @downloads_occurred = true
-      @dependency_updated = true if filename == 'dependency.lic'
-      echo("Downloaded #{filename}")
-      true
-    end
-
-    def verify_or_make_dir(path)
-      Dir.mkdir(path) unless Dir.exist?(path)
-    end
-
-    def setup_data
-      verify_or_make_dir File.join(SCRIPT_DIR, 'data')
-      get_status['tree']
-        .select { |data| data['path'] =~ %r{^data/} && data['type'] == 'blob' }
-        .each do |setup_file|
-          filename = File.basename(setup_file['path'])
-          echo("downloading #{filename}") if @debug
-          content = download_raw_file(setup_file['path'])
-          next unless content
-
-          File.open(File.join(SCRIPT_DIR, "data/#{filename}"), 'wb') { |file| file.print(content) }
-        end
-    end
-
-    def check_base_files
-      start_time = Time.now
-      verify_or_make_dir File.join(SCRIPT_DIR, 'profiles')
-      to_update = get_status['tree']
-                  .select { |data| data['path'] =~ %r{^profiles/base(?:-empty)?\.yaml$} }
-                  .reject { |setup_file|
-                    filename = File.basename(setup_file['path'])
-                    File.exist?(File.join(SCRIPT_DIR, 'profiles', filename)) && setup_file['sha'] == Settings['base_versions'][filename]
-                  }
-      if to_update.empty?
-        echo("Base profile files are up to date.")
-      else
-        echo("Updating #{to_update.length} base profile file#{to_update.length == 1 ? '' : 's'}...")
-        to_update.each do |setup_file|
-          filename = File.basename(setup_file['path'])
-          content = download_raw_file(setup_file['path'])
-          next unless content
-
-          File.open(File.join(SCRIPT_DIR, "profiles/#{filename}"), 'wb') { |file| file.print(content) }
-          Settings['base_versions'][filename] = setup_file['sha']
-          echo("Downloaded #{filename}")
-        end
-      end
-      Settings.save
-      finish_time = Time.now
-      run_time = finish_time - start_time
-      echo("Time spent in check_base_files is #{run_time}") if @debug
-    end
-
-    def check_data_files
-      start_time = Time.now
-      verify_or_make_dir File.join(SCRIPT_DIR, 'data')
-      to_update = get_status['tree']
-                  .select { |data| data['path'] =~ %r{^data/base.+yaml$} }
-                  .reject { |setup_file|
-                    filename = File.basename(setup_file['path'])
-                    File.exist?(File.join(SCRIPT_DIR, 'data', filename)) && setup_file['sha'] == Settings['base_versions'][filename]
-                  }
-      if to_update.empty?
-        echo("Data files are up to date.")
-      else
-        echo("Updating #{to_update.length} data file#{to_update.length == 1 ? '' : 's'}...")
-        to_update.each do |setup_file|
-          filename = File.basename(setup_file['path'])
-          content = download_raw_file(setup_file['path'])
-          next unless content
-
-          File.open(File.join(SCRIPT_DIR, "data/#{filename}"), 'wb') { |file| file.print(content) }
-          Settings['base_versions'][filename] = setup_file['sha']
-          echo("Downloaded #{filename}")
-        end
-      end
-      Settings.save
-      finish_time = Time.now
-      run_time = finish_time - start_time
-      echo("Time spent in check_data_files is #{run_time}") if @debug
-    end
-
-    def run_script(filename)
-      filename.sub!(/\.lic$/, '')
-      echo("refresh:#{filename}") if @debug
-      stop_script(filename) if Script.running?(filename)
-      pause 0.1 while Script.running?(filename)
-      start_script(filename)
-    end
-
-    def get_file_status(filename)
-      get_status['tree'].find { |element| element['path'] == filename }
-    end
-
-    def invalidate_status_cache
-      echo("Invalidating cached status (files were downloaded)") if @debug
-      Settings['status'] = nil
-      Settings['status_time'] = nil
-      Settings.save
-    end
-
-    def get_status
-      if Settings['status'] && Time.now - Settings['status_time'] <= 120
-        echo("Returning cached status response") if @debug
-        return Settings['status']
-      end
-
-      Settings['status_time'] = Time.now
-      Settings['status'] = make_request(@status_url)
-      Settings.save
-      return Settings['status']
-    end
-
-    def make_request(raw_uri)
-      echo "make_request:raw_uri = #{raw_uri}" if @debug
-      uri = URI.parse(raw_uri)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-      request = Net::HTTP::Get.new(uri.request_uri)
-      request['Authorization'] = @request_authorization if @request_authorization
-
-      response = http.request(request)
-      JSON.parse(response.body)
-    end
-
-    def download_raw_file(path)
-      raw_url = "#{@raw_base_url}/#{path}"
-      echo "download_raw_file: #{raw_url}" if @debug
-      uri = URI.parse(raw_url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-      request = Net::HTTP::Get.new(uri.request_uri)
-      response = http.request(request)
-
-      unless response.code == '200'
-        echo "Failed to download #{path}: HTTP #{response.code}"
-        return nil
-      end
-
-      response.body
-    end
-
-    def load_personal_github_token
-      token_path = "#{DATA_DIR}/githubtoken.txt"
-      return nil unless File.exist?(token_path)
-
-      token = File.read(token_path).strip
-      if token.empty?
-        echo "GitHub token file is empty. Using unauthenticated access."
-        return nil
-      end
-
-      echo "Using personal GitHub token."
-
-      url = URI("https://api.github.com/rate_limit")
-      http = Net::HTTP.new(url.host, url.port)
-      http.use_ssl = true
-      request = Net::HTTP::Get.new(url)
-      request['Authorization'] = "Bearer #{token}"
-
-      response = http.request(request)
-      if response.body =~ /Bad credentials/
-        echo "Bad personal GitHub token. Falling back to unauthenticated access."
-        echo "Please update or remove #{token_path}"
-        return nil
-      end
-
-      parsed_response = JSON.parse(response.body)
-      used = parsed_response["resources"]["core"]["used"].to_i
-      limit = parsed_response["resources"]["core"]["limit"].to_i
-      echo "Personal token rate limit usage: #{used}/#{limit}" if @debug
-
-      "Bearer #{token}"
-    end
-
-    def make_map_edits
-      echo("Applying personal map overrides")
-      base_wayto_overrides = get_settings.base_wayto_overrides
-      personal_wayto_overrides = get_settings.personal_wayto_overrides
-      wayto_overrides = base_wayto_overrides.merge(personal_wayto_overrides)
-      wayto_overrides.each do |_key, values|
-        start_room_id = values['start_room'].to_i
-        end_room_id = values['end_room'].to_i
-        start_room = Map.list[start_room_id]
-        old_wayto = start_room.wayto["#{end_room_id}"]
-        old_timeto = start_room.timeto["#{end_room_id}"]
-        new_wayto = old_wayto
-        new_timeto = old_timeto
-        if values['str_proc']
-          new_wayto = StringProc.new("#{values['str_proc']}")
-        end
-        if values['travel_time']
-          new_timeto = Float(values['travel_time'], exception: false)
-          new_timeto ||= StringProc.new("#{values['travel_time']}")
-        end
-        start_room.wayto["#{end_room_id}"] = new_wayto
-        start_room.timeto["#{end_room_id}"] = new_timeto
-      end
-      personal_map_targets = get_settings.personal_map_targets
-      if personal_map_targets
-        custom_targets = (GameSettings['custom targets'] || Hash.new)
-        custom_targets.merge!(personal_map_targets)
-        GameSettings['custom targets'] = custom_targets
-      end
-    end
-  end
-
-  $manager = ScriptManager.new(debug)
-
-  def get_script(script_name)
-    filename = format_name(script_name)
-    if $manager.get_script(filename, true)
-      echo("#{filename} has been updated.")
-    else
-      echo("#{filename} could not be found in the repository.")
-    end
-  end
-
-  def force_refresh_scripts
-    echo("Force refreshing all scripts.")
-    $manager.start_scripts
-  end
-
-  def list_tracked_scripts
-    $manager.get_versions.sort
-  end
-
-  def setup_data
-    echo("Force checking scripts/data files.")
-    $manager.setup_data
-  end
-end # ScriptManager gate
-
-# --- One-shot cleanup of orphaned Settings['autostart'] ---
-# The old CORE_AUTOSTART gate merged Settings['autostart'] into
-# UserVars.autostart_scripts on every login, making it impossible
-# to permanently remove entries.  Clear the orphaned data once,
-# then this block becomes a no-op on subsequent logins.
-if Settings['autostart']
-  echo("Clearing orphaned Settings['autostart'] (no longer used).")
-  Settings['autostart'] = nil
-  Settings.save
-end
-
-# --- Deprecated autostart helpers ---
-# These functions were removed in 3.1.0. Thin stubs remain so that
-# scripts or console calls get a clear message instead of NoMethodError.
-def autostart(_script_names, _global = true)
-  echo("DEPRECATED: autostart() has been removed.")
-  echo("Use the 'autostarts' list in your YAML profile, or ;autostart add <script>")
-end
-
-def stop_autostart(_script_names)
-  echo("DEPRECATED: stop_autostart() has been removed.")
-  echo("Remove the script from 'autostarts' in your YAML profile, or ;autostart remove <script>")
-end
-
-def dependency_status
-  echo("DEPRECATED: dependency_status() has been removed.")
-  echo("Use ;autostart list to see active autostarts.")
-end
-
-# --- CORE_DR_STARTUP gate ---
-unless Lich::Common.const_defined?(:CORE_DR_STARTUP, false)
-  unless UserVars.dependency_setflags
-    echo("Checking MonsterBold and ShowRoomID flags.")
-    flags = Lich::Util.issue_command("flag", /^Usage/, /^For other setting options, see AVOID, SET, and TOGGLE/, quiet: true, timeout: 1, usexml: false)
-    mandatory_flags = ["ShowRoomID", "MonsterBold"]
-    mandatory_flags.each do |flag|
-      unless flags.any? { |f| f.match?(/#{flag}\s+ON/) }
-        fput("flag #{flag} on")
-      end
-    end
-    UserVars.dependency_setflags = Time.now
-  end
-
-  DR_OBSOLETE_SCRIPTS = %w[
-    events slackbot spellmonitor exp-monitor
-    common-travel common-validation common drinfomon equipmanager
-    common-money common-moonmage common-summoning common-theurgy common-arcana
-    bootstrap common-crafting common-healing-data common-healing common-items
-    update-shops
-  ].freeze
-
-  DR_OBSOLETE_DATA_FILES = %w[].freeze
-
-  def warn_obsolete_scripts
-    DR_OBSOLETE_SCRIPTS.each do |script_name|
-      path = File.join(SCRIPT_DIR, "#{script_name}.lic")
-      next unless File.exist?(path)
-
-      _respond Lich::Messaging.monsterbold("--- Lich: '#{script_name}.lic' is obsolete and should be deleted from #{SCRIPT_DIR}. It is no longer needed and may cause problems.")
-    end
-  end
-
-  def warn_obsolete_data_files
-    data_dir = File.join(SCRIPT_DIR, 'data')
-    DR_OBSOLETE_DATA_FILES.each do |filename|
-      path = File.join(data_dir, filename)
-      next unless File.exist?(path)
-
-      _respond Lich::Messaging.monsterbold("--- Lich: '#{filename}' is obsolete and can be safely deleted from #{data_dir}.")
-    end
-  end
-
-  def warn_custom_scripts
-    custom_scripts = Dir.entries(File.join(SCRIPT_DIR, 'custom')).reject { |f| File.directory?(f) || File.basename(f).start_with?(".") }
-    curated_scripts = Dir.entries(SCRIPT_DIR).reject { |f| File.directory?(f) || File.basename(f).start_with?(".") }
-    include_list = []
-
-    custom_scripts.each do |script|
-      include_list.push(script) if curated_scripts.include?(script)
-    end
-
-    unless include_list.empty?
-      echo "NOTE: The following curated scripts are in your custom folder and will not receive updates"
-      echo "#{include_list}" unless include_list.empty?
-    end
-  end
-end # CORE_DR_STARTUP gate
-
-# --- Runtime helpers (not gated, always defined) ---
+# --- Runtime helpers ---
 
 def save_bankbot_transaction(transaction, ledger)
   ledger_yaml = ledger.to_yaml
@@ -1108,72 +117,3 @@ end
 def clear_hometown
   $HOMETOWN = nil
 end
-
-# --- Boot sequence ---
-
-# Legacy ScriptManager boot (skipped when core provides ScriptSync)
-if defined?($manager)
-  arg_definitions = [
-    [
-      { name: 'install', regex: /install/i, optional: true }
-    ]
-  ]
-  args = parse_args(arg_definitions)
-  install = args.install
-
-  while Script.running?('repository')
-    echo("Repository is running, pausing for 10 seconds.")
-    pause 10
-  end
-
-  unless Settings['dependency_version'] == $DEPENDENCY_VERSION
-    echo("New dependency version detected. Resetting repository auto-update settings.")
-    Script.start("repository", "reset-update-settings")
-    if XMLData.game == "DRX" || XMLData.game == "DRF"
-      if XMLData.game == "DRX"
-        echo("DR Plat instance detected. Setting map to not auto-update.")
-      elsif XMLData.game == "DRF"
-        echo("DR Fallen instance detected. Setting map to not auto-update.")
-      end
-      Script.start("repository", "unset-mapdb-updatable")
-    end
-    Settings['status'] = nil
-    Settings['status_time'] = nil
-    Settings['dependency_version'] = $DEPENDENCY_VERSION
-    Settings.save
-  end
-
-  if install
-    respond 'Performing setup for dr-scripts. This will take some time. Do not stop this script until finished.'
-  end
-
-  respond '(Step 1 of 4) Checking base profile files...' if install
-  $manager.check_base_files
-
-  respond '(Step 2 of 4) Checking data files...' if install
-  $manager.check_data_files
-
-  respond '(Step 3 of 4) Downloading and starting scripts...' if install
-  $manager.start_scripts
-
-  respond '(Step 4 of 4) Applying map edits...' if install
-  $manager.make_map_edits
-
-  respond 'Finished install!' if install
-
-  if $manager.dependency_updated?
-    DRC.message("--- Dependency: A new version of dependency.lic was downloaded.")
-    DRC.message("--- Dependency: Run ;dependency to pick up the new version.")
-  end
-else
-  # Core provides ScriptSync -- just apply map overrides
-  make_map_edits if respond_to?(:make_map_edits, true)
-end
-
-# Reload settings cache
-$setupfiles.reload if defined?($setupfiles) && $setupfiles
-
-# Run startup warnings (gated functions handle core vs inline)
-warn_custom_scripts if respond_to?(:warn_custom_scripts, true)
-warn_obsolete_scripts if respond_to?(:warn_obsolete_scripts, true)
-warn_obsolete_data_files if respond_to?(:warn_obsolete_data_files, true)
diff --git a/spec/dependency_spec.rb b/spec/dependency_spec.rb
index 8ff5635771..e2fdc4b5da 100644
--- a/spec/dependency_spec.rb
+++ b/spec/dependency_spec.rb
@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'digest'
 require 'tmpdir'
 require 'ostruct'
 require 'yaml'
 
-# Test suite for dependency.lic
+# Test suite for dependency.lic (v4.0.0+)
 #
-# Covers obsolete script detection, autostart handling, cascading includes,
-# and inlined manager functions (bankbot, reportbot, slackbot).
+# Covers the runtime helper functions that remain after all gated
+# code was removed (core lich 5.17.2+ provides ArgParser, SetupFiles,
+# ScriptManager, map overrides, and DR startup natively).
 
-# Stub SCRIPT_DIR, _respond, respond, and Lich::Messaging before loading methods
+# Stub constants and globals before loading methods
 SCRIPT_DIR = Dir.mktmpdir('dr-scripts-test') unless defined?(SCRIPT_DIR)
 LICH_DIR = Dir.mktmpdir('lich-test') unless defined?(LICH_DIR)
 
@@ -22,17 +22,19 @@ def self.monsterbold(msg)
   end
 end
 
-# Capture _respond and respond calls for assertion
 $respond_messages = []
 def _respond(msg)
   $respond_messages << msg
 end
 
-# Stub Script.current for dr_obsolete_script?
 module Script
   def self.current
     OpenStruct.new(name: 'test-script')
   end
+
+  def self.exists?(_name)
+    false
+  end
 end
 
 $clean_lich_char = ';'
@@ -45,50 +47,12 @@ def echo(_msg)
   # no-op in tests
 end
 
-# Mock UserVars with a mutable autostart_scripts array
-module UserVars
-  class << self
-    attr_accessor :autostart_scripts
-  end
-  self.autostart_scripts = []
-end unless defined?(UserVars)
-
-# Mock Settings as a hash-like store
-module Settings
-  @store = { 'autostart' => [] }
-
-  def self.[](key)
-    @store[key]
-  end
-
-  def self.[]=(key, value)
-    @store[key] = value
-  end
-
-  def self.reset!
-    @store = { 'autostart' => [] }
-  end
-end unless defined?(Settings)
-
-# --- Extract the constant and methods from dependency.lic ---
-# We eval only the relevant sections to avoid all Lich runtime dependencies.
-# Methods/constants may be at column 0 or indented inside sentinel gate blocks.
+# --- Extract methods from dependency.lic ---
 dep_path = File.join(File.dirname(__FILE__), '..', 'dependency.lic')
 dep_lines = File.readlines(dep_path)
 
-# Helper: extract a constant assignment (possibly indented) through .freeze
-def extract_constant(lines, path, const_name)
-  start = lines.index { |l| l =~ /^\s*#{Regexp.escape(const_name)}\s*=/ }
-  raise "Could not find #{const_name} in #{path}" unless start
-
-  freeze_offset = lines[start..].index { |l| l =~ /\.freeze$/ }
-  raise "Could not find .freeze for #{const_name}" unless freeze_offset
-
-  source = lines[start..start + freeze_offset].map(&:lstrip).join
-  eval(source, TOPLEVEL_BINDING, path, start + 1)
-end
+DEP_SOURCE = File.read(dep_path)
 
-# Helper: extract a method definition (possibly indented) through its matching end
 def extract_method(lines, path, method_name)
   start = lines.index { |l| l =~ /^\s*def #{Regexp.escape(method_name)}[\s(]?/ }
   raise "Could not find def #{method_name} in #{path}" unless start
@@ -101,432 +65,21 @@ def extract_method(lines, path, method_name)
   eval(source, TOPLEVEL_BINDING, path, start + 1)
 end
 
-extract_constant(dep_lines, dep_path, 'DR_OBSOLETE_SCRIPTS')
-extract_constant(dep_lines, dep_path, 'DR_OBSOLETE_DATA_FILES')
-
 %w[
-  warn_obsolete_scripts
   save_bankbot_transaction
   load_bankbot_ledger
   save_reportbot_whitelist
   load_reportbot_whitelist
   register_slackbot
   send_slackbot_message
-  warn_obsolete_data_files
+  format_name
+  format_yaml_name
+  verify_script
+  shift_hometown
+  clear_hometown
 ].each { |fn| extract_method(dep_lines, dep_path, fn) }
 
-RSpec.describe 'Obsolete Scripts' do
-  before { $respond_messages.clear }
-
-  describe 'DR_OBSOLETE_SCRIPTS' do
-    it 'includes exp-monitor' do
-      expect(DR_OBSOLETE_SCRIPTS).to include('exp-monitor')
-    end
-
-    it 'includes previously obsoleted scripts' do
-      %w[events slackbot spellmonitor].each do |script|
-        expect(DR_OBSOLETE_SCRIPTS).to include(script)
-      end
-    end
-
-    it 'is frozen' do
-      expect(DR_OBSOLETE_SCRIPTS).to be_frozen
-    end
-  end
-
-  describe '#warn_obsolete_scripts' do
-    context 'when no obsolete script files exist' do
-      it 'produces no warnings' do
-        warn_obsolete_scripts
-        expect($respond_messages).to be_empty
-      end
-    end
-
-    context 'when an obsolete script file exists in SCRIPT_DIR' do
-      around do |example|
-        path = File.join(SCRIPT_DIR, 'exp-monitor.lic')
-        File.write(path, '# obsolete')
-        example.run
-      ensure
-        File.delete(path) if File.exist?(path)
-      end
-
-      it 'warns about the obsolete file' do
-        warn_obsolete_scripts
-        warning = $respond_messages.find { |m| m.include?('exp-monitor') }
-        expect(warning).to include('obsolete')
-        expect(warning).to include('should be deleted')
-      end
-    end
-  end
-
-  describe 'DR_OBSOLETE_DATA_FILES' do
-    it 'is frozen' do
-      expect(DR_OBSOLETE_DATA_FILES).to be_frozen
-    end
-
-    it 'is empty (no data files are currently obsolete)' do
-      expect(DR_OBSOLETE_DATA_FILES).to be_empty
-    end
-  end
-
-  describe '#warn_obsolete_data_files' do
-    let(:data_dir) { File.join(SCRIPT_DIR, 'data') }
-
-    before { FileUtils.mkdir_p(data_dir) }
-
-    context 'when no obsolete data files exist' do
-      it 'produces no warnings' do
-        warn_obsolete_data_files
-        expect($respond_messages).to be_empty
-      end
-    end
-  end
-end
-
-# --- Cascading Includes ---
-
-# Minimal mock that replicates the resolve_includes_recursively behavior.
-# Tests the core algorithm in isolation without SetupFiles's complex dependencies.
-class IncludeResolver
-  attr_reader :files, :loaded_files, :debug
-
-  def initialize(files = {}, debug: false)
-    @files = files
-    @loaded_files = []
-    @debug = debug
-  end
-
-  def reload_profiles(filenames)
-    filenames.each { |f| @loaded_files << f unless @loaded_files.include?(f) }
-  end
-
-  def cache_get_by_filename(filename)
-    return nil unless @files.key?(filename)
-
-    data = @files[filename]
-    OpenStruct.new(
-      name: filename,
-      data: data,
-      peek: ->(prop) { data[prop.to_sym] || data[prop.to_s] }
-    )
-  end
-
-  def to_include_filename(suffix)
-    "include-#{suffix}.yaml"
-  end
-
-  def echo(msg)
-    puts msg if @debug
-  end
-
-  def resolve_includes_recursively(filenames, visited = Set.new, include_order = [])
-    filenames.each do |filename|
-      next if visited.include?(filename)
-
-      visited << filename
-      reload_profiles([filename])
-      file_info = cache_get_by_filename(filename)
-      next unless file_info
-
-      nested_suffixes = file_info.peek.call('include') || []
-      echo "#{filename} has nested includes: #{nested_suffixes}" if @debug && !nested_suffixes.empty?
-      nested_filenames = nested_suffixes.map { |suffix| to_include_filename(suffix) }
-
-      resolve_includes_recursively(nested_filenames, visited, include_order)
-
-      include_order << filename
-    end
-    include_order
-  end
-end
-
-RSpec.describe 'Cascading Includes Algorithm' do
-  describe '#resolve_includes_recursively' do
-    context 'with no includes' do
-      it 'returns empty array when no include files specified' do
-        resolver = IncludeResolver.new({})
-        result = resolver.resolve_includes_recursively([])
-        expect(result).to eq([])
-      end
-    end
-
-    context 'with single-level includes (backwards compatibility)' do
-      let(:files) do
-        {
-          'include-hunting.yaml' => { hunting_zones: ['zone1', 'zone2'] }
-        }
-      end
-
-      it 'resolves single-level includes correctly' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-hunting.yaml'])
-        expect(result).to eq(['include-hunting.yaml'])
-      end
-    end
-
-    context 'with two-level cascading includes' do
-      let(:files) do
-        {
-          'include-hunting.yaml' => { include: ['combat'], hunting_zones: ['zone1'] },
-          'include-combat.yaml'  => { combat_style: 'aggressive' }
-        }
-      end
-
-      it 'resolves nested includes depth-first' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-hunting.yaml'])
-        expect(result).to eq(['include-combat.yaml', 'include-hunting.yaml'])
-      end
-    end
-
-    context 'with three-level cascading includes' do
-      let(:files) do
-        {
-          'include-hunting.yaml' => { include: ['combat'], hunting_zones: ['zone1'] },
-          'include-combat.yaml'  => { include: ['weapons'], combat_style: 'aggressive' },
-          'include-weapons.yaml' => { primary_weapon: 'sword' }
-        }
-      end
-
-      it 'resolves three levels depth-first' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-hunting.yaml'])
-        expect(result).to eq(['include-weapons.yaml', 'include-combat.yaml', 'include-hunting.yaml'])
-      end
-    end
-
-    context 'with sibling includes at same level' do
-      let(:files) do
-        {
-          'include-hunting.yaml'  => { include: ['combat', 'survival'], hunting_zones: ['zone1'] },
-          'include-combat.yaml'   => { combat_style: 'aggressive' },
-          'include-survival.yaml' => { survival_skill: 'evasion' }
-        }
-      end
-
-      it 'resolves siblings in order, depth-first' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-hunting.yaml'])
-        expect(result).to eq(['include-combat.yaml', 'include-survival.yaml', 'include-hunting.yaml'])
-      end
-    end
-
-    context 'with diamond dependency pattern' do
-      let(:files) do
-        {
-          'include-hunting.yaml'  => { include: ['common'], hunting_zones: ['zone1'] },
-          'include-crafting.yaml' => { include: ['common'], crafting_type: 'forging' },
-          'include-common.yaml'   => { safe_room: 1234 }
-        }
-      end
-
-      it 'resolves diamond pattern without duplicates' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-hunting.yaml', 'include-crafting.yaml'])
-        expect(result).to eq(['include-common.yaml', 'include-hunting.yaml', 'include-crafting.yaml'])
-        expect(result.count('include-common.yaml')).to eq(1)
-      end
-    end
-
-    context 'with circular dependency' do
-      let(:files) do
-        {
-          'include-circular-a.yaml' => { include: ['circular-b'], setting_a: 'value_a' },
-          'include-circular-b.yaml' => { include: ['circular-a'], setting_b: 'value_b' }
-        }
-      end
-
-      it 'handles circular dependency without infinite loop' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-circular-a.yaml'])
-        expect(result).to eq(['include-circular-b.yaml', 'include-circular-a.yaml'])
-      end
-    end
-
-    context 'with self-referencing include' do
-      let(:files) do
-        {
-          'include-self-ref.yaml' => { include: ['self-ref'], setting_self: 'value_self' }
-        }
-      end
-
-      it 'handles self-reference without infinite loop' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-self-ref.yaml'])
-        expect(result).to eq(['include-self-ref.yaml'])
-      end
-    end
-
-    context 'with missing include file' do
-      let(:files) do
-        {
-          'include-exists.yaml' => { existing_setting: 'value' }
-        }
-      end
-
-      it 'skips missing files gracefully' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-exists.yaml', 'include-missing.yaml'])
-        expect(result).to eq(['include-exists.yaml'])
-      end
-    end
-
-    context 'with include file having empty include array' do
-      let(:files) do
-        {
-          'include-empty-includes.yaml' => { include: [], some_setting: 'value' }
-        }
-      end
-
-      it 'handles empty include arrays' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-empty-includes.yaml'])
-        expect(result).to eq(['include-empty-includes.yaml'])
-      end
-    end
-
-    context 'with include file having nil/missing include key' do
-      let(:files) do
-        {
-          'include-nil-includes.yaml' => { some_setting: 'value' }
-        }
-      end
-
-      it 'handles missing include key (nil)' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-nil-includes.yaml'])
-        expect(result).to eq(['include-nil-includes.yaml'])
-      end
-    end
-
-    context 'with deeply nested includes (stress test)' do
-      let(:files) do
-        (1..10).each_with_object({}) do |level, hash|
-          next_include = level < 10 ? ["level-#{level + 1}"] : []
-          hash["include-level-#{level}.yaml"] = {
-            include: next_include,
-            "setting_#{level}": "value_#{level}"
-          }
-        end
-      end
-
-      it 'handles deeply nested includes' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-level-1.yaml'])
-        expect(result.length).to eq(10)
-      end
-
-      it 'resolves in correct depth-first order' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-level-1.yaml'])
-        expected = (1..10).to_a.reverse.map { |n| "include-level-#{n}.yaml" }
-        expect(result).to eq(expected)
-      end
-    end
-
-    context 'complex real-world scenario' do
-      let(:files) do
-        {
-          'include-moon-mage.yaml'  => {
-            include: ['magic-user', 'common'],
-            guild: 'Moon Mage',
-            cambrinth: 'moon-staff'
-          },
-          'include-crossing.yaml'   => {
-            include: ['common'],
-            hometown: 'Crossing',
-            safe_room: 1234
-          },
-          'include-magic-user.yaml' => {
-            include: ['common'],
-            train_magic: true
-          },
-          'include-common.yaml'     => {
-            loot_coins: true,
-            safe_room: 9999
-          }
-        }
-      end
-
-      it 'resolves complex hierarchy correctly' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-moon-mage.yaml', 'include-crossing.yaml'])
-        expect(result).to eq([
-                               'include-common.yaml',
-                               'include-magic-user.yaml',
-                               'include-moon-mage.yaml',
-                               'include-crossing.yaml'
-                             ])
-      end
-
-      it 'common is only loaded once despite multiple references' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-moon-mage.yaml', 'include-crossing.yaml'])
-        expect(result.count('include-common.yaml')).to eq(1)
-        expect(result.uniq.length).to eq(result.length)
-      end
-    end
-
-    context 'multiple initial includes with shared dependencies' do
-      let(:files) do
-        {
-          'include-hunting.yaml'   => { include: ['weapons', 'armor'] },
-          'include-crafting.yaml'  => { include: ['tools', 'armor'] },
-          'include-weapons.yaml'   => { include: ['materials'] },
-          'include-tools.yaml'     => { include: ['materials'] },
-          'include-armor.yaml'     => {},
-          'include-materials.yaml' => {}
-        }
-      end
-
-      it 'resolves shared dependencies correctly' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-hunting.yaml', 'include-crafting.yaml'])
-        expect(result.uniq.length).to eq(result.length)
-        expect(result).to include('include-hunting.yaml')
-        expect(result).to include('include-crafting.yaml')
-        expect(result).to include('include-weapons.yaml')
-        expect(result).to include('include-tools.yaml')
-        expect(result).to include('include-armor.yaml')
-        expect(result).to include('include-materials.yaml')
-      end
-
-      it 'maintains depth-first order' do
-        resolver = IncludeResolver.new(files)
-        result = resolver.resolve_includes_recursively(['include-hunting.yaml', 'include-crafting.yaml'])
-        expect(result.index('include-materials.yaml')).to be < result.index('include-weapons.yaml')
-        expect(result.index('include-weapons.yaml')).to be < result.index('include-hunting.yaml')
-        expect(result.index('include-hunting.yaml')).to be < result.index('include-crafting.yaml')
-      end
-    end
-  end
-
-  describe 'merge order verification' do
-    context 'setting override precedence' do
-      let(:files) do
-        {
-          'include-level2.yaml' => { shared: 'from_level2', level2_only: 'l2' },
-          'include-level1.yaml' => { include: ['level2'], shared: 'from_level1', level1_only: 'l1' }
-        }
-      end
-
-      it 'shallower include overrides deeper include' do
-        resolver = IncludeResolver.new(files)
-        order = resolver.resolve_includes_recursively(['include-level1.yaml'])
-        merged = order.reduce({}) do |result, filename|
-          data = files[filename] || {}
-          result.merge(data.reject { |k, _| k == :include })
-        end
-        expect(merged[:shared]).to eq('from_level1')
-        expect(merged[:level1_only]).to eq('l1')
-        expect(merged[:level2_only]).to eq('l2')
-      end
-    end
-  end
-end
-
-# --- Inlined Manager Functions ---
+# --- Bankbot ---
 
 RSpec.describe 'Bankbot Functions' do
   let(:ledger_path) { File.join(LICH_DIR, 'Testchar-ledger.yaml') }
@@ -590,6 +143,8 @@ def resolve_includes_recursively(filenames, visited = Set.new, include_order = [
   end
 end
 
+# --- Reportbot ---
+
 RSpec.describe 'Reportbot Functions' do
   let(:whitelist_path) { File.join(LICH_DIR, 'reportbot-whitelist.yaml') }
 
@@ -628,6 +183,8 @@ def resolve_includes_recursively(filenames, visited = Set.new, include_order = [
   end
 end
 
+# --- Slackbot ---
+
 RSpec.describe 'Slackbot Functions' do
   before do
     $slackbot_instance = nil
@@ -708,429 +265,97 @@ def resolve_includes_recursively(filenames, visited = Set.new, include_order = [
   end
 end
 
-# --- SHA Computation (build_version_hash) ---
-
-RSpec.describe 'SHA computation' do
-  # Replicates dependency's build_version_hash SHA computation:
-  #   body = File.binread(path)
-  #   sha = Digest::SHA1.hexdigest("blob #{body.size}\0#{body}")
-  # This must match git's blob SHA regardless of line endings.
-
-  let(:content_lf) { "line1\nline2\nline3\n" }
-  let(:content_crlf) { "line1\r\nline2\r\nline3\r\n" }
+# --- Utility helpers ---
 
-  def git_blob_sha(content)
-    Digest::SHA1.hexdigest("blob #{content.size}\0#{content}")
-  end
-
-  it 'produces consistent SHAs for LF files using binread' do
-    path = File.join(SCRIPT_DIR, 'test-lf.lic')
-    File.binwrite(path, content_lf)
-    body = File.binread(path)
-    expect(git_blob_sha(body)).to eq(git_blob_sha(content_lf))
-  ensure
-    File.delete(path) if File.exist?(path)
-  end
-
-  it 'produces consistent SHAs for CRLF files using binread' do
-    path = File.join(SCRIPT_DIR, 'test-crlf.lic')
-    File.binwrite(path, content_crlf)
-    body = File.binread(path)
-    expect(git_blob_sha(body)).to eq(git_blob_sha(content_crlf))
-  ensure
-    File.delete(path) if File.exist?(path)
-  end
-
-  it 'produces DIFFERENT SHAs for LF vs CRLF content (they are different bytes)' do
-    expect(git_blob_sha(content_lf)).not_to eq(git_blob_sha(content_crlf))
-  end
-
-  it 'would produce WRONG SHA if text-mode read were used on CRLF files' do
-    path = File.join(SCRIPT_DIR, 'test-crlf-textmode.lic')
-    File.binwrite(path, content_crlf)
-
-    # Text-mode read (the old buggy way) - translates CRLF to LF on read
-    text_body = File.open(path, 'r').readlines.join('')
-    git_blob_sha(text_body)
-
-    # Binary read (the correct way) - preserves bytes
-    bin_body = File.binread(path)
-    git_blob_sha(bin_body)
-
-    # On platforms that translate line endings (Windows), these would differ.
-    # On Unix they're the same because 'r' mode doesn't translate.
-    # The key point: binread always gives the correct SHA regardless of platform.
-    expect(git_blob_sha(bin_body)).to eq(git_blob_sha(content_crlf))
-  ensure
-    File.delete(path) if File.exist?(path)
-  end
-
-  it 'round-trip: write with wb then read with binread produces SHA matching original content' do
-    # This is the critical regression test: if we write with 'wb' and read
-    # with binread, the SHA of the round-tripped content must match the SHA
-    # of the original content (as GitHub would compute it).
-    # The regression in 2.4.7 was: writes used text mode ('w') which added
-    # CRLF on Windows, but reads used binread which preserved CRLF,
-    # producing a SHA that never matched GitHub's LF-based SHA.
-    original_content = content_lf # simulates what download_raw_file returns
-    path = File.join(SCRIPT_DIR, 'test-roundtrip.lic')
-
-    # Write the way dependency does (wb mode)
-    File.open(path, 'wb') { |file| file.print(original_content) }
-
-    # Read the way build_version_hash does (binread)
-    read_back = File.binread(path)
-
-    # SHA must match the original content's SHA
-    expect(git_blob_sha(read_back)).to eq(git_blob_sha(original_content))
-  ensure
-    File.delete(path) if File.exist?(path)
-  end
-
-  it 'round-trip: write with wb preserves LF line endings (no CRLF conversion)' do
-    path = File.join(SCRIPT_DIR, 'test-roundtrip-endings.lic')
-    File.open(path, 'wb') { |file| file.print(content_lf) }
-    read_back = File.binread(path)
-
-    # Content must be byte-identical - no line ending translation
-    expect(read_back).to eq(content_lf)
-    expect(read_back).not_to include("\r\n")
-  ensure
-    File.delete(path) if File.exist?(path)
-  end
-end
-
-RSpec.describe 'union_keys merge behavior' do
-  # Simulates the merge logic from SetupFiles#get_settings
-  def merge_with_union_keys(file_data_list)
-    # Peek pass: collect union_keys from all files
-    union_keys = file_data_list.reduce([]) do |keys, data|
-      file_keys = data['union_keys'] || []
-      (keys + file_keys).uniq
+RSpec.describe 'Utility Functions' do
+  describe '#format_name' do
+    it 'appends .lic if missing' do
+      expect(format_name('dependency')).to eq('dependency.lic')
     end
 
-    # Merge pass
-    file_data_list.reduce({}) do |result, data|
-      result.merge(data) do |key, old_val, new_val|
-        if union_keys.include?(key) && old_val.is_a?(Array) && new_val.is_a?(Array)
-          (old_val + new_val).uniq
-        else
-          new_val
-        end
-      end
+    it 'does not double-append .lic' do
+      expect(format_name('dependency.lic')).to eq('dependency.lic')
     end
   end
 
-  context 'when no union_keys defined' do
-    it 'overwrites arrays (existing behavior)' do
-      base = { 'autostarts' => %w[esp afk] }
-      char = { 'autostarts' => %w[healer] }
-      result = merge_with_union_keys([base, char])
-      expect(result['autostarts']).to eq(%w[healer])
+  describe '#format_yaml_name' do
+    it 'appends .yaml if missing' do
+      expect(format_yaml_name('base-spells')).to eq('base-spells.yaml')
     end
-  end
 
-  context 'when union_keys includes autostarts' do
-    it 'unions arrays from include and character files' do
-      include_file = { 'union_keys' => ['autostarts'], 'autostarts' => %w[esp afk textsubs] }
-      char_file = { 'autostarts' => %w[healer moonwatch] }
-      result = merge_with_union_keys([include_file, char_file])
-      expect(result['autostarts']).to match_array(%w[esp afk textsubs healer moonwatch])
+    it 'does not double-append .yaml' do
+      expect(format_yaml_name('base-spells.yaml')).to eq('base-spells.yaml')
     end
   end
 
-  context 'when union_keys defined in multiple files' do
-    it 'unions the union_keys themselves' do
-      base = { 'union_keys' => ['autostarts'], 'autostarts' => %w[esp], 'gear' => %w[backpack] }
-      include_file = { 'union_keys' => ['gear'], 'autostarts' => %w[afk], 'gear' => %w[sword] }
-      char = { 'autostarts' => %w[healer], 'gear' => %w[shield] }
-      result = merge_with_union_keys([base, include_file, char])
-      expect(result['autostarts']).to match_array(%w[esp afk healer])
-      expect(result['gear']).to match_array(%w[backpack sword shield])
+  describe '#verify_script' do
+    it 'returns false when script does not exist' do
+      expect(verify_script('nonexistent-script')).to be false
     end
-  end
 
-  context 'when union key value is not an array' do
-    it 'falls through to overwrite' do
-      base = { 'union_keys' => ['hometown'], 'hometown' => 'Crossing' }
-      char = { 'hometown' => 'Shard' }
-      result = merge_with_union_keys([base, char])
-      expect(result['hometown']).to eq('Shard')
+    it 'accepts an array of script names' do
+      expect(verify_script(%w[nonexistent1 nonexistent2])).to be false
     end
   end
 
-  context 'when union key only defined in one file' do
-    it 'keeps the value as-is' do
-      base = { 'union_keys' => ['autostarts'] }
-      char = { 'autostarts' => %w[healer moonwatch] }
-      result = merge_with_union_keys([base, char])
-      expect(result['autostarts']).to eq(%w[healer moonwatch])
-    end
-  end
+  describe '#shift_hometown' do
+    after { $HOMETOWN = nil }
 
-  context 'when union produces duplicates' do
-    it 'deduplicates the result' do
-      base = { 'union_keys' => ['autostarts'], 'autostarts' => %w[esp afk] }
-      char = { 'autostarts' => %w[afk healer] }
-      result = merge_with_union_keys([base, char])
-      expect(result['autostarts']).to match_array(%w[esp afk healer])
-      expect(result['autostarts'].length).to eq(3)
+    it 'sets the $HOMETOWN global' do
+      shift_hometown('Shard')
+      expect($HOMETOWN).to eq('Shard')
     end
   end
 
-  context 'with three-file cascade (base, include, character)' do
-    it 'unions across all three files' do
-      base = { 'union_keys' => ['autostarts'], 'autostarts' => %w[esp] }
-      include_file = { 'autostarts' => %w[afk textsubs] }
-      char = { 'autostarts' => %w[healer] }
-      result = merge_with_union_keys([base, include_file, char])
-      expect(result['autostarts']).to match_array(%w[esp afk textsubs healer])
-    end
-  end
-
-  context 'non-union keys remain unaffected' do
-    it 'overwrites non-union keys normally' do
-      base = { 'union_keys' => ['autostarts'], 'autostarts' => %w[esp], 'hometown' => 'Crossing' }
-      char = { 'autostarts' => %w[healer], 'hometown' => 'Shard' }
-      result = merge_with_union_keys([base, char])
-      expect(result['autostarts']).to match_array(%w[esp healer])
-      expect(result['hometown']).to eq('Shard')
+  describe '#clear_hometown' do
+    it 'clears the $HOMETOWN global' do
+      $HOMETOWN = 'Shard'
+      clear_hometown
+      expect($HOMETOWN).to be_nil
     end
   end
 end
 
-# --- Sentinel Gating ---
-# Validates structural integrity of the gated dependency.lic:
-# - Each sentinel gates an independent block
-# - No gate block nests another sentinel check
-# - Functions land in the correct gate (or outside all gates)
-# - Version string has been ticked
-
-DEP_SOURCE = File.read(dep_path)
-
-# Extracts the body of an `unless Lich::Common.const_defined?(:SENTINEL, false)` block.
-# Returns the indented content between the unless and its closing end.
-# Extracts all `unless Lich::Common.const_defined?(:SENTINEL, false)` blocks
-# that reference the given sentinel. Returns their bodies concatenated.
-# A single sentinel may gate multiple blocks (e.g. CORE_GET_SETTINGS gates
-# both the get_settings/get_data functions and the ScriptManager class).
-def extract_gate_block(source, sentinel_name)
-  opening = "unless Lich::Common.const_defined?(:#{sentinel_name}, false)\n"
-  bodies = []
-  pos = 0
-  while (idx = source.index(opening, pos))
-    rest = source[idx + opening.length..]
-    end_match = rest.match(/^end\s*#.*gate/)
-    raise "Could not find closing end for #{sentinel_name} gate at position #{idx}" unless end_match
-
-    bodies << rest[0...end_match.begin(0)]
-    pos = idx + opening.length + end_match.end(0)
-  end
-  raise "Could not find any gate block for #{sentinel_name}" if bodies.empty?
-
-  bodies.join("\n")
-end
-
-RSpec.describe 'Sentinel Gating Structure' do
-  describe 'gate block extraction' do
-    %w[CORE_GET_SETTINGS CORE_SCRIPT_LOADER CORE_MAP_OVERRIDES CORE_DR_STARTUP].each do |sentinel|
-      it "#{sentinel} gate block exists and is extractable" do
-        expect { extract_gate_block(DEP_SOURCE, sentinel) }.not_to raise_error
-      end
-    end
-  end
-
-  describe 'gate independence' do
-    let(:sentinels) { %w[CORE_GET_SETTINGS CORE_SCRIPT_LOADER CORE_MAP_OVERRIDES CORE_DR_STARTUP] }
-
-    it 'no gate block contains another sentinel check' do
-      sentinels.each do |sentinel|
-        block = extract_gate_block(DEP_SOURCE, sentinel)
-        other_sentinels = sentinels - [sentinel]
-        other_sentinels.each do |other|
-          expect(block).not_to include("const_defined?(:#{other}"),
-                               "#{sentinel} gate must not check #{other} -- gates must be independent"
-        end
-      end
-    end
-  end
-
-  describe 'CORE_GET_SETTINGS gate contents' do
-    let(:block) { extract_gate_block(DEP_SOURCE, 'CORE_GET_SETTINGS') }
-
-    it 'defines $setupfiles global' do
-      expect(block).to include('$setupfiles = SetupFiles.new')
-    end
-
-    it 'defines get_settings method' do
-      expect(block).to include('def get_settings')
-    end
-
-    it 'defines get_data method' do
-      expect(block).to include('def get_data')
-    end
-
-    it 'defines ScriptManager class (also gated by CORE_GET_SETTINGS)' do
-      expect(block).to include('class ScriptManager')
-    end
+# --- Version and structure ---
 
-    it 'defines $manager global' do
-      expect(block).to include('$manager = ScriptManager.new')
-    end
-
-    it 'defines ScriptManager-dependent helpers' do
-      expect(block).to include('def get_script(')
-      expect(block).to include('def force_refresh_scripts')
-      expect(block).to include('def list_tracked_scripts')
-      expect(block).to include('def setup_data')
-    end
-  end
-
-  describe 'CORE_SCRIPT_LOADER gate contents' do
-    let(:block) { extract_gate_block(DEP_SOURCE, 'CORE_SCRIPT_LOADER') }
-
-    it 'defines custom_require method returning a lambda' do
-      expect(block).to include('def custom_require')
-      expect(block).to include('lambda do')
-    end
-  end
-
-  describe 'CORE_MAP_OVERRIDES gate contents' do
-    let(:block) { extract_gate_block(DEP_SOURCE, 'CORE_MAP_OVERRIDES') }
-
-    it 'defines make_map_edits method' do
-      expect(block).to include('def make_map_edits')
-    end
-
-    it 'handles wayto overrides' do
-      expect(block).to include('base_wayto_overrides')
-      expect(block).to include('personal_wayto_overrides')
-    end
-
-    it 'handles personal map targets' do
-      expect(block).to include('personal_map_targets')
-    end
-  end
-
-  describe 'CORE_DR_STARTUP gate contents' do
-    let(:block) { extract_gate_block(DEP_SOURCE, 'CORE_DR_STARTUP') }
-
-    it 'checks ShowRoomID and MonsterBold flags' do
-      expect(block).to include('ShowRoomID')
-      expect(block).to include('MonsterBold')
-    end
-
-    it 'guards flag setup with UserVars.dependency_setflags' do
-      expect(block).to include('dependency_setflags')
-    end
-
-    it 'defines DR_OBSOLETE_SCRIPTS constant' do
-      expect(block).to include('DR_OBSOLETE_SCRIPTS')
-    end
-
-    it 'defines DR_OBSOLETE_DATA_FILES constant' do
-      expect(block).to include('DR_OBSOLETE_DATA_FILES')
-    end
-
-    it 'defines warn_obsolete_scripts method' do
-      expect(block).to include('def warn_obsolete_scripts')
-    end
-
-    it 'defines warn_obsolete_data_files method' do
-      expect(block).to include('def warn_obsolete_data_files')
-    end
-
-    it 'defines warn_custom_scripts method' do
-      expect(block).to include('def warn_custom_scripts')
-    end
-  end
-
-  describe 'CORE_AUTOSTART gate removed' do
-    it 'no longer contains CORE_AUTOSTART gate block' do
-      expect(DEP_SOURCE).not_to include('const_defined?(:CORE_AUTOSTART')
-    end
-
-    it 'no longer contains the autostart helpers gate comment' do
-      expect(DEP_SOURCE).not_to include('Autostart helpers gate')
-    end
-
-    it 'no longer references handle_obsolete_autostart anywhere' do
-      expect(DEP_SOURCE).not_to match(/\bhandle_obsolete_autostart/)
-    end
-
-    it 'no longer contains the perpetual merge into UserVars.autostart_scripts' do
-      expect(DEP_SOURCE).not_to include('UserVars.autostart_scripts = merged')
-    end
-
-    it 'no longer contains the zombie merge echo message' do
-      expect(DEP_SOURCE).not_to include('Merging global autostarts into character autostarts')
-    end
-  end
-
-  describe 'deprecated autostart helper stubs' do
-    it 'defines autostart() as a deprecation stub' do
-      expect(DEP_SOURCE).to match(/def autostart\(/)
-      expect(DEP_SOURCE).to include('DEPRECATED: autostart() has been removed')
-    end
-
-    it 'defines stop_autostart() as a deprecation stub' do
-      expect(DEP_SOURCE).to match(/def stop_autostart\(/)
-      expect(DEP_SOURCE).to include('DEPRECATED: stop_autostart() has been removed')
-    end
-
-    it 'defines dependency_status() as a deprecation stub' do
-      expect(DEP_SOURCE).to match(/def dependency_status/)
-      expect(DEP_SOURCE).to include('DEPRECATED: dependency_status() has been removed')
-    end
-
-    it 'points users to YAML autostarts or ;autostart add' do
-      expect(DEP_SOURCE).to include(';autostart add')
-      expect(DEP_SOURCE).to include(';autostart remove')
-      expect(DEP_SOURCE).to include(';autostart list')
+RSpec.describe 'Dependency Structure' do
+  describe 'version' do
+    it 'declares version 4.0.0' do
+      expect(DEP_SOURCE).to include("$DEPENDENCY_VERSION = '4.0.0'")
     end
 
-    it 'stubs do not modify UserVars.autostart_scripts' do
-      expect(DEP_SOURCE).not_to include('UserVars.autostart_scripts.push')
-      expect(DEP_SOURCE).not_to include('UserVars.autostart_scripts.delete')
+    it 'requires minimum lich version 5.17.2' do
+      expect(DEP_SOURCE).to include("$MIN_LICH_VERSION = '5.17.2'")
     end
   end
 
-  describe 'one-shot orphan cleanup of Settings autostart' do
-    it "clears Settings['autostart'] if present" do
-      expect(DEP_SOURCE).to include("Settings['autostart'] = nil")
+  describe 'removed gated code' do
+    it 'does not contain any sentinel gate blocks' do
+      expect(DEP_SOURCE).not_to include('const_defined?')
     end
 
-    it 'saves after clearing' do
-      cleanup_block = DEP_SOURCE[/if Settings\['autostart'\].*?end/m]
-      expect(cleanup_block).not_to be_nil
-      expect(cleanup_block).to include('Settings.save')
+    it 'does not define ArgParser class' do
+      expect(DEP_SOURCE).not_to include('class ArgParser')
     end
 
-    it 'is guarded by a conditional check on Settings key' do
-      expect(DEP_SOURCE).to match(/^if Settings\['autostart'\]/)
+    it 'does not define SetupFiles class' do
+      expect(DEP_SOURCE).not_to include('class SetupFiles')
     end
-  end
 
-  describe 'pre-existing gates' do
-    it 'CORE_ARGPARSER gate exists with inline fallback' do
-      expect(DEP_SOURCE).to match(/const_defined\?\(:CORE_ARGPARSER/)
-      expect(DEP_SOURCE).to include('class ArgParser')
+    it 'does not define ScriptManager class' do
+      expect(DEP_SOURCE).not_to include('class ScriptManager')
     end
 
-    it 'CORE_SETUPFILES gate exists with inline fallback' do
-      expect(DEP_SOURCE).to match(/const_defined\?\(:CORE_SETUPFILES/)
-      expect(DEP_SOURCE).to include('class SetupFiles')
+    it 'does not reference $manager' do
+      expect(DEP_SOURCE).not_to include('$manager')
     end
 
-    it 'does not define redundant top-level aliases (include Lich::Common handles it)' do
-      expect(DEP_SOURCE).not_to include('ArgParser = Lich::Common::ArgParser')
-      expect(DEP_SOURCE).not_to include('SetupFiles = Lich::Common::SetupFiles')
+    it 'does not reference $setupfiles' do
+      expect(DEP_SOURCE).not_to include('$setupfiles')
     end
   end
 
-  describe 'ungated runtime helpers' do
-    let(:runtime_marker) { DEP_SOURCE.index('# --- Runtime helpers') }
-
+  describe 'runtime helpers are present' do
     %w[
       save_bankbot_transaction
       load_bankbot_ledger
@@ -1144,42 +369,9 @@ def extract_gate_block(source, sentinel_name)
       shift_hometown
       clear_hometown
     ].each do |fn_name|
-      it "#{fn_name} is defined outside all gate blocks" do
-        fn_pos = DEP_SOURCE.index(/^def #{Regexp.escape(fn_name)}[\s(]?/)
-        expect(fn_pos).not_to be_nil, "Expected to find def #{fn_name}"
-        expect(fn_pos).to be > runtime_marker,
-                          "#{fn_name} should be after the runtime helpers section marker"
+      it "defines #{fn_name}" do
+        expect(DEP_SOURCE).to match(/^def #{Regexp.escape(fn_name)}[\s(]/)
       end
     end
   end
-
-  describe 'version' do
-    it 'has been ticked to 3.1.0' do
-      expect(DEP_SOURCE).to include("$DEPENDENCY_VERSION = '3.1.0'")
-    end
-
-    it 'requires minimum lich version 5.17.0' do
-      expect(DEP_SOURCE).to include("$MIN_LICH_VERSION = '5.17.0'")
-    end
-  end
-
-  describe 'boot sequence' do
-    it 'conditionally runs legacy ScriptManager boot' do
-      expect(DEP_SOURCE).to include('if defined?($manager)')
-    end
-
-    it 'calls map overrides in non-legacy path' do
-      expect(DEP_SOURCE).to match(/make_map_edits if/)
-    end
-
-    it 'reloads setupfiles cache' do
-      expect(DEP_SOURCE).to include('$setupfiles.reload if')
-    end
-
-    it 'calls warning functions conditionally' do
-      expect(DEP_SOURCE).to match(/warn_custom_scripts if/)
-      expect(DEP_SOURCE).to match(/warn_obsolete_scripts if/)
-      expect(DEP_SOURCE).to match(/warn_obsolete_data_files if/)
-    end
-  end
 end