rails-hyperdrive 0.8.0 → 0.9.0

data/lib/rails/hyperdrive/ancestor_locator.rb

@@ -2,6 +2,7 @@ require "bundler"
 require "rails/hyperdrive/bundler_artifact_discovery"
 require "rails/hyperdrive/drift_verdict"
 require "rails/hyperdrive/install_layout"
+require "rails/hyperdrive/lock_file"
 require "rails/hyperdrive/skill_template"
 
 module Rails
@@ -34,6 +35,40 @@ module Rails
         nil
       end
 
+      # The sha gate runs against the ancestor an entry records while its
+      # sidecar is pending, not against the entry's own source, which by then
+      # names the pending delivery.
+      def locate_recorded_ancestor(lock_entry, final_name: nil, gem_paths: Gem.path, resolved: nil)
+        return nil unless lock_entry&.ancestor?
+
+        locate(
+          kind: lock_entry.kind,
+          relpath: lock_entry.ancestor_relpath,
+          lock_entry: LockFile::Entry.new(
+            source_gem: lock_entry.ancestor_gem,
+            source_version: lock_entry.ancestor_version,
+            source_sha: lock_entry.ancestor_sha
+          ),
+          final_name: final_name || final_name_from_dest(lock_entry),
+          gem_paths: gem_paths,
+          resolved: resolved
+        )
+      rescue StandardError
+        nil
+      end
+
+      # Only the kinds whose frontmatter carries the name need one, and for
+      # those the dest was built from it.
+      def final_name_from_dest(lock_entry)
+        type = InstallLayout::ARTIFACT_TYPES[lock_entry.kind.to_s]
+        descriptor = type && InstallLayout.kind(type)
+        return nil unless descriptor&.collision_rewrites_name
+
+        descriptor.installed_name(lock_entry.path.to_s)
+      rescue StandardError
+        nil
+      end
+
       def read_candidate(gem_root, relpath, kind:, resolved:)
         exact = File.join(gem_root, relpath)
         if File.file?(exact)
@@ -67,7 +102,7 @@ module Rails
         nil
       end
 
-      private_class_method :read_candidate, :install_ready, :resolved_bundle
+      private_class_method :final_name_from_dest, :read_candidate, :install_ready, :resolved_bundle
     end
   end
 end

data/lib/rails/hyperdrive/artifact_status.rb

@@ -1,3 +1,4 @@
+require "rails/hyperdrive/config_file"
 require "rails/hyperdrive/drift_verdict"
 require "rails/hyperdrive/install_layout"
 require "rails/hyperdrive/install_plan"
@@ -28,16 +29,17 @@ module Rails
         end
       end
 
-      def self.compare(root:, artifacts:, bundled_gems: [])
-        new(root: root, artifacts: artifacts, bundled_gems: bundled_gems).tap(&:compare)
+      def self.compare(root:, artifacts:, bundled_gems: [], config: nil)
+        new(root: root, artifacts: artifacts, bundled_gems: bundled_gems, config: config).tap(&:compare)
       end
 
       attr_reader :entries
 
-      def initialize(root:, artifacts:, bundled_gems: [])
+      def initialize(root:, artifacts:, bundled_gems: [], config: nil)
         @root = File.expand_path(root.to_s)
         @artifacts = artifacts
         @bundled_gems = Array(bundled_gems).map(&:to_s)
+        @config = config
         @entries = []
       end
 
@@ -45,7 +47,7 @@ module Rails
         lock = LockFile.load(File.join(@root, InstallLayout::LOCK_PATH))
         offered = {}
 
-        InstallPlan.build(@artifacts, lock: lock).entries.each do |plan_entry|
+        InstallPlan.build(@artifacts, config: config).entries.each do |plan_entry|
           offered[plan_entry.dest] = [DriftVerdict.body_sha(plan_entry.install_ready_body), plan_entry.source_label, plan_entry.type]
           plan_entry.support_files.each do |file|
             offered[file[:dest]] = [DriftVerdict.body_sha(file[:body]), plan_entry.source_label, :skill_support]
@@ -71,7 +73,7 @@ module Rails
           # A disabled artifact left on disk was reported at install time; the
           # bundle still ships it, so it is not an orphan.
           type = InstallLayout::ARTIFACT_TYPES[locked.kind]
-          next if type && InstallPlan.disabled_dest?(lock, type, locked.path, source_gem: locked.source_gem)
+          next if type && InstallPlan.disabled_dest?(config, type, locked.path, source_gem: locked.source_gem)
 
           @entries << Entry.new(
             path: locked.path, state: :orphaned, artifact: locked.kind&.to_sym,
@@ -90,6 +92,12 @@ module Rails
       def stale?
         !missing.empty? || !outdated.empty? || !orphaned.empty?
       end
+
+      private
+
+      def config
+        @config ||= ConfigFile.load(File.join(@root, InstallLayout::CONFIG_PATH))
+      end
     end
   end
 end

data/lib/rails/hyperdrive/auto_install.rb

@@ -1,6 +1,7 @@
 require "bundler"
 require "rails/hyperdrive/artifact_status"
 require "rails/hyperdrive/bundler_artifact_discovery"
+require "rails/hyperdrive/config_file"
 require "rails/hyperdrive/install_layout"
 require "rails/hyperdrive/install_pipeline"
 require "rails/hyperdrive/install_shell"
@@ -14,7 +15,7 @@ module Rails
       DEVELOPMENT = "development".freeze
 
       Result = Struct.new(:installed, :outdated, :orphaned, :unwired, :advisories, :fence_warnings,
-        :halted, :skipped, :error, keyword_init: true) do
+        :config_warnings, :halted, :skipped, :error, keyword_init: true) do
         def ran?
           skipped.nil?
         end
@@ -27,7 +28,7 @@ module Rails
           return [] unless ran?
           return [halted] if halted
 
-          lines = []
+          lines = Array(config_warnings).dup
           unless Array(installed).empty?
             lines << "installed #{installed.size} artifact(s):"
             installed.each { |path| lines << "  #{path}" }
@@ -57,9 +58,14 @@ module Rails
         lock = LockFile.load(File.join(root, InstallLayout::LOCK_PATH))
         return halted(lock.schema_ahead_message(InstallLayout::LOCK_PATH)) if lock.schema_ahead?
 
+        config = ConfigFile.load(File.join(root, InstallLayout::CONFIG_PATH))
+        config_warnings = config.warnings.dup
+        config_warnings << lock.legacy_settings_message(InstallLayout::LOCK_PATH) if lock.legacy_settings?
+
         report = BundlerArtifactDiscovery::Report.new
-        artifacts = BundlerArtifactDiscovery.discover(enabled_gems: lock.enabled_gems, report: report)
-        status = ArtifactStatus.compare(root: root, artifacts: artifacts, bundled_gems: report.bundled_gems)
+        artifacts = BundlerArtifactDiscovery.discover(enabled_gems: config.enabled_gems, report: report)
+        status = ArtifactStatus.compare(root: root, artifacts: artifacts, bundled_gems: report.bundled_gems,
+          config: config)
 
         installed = []
         unwired = false
@@ -70,7 +76,8 @@ module Rails
             shell: InstallShell.new(root: root, io: io),
             artifacts: artifacts,
             mode: :additive,
-            report: report
+            report: report,
+            config: config
           )
           installed = pipeline.call.installed
           # This runs from a bundle install, which must not edit CLAUDE.md, so a
@@ -80,7 +87,8 @@ module Rails
         end
 
         Result.new(installed: installed, outdated: status.outdated, orphaned: status.orphaned,
-          unwired: unwired, advisories: report.advisories, fence_warnings: report.fence_warnings)
+          unwired: unwired, advisories: report.advisories, fence_warnings: report.fence_warnings,
+          config_warnings: config_warnings)
       rescue StandardError => e
         skip(:error, e)
       end
@@ -106,12 +114,13 @@ module Rails
 
       def skip(reason, error = nil)
         Result.new(installed: [], outdated: [], orphaned: [], advisories: [], fence_warnings: [],
-          skipped: reason, error: error)
+          config_warnings: [], skipped: reason, error: error)
       end
 
       # A completed run that installed nothing and has a reason to print.
       def halted(reason)
-        Result.new(installed: [], outdated: [], orphaned: [], advisories: [], fence_warnings: [], halted: reason)
+        Result.new(installed: [], outdated: [], orphaned: [], advisories: [], fence_warnings: [],
+          config_warnings: [], halted: reason)
       end
     end
   end

data/lib/rails/hyperdrive/bundler_artifact_discovery.rb

@@ -308,7 +308,7 @@ module Rails
 
         count = found.map { |p| File.dirname(p) }.uniq.size
         report.notices << "gem '#{spec.name}' ships #{count} skills.sh skill(s); add \"#{spec.name}\" to enabled: " \
-                          "in .hyperdrive/lock.yml and re-run bin/rails hyperdrive:sync to install them"
+                          "in #{InstallLayout::CONFIG_PATH} and re-run bin/rails hyperdrive:sync to install them"
       end
 
       # Frontmatter's schema is exactly name and description; any other key is

data/lib/rails/hyperdrive/config_file.rb

@@ -0,0 +1,135 @@
+require "yaml"
+require "rails/hyperdrive/install_layout"
+
+module Rails
+  module Hyperdrive
+    # The hand-owned settings file: which artifacts never to install, and which
+    # gems to treat as companions. Fail-open — a malformed part warns and reads
+    # as absent, and nothing raises.
+    class ConfigFile
+      DISABLED_KEYS = { skill: "skills", guideline: "guidelines", agent: "agents", command: "commands" }.freeze
+
+      attr_reader :path, :warnings, :resolve_command, :resolve_prompt
+
+      def self.load(path)
+        new(path).tap(&:read)
+      end
+
+      def initialize(path)
+        @path = path.to_s
+        @disabled = empty_disabled
+        @enabled = []
+        @warnings = []
+      end
+
+      def exist?
+        File.file?(@path)
+      end
+
+      def read
+        return self unless File.file?(@path)
+
+        data = YAML.safe_load(File.read(@path))
+        return self if data.nil?
+        return warn_and_empty("root is not a map; reading it as empty") unless data.is_a?(Hash)
+
+        read_disabled(data["disabled"])
+        read_enabled(data["enabled"])
+        read_resolve(data["resolve"])
+        self
+      rescue StandardError => e
+        warn_and_empty("could not be parsed (#{first_line(e.message)}); reading it as empty")
+      end
+
+      def disabled?(type, name)
+        Array(@disabled[type.to_sym]).include?(name.to_s)
+      end
+
+      def enabled_gems
+        @enabled
+      end
+
+      private
+
+      def read_disabled(raw)
+        return if raw.nil?
+        return report("disabled: must be a map of kind to list; ignoring it") unless raw.is_a?(Hash)
+
+        DISABLED_KEYS.each do |type, key|
+          value = raw[key]
+          next if value.nil?
+          unless value.is_a?(Array)
+            report("disabled: #{key}: must be a list of names; ignoring it")
+            next
+          end
+          @disabled[type] = normalize(value)
+        end
+      end
+
+      def read_resolve(raw)
+        return if raw.nil?
+        return report("resolve: must be a map; ignoring it") unless raw.is_a?(Hash)
+
+        @resolve_command = read_resolve_command(raw["command"])
+        @resolve_prompt = read_resolve_prompt(raw["prompt"])
+      end
+
+      def read_resolve_command(value)
+        return nil if value.nil?
+        return value.strip if value.is_a?(String) && !value.strip.empty?
+
+        report("resolve: command: must be a non-empty string; ignoring it")
+        nil
+      end
+
+      # The prompt is read relative to the app root; a path that escapes it is
+      # refused.
+      def read_resolve_prompt(value)
+        return nil if value.nil?
+        unless value.is_a?(String) && !value.strip.empty?
+          report("resolve: prompt: must be a non-empty string; ignoring it")
+          return nil
+        end
+
+        prompt = value.strip
+        if prompt.split("/").include?("..") || prompt.start_with?("/")
+          report("resolve: prompt: must be a path inside the app; ignoring it")
+          return nil
+        end
+        prompt
+      end
+
+      def read_enabled(raw)
+        return if raw.nil?
+        return report("enabled: must be a list of gem names; ignoring it") unless raw.is_a?(Array)
+
+        @enabled = normalize(raw)
+      end
+
+      def normalize(list)
+        list.map { |name| name.to_s.strip }.reject(&:empty?).uniq
+      end
+
+      def warn_and_empty(message)
+        report(message)
+        @disabled = empty_disabled
+        @enabled = []
+        @resolve_command = nil
+        @resolve_prompt = nil
+        self
+      end
+
+      def report(message)
+        @warnings << "#{InstallLayout::CONFIG_PATH} #{message}"
+      end
+
+      def first_line(message)
+        message.to_s.lines.first.to_s.strip
+      end
+
+      def empty_disabled
+        DISABLED_KEYS.keys.each_with_object({}) { |type, h| h[type] = [] }
+      end
+    end
+  end
+end

data/lib/rails/hyperdrive/install_layout.rb

@@ -11,6 +11,7 @@ module Rails
       COMMANDS_DIR = ".claude/commands".freeze
       INDEX_PATH = "#{HYPERDRIVE_DIR}/index.md".freeze
       LOCK_PATH = ".hyperdrive/lock.yml".freeze
+      CONFIG_PATH = ".hyperdrive/config.yml".freeze
 
       DEFAULT_TARGET = :claude
 

data/lib/rails/hyperdrive/install_pipeline.rb

@@ -3,6 +3,7 @@ require "time"
 require "rails/hyperdrive/ancestor_locator"
 require "rails/hyperdrive/bundler_artifact_discovery"
 require "rails/hyperdrive/claude_md_import"
+require "rails/hyperdrive/config_file"
 require "rails/hyperdrive/drift_verdict"
 require "rails/hyperdrive/three_way_merge"
 require "rails/hyperdrive/eager_footprint"
@@ -16,7 +17,8 @@ module Rails
     # The application root is explicit and no Rails constant is touched, so any
     # process that can see the bundle can run this.
     class InstallPipeline
-      ARTIFACT_DESTINATIONS = (InstallLayout.dest_roots + [InstallLayout::LOCK_PATH]).freeze
+      ARTIFACT_DESTINATIONS =
+        (InstallLayout.dest_roots + [InstallLayout::LOCK_PATH, InstallLayout::CONFIG_PATH]).freeze
 
       WARN_LINES = 150
       WARN_TOKENS = 1_500
@@ -26,7 +28,10 @@ module Rails
       Result = Struct.new(:installed, :updated, :unchanged, :skipped, :orphaned, :removed, :merged, :sidecars,
         keyword_init: true)
 
-      def initialize(root:, shell:, artifacts:, mode: :preserve, report: BundlerArtifactDiscovery::Report.new)
+      Sidecar = Struct.new(:dest, :ancestor, :previous_source, keyword_init: true)
+
+      def initialize(root:, shell:, artifacts:, mode: :preserve, report: BundlerArtifactDiscovery::Report.new,
+                     config: nil)
         raise ArgumentError, "unknown mode #{mode.inspect}" unless MODES.include?(mode)
 
         @root = File.expand_path(root.to_s)
@@ -34,6 +39,7 @@ module Rails
         @artifacts = artifacts
         @mode = mode
         @report = report
+        @config = config
         @bundled_gems = Array(report.bundled_gems).map(&:to_s)
         @skipped_gems = Array(report.skipped_gems).map(&:to_s)
         @result = Result.new(
@@ -44,7 +50,8 @@ module Rails
       def call
         return halt_schema_ahead if old_lock.schema_ahead?
 
-        @new_lock = LockFile.new(abs(InstallLayout::LOCK_PATH)).carry_settings(old_lock)
+        report_settings_warnings
+        @new_lock = LockFile.new(abs(InstallLayout::LOCK_PATH)).carry_document(old_lock)
         @plan = plan
 
         report_collisions
@@ -56,6 +63,7 @@ module Rails
         carry_orphans
         eager_guidelines = write_index_md(guidelines)
         write_claude_md(guidelines)
+        clear_resolved_ancestors
         write_lock
         print_warnings
         print_notices
@@ -82,7 +90,19 @@ module Rails
       end
 
       def build_result
-        @build_result ||= InstallPlan.build(@artifacts, lock: old_lock)
+        @build_result ||= InstallPlan.build(@artifacts, config: config)
+      end
+
+      def config
+        @config ||= ConfigFile.load(abs(InstallLayout::CONFIG_PATH))
+      end
+
+      def report_settings_warnings
+        return if additive?
+
+        config.warnings.each { |warning| @shell.say_status :warn, warning, :yellow }
+        return unless old_lock.legacy_settings?
+        @shell.say_status :warn, old_lock.legacy_settings_message(InstallLayout::LOCK_PATH), :yellow
       end
 
       def old_lock
@@ -120,7 +140,7 @@ module Rails
 
       def report_disabled
         build_result.disabled.each do |entry|
-          @shell.say_status :disabled, "#{entry.type} '#{entry.final_name}' (listed in #{InstallLayout::LOCK_PATH})", :blue
+          @shell.say_status :disabled, "#{entry.type} '#{entry.final_name}' (listed in #{InstallLayout::CONFIG_PATH})", :blue
         end
       end
 
@@ -239,56 +259,101 @@ module Rails
       # Reconciliation for a locally-modified destination in :sidecar/:merge
       # mode. The lock records the newest upstream *delivered* — installed
       # live, merged in, or written as a sidecar — never the live file's own
-      # hash, so the same upstream version is offered exactly once.
+      # hash, so the same upstream version is offered exactly once. While a
+      # sidecar is pending the entry also records the *ancestor*: the upstream
+      # the live file's own edits descend from, which a later run needs as the
+      # merge base.
       def reconcile_edited(write, old, source_relpath:, final_name:)
         dest = write[:dest]
         sidecar = InstallLayout.sidecar_path(dest)
+        pending = File.exist?(abs(sidecar))
+        pristine = pending && delivered_sidecar?(sidecar, delivered_shas(write, old))
 
         if old && old.source_sha == write[:gem_sha]
-          skip_edited(write, old)
-          if File.exist?(abs(sidecar))
-            @shell.say_status :warn, "#{sidecar} (unresolved sidecar; reconcile it with #{dest}, then delete it)", :yellow
-          end
-          return
+          return retry_pending(write, old, sidecar, pending: pending, pristine: pristine, final_name: final_name)
         end
 
         # An edited sidecar is user work: leave it, and leave the lock at the
         # old upstream so this delivery is re-offered once the user clears it.
-        if File.exist?(abs(sidecar)) && !delivered_sidecar?(sidecar, delivered_shas(write, old))
+        if pending && !pristine
           @result.skipped << dest
           @shell.say_status :warn, "#{sidecar} (sidecar locally modified; resolve or delete it)", :yellow
           @new_lock.carry(old) if old
           return
         end
 
+        deliver(write, old, pending: pending, source_relpath: source_relpath, final_name: final_name)
+      end
+
+      # Nothing new to deliver: the pending sidecar is still the standing
+      # offer, so --merge attempts to complete it rather than re-offering it.
+      def retry_pending(write, old, sidecar, pending:, pristine:, final_name:)
         reason = nil
-        if merge_mode?
-          if File.exist?(abs(sidecar))
-            # A pending sidecar means the last delivered upstream never reached
-            # the live file, so the reconstructable ancestor is stale; merging
-            # over it would silently revert that delivery.
-            reason = "previous delivery still unresolved"
-          else
-            merged, reason = attempt_merge(write, old, source_relpath: source_relpath, final_name: final_name)
-            if merged
-              write_merged(write, merged)
-              sweep_sidecar(write, old)
-              return
-            end
+        if merge_mode? && pristine
+          ancestor = AncestorLocator.locate_recorded_ancestor(old, final_name: final_name)
+          merged, reason = ancestor ? merge_bodies(write, ancestor) : [nil, "ancestor unavailable"]
+          if merged
+            write_merged(write, merged)
+            sweep_sidecar(write, old)
+            return
           end
         end
 
-        write_sidecar(write, reason)
+        skip_edited(write, old)
+        return unless pending
+
+        message = "#{sidecar} (unresolved sidecar; reconcile it with #{write[:dest]}, then delete it"
+        message += "; #{reason}" if reason
+        @shell.say_status :warn, "#{message})", :yellow
       end
 
-      def attempt_merge(write, old, source_relpath:, final_name:)
-        return [nil, "no previous install recorded"] unless old
+      # The ancestor is the live file's own base, so a delivery landing on top
+      # of a pending one keeps the ancestor already recorded.
+      def deliver(write, old, pending:, source_relpath:, final_name:)
+        if pending
+          record = recorded_ancestor(old)
+          ancestor = AncestorLocator.locate_recorded_ancestor(old, final_name: final_name)
+          previous_source = old&.ancestor_label
+          reason = "ancestor unavailable" if merge_mode? && ancestor.nil?
+        else
+          record = fresh_ancestor(old, source_relpath)
+          ancestor = locate_ancestor(write, old, source_relpath: source_relpath, final_name: final_name)
+          previous_source = old&.source_label
+          reason = fresh_merge_reason(old, ancestor) if merge_mode?
+        end
 
-        ancestor = AncestorLocator.locate(
-          kind: write[:artifact_kind], relpath: source_relpath, lock_entry: old, final_name: final_name
-        )
-        return [nil, "#{old.source_label} not found in installed gems"] unless ancestor
+        if merge_mode? && ancestor
+          merged, reason = merge_bodies(write, ancestor)
+          if merged
+            write_merged(write, merged)
+            sweep_sidecar(write, old)
+            return
+          end
+        end
+
+        write_sidecar(write, reason, ancestor: ancestor, previous_source: previous_source, ancestor_record: record)
+      end
+
+      def fresh_merge_reason(old, ancestor)
+        return "no previous install recorded" unless old
+        return "#{old.source_label} not found in installed gems" unless ancestor
+        nil
+      end
 
+      # A fresh delivery always reads the ancestor off the entry's own source,
+      # never off ancestor keys left over from a window that already closed.
+      def fresh_ancestor(old, source_relpath)
+        return nil unless old && source_relpath
+        { gem: old.source_gem, version: old.source_version, sha: old.source_sha, relpath: source_relpath }
+      end
+
+      def recorded_ancestor(old)
+        return nil unless old&.ancestor?
+        { gem: old.ancestor_gem, version: old.ancestor_version, sha: old.ancestor_sha,
+          relpath: old.ancestor_relpath }
+      end
+
+      def merge_bodies(write, ancestor)
         ours = live_body(write)
         if ours.nil? || [ours, ancestor, write[:body]].any? { |b| ThreeWayMerge.binary?(b) }
           return [nil, "binary content"]
@@ -302,6 +367,16 @@ module Rails
         end
       end
 
+      # Reconstruction is sha-gated against the lock entry recorded before this
+      # run, so it must happen before the new upstream is locked.
+      def locate_ancestor(write, old, source_relpath:, final_name:)
+        return nil unless old
+
+        AncestorLocator.locate(
+          kind: write[:artifact_kind], relpath: source_relpath, lock_entry: old, final_name: final_name
+        )
+      end
+
       def live_body(write)
         file = abs(write[:dest])
         return File.binread(file) if write[:type] == :skill_support
@@ -320,14 +395,14 @@ module Rails
       # The sidecar is byte-identical to what a live install of the new
       # upstream would write, so `mv <dest>.new <dest>` accepts it wholesale
       # and the lock already verifies it.
-      def write_sidecar(write, reason)
+      def write_sidecar(write, reason, ancestor: nil, previous_source: nil, ancestor_record: nil)
         sidecar = InstallLayout.sidecar_path(write[:dest])
         @shell.create_file sidecar, write[:body]
-        @result.sidecars << write[:dest]
+        @result.sidecars << Sidecar.new(dest: write[:dest], ancestor: ancestor, previous_source: previous_source)
         message = "#{write[:dest]} (locally modified; new upstream delivered to #{sidecar}"
         message += "; #{reason}" if reason
         @shell.say_status :sidecar, "#{message})", :yellow
-        upsert_lock(write, Time.now.utc)
+        upsert_lock(write, Time.now.utc, ancestor: ancestor_record)
       end
 
       # Only a machine-pristine sidecar — one still hashing to a delivered
@@ -387,17 +462,33 @@ module Rails
         )
       end
 
-      def upsert_lock(write, installed_at)
+      def upsert_lock(write, installed_at, ancestor: nil)
         @new_lock.upsert(
           path: write[:dest],
           kind: write[:artifact_kind],
           source_gem: write[:source_gem],
           source_version: write[:version],
           source_sha: write[:gem_sha],
-          installed_at: installed_at.iso8601
+          installed_at: installed_at.iso8601,
+          ancestor_gem: ancestor && ancestor[:gem],
+          ancestor_version: ancestor && ancestor[:version],
+          ancestor_sha: ancestor && ancestor[:sha],
+          ancestor_relpath: ancestor && ancestor[:relpath]
         )
       end
 
+      # Deleting <dest>.new is the only resolution signal, so a recorded
+      # ancestor stays until the run that finds the sidecar gone drops it.
+      def clear_resolved_ancestors
+        return if additive?
+
+        @new_lock.each_entry do |entry|
+          next unless entry.ancestor?
+          next if File.exist?(abs(InstallLayout.sidecar_path(entry.path)))
+          @new_lock.clear_ancestor(entry.path)
+        end
+      end
+
       # The pipeline's only delete path, so it is gated on the file still
       # matching the content the lock recorded: hand-edited work is reported and
       # left for its owner to remove. The dest's sidecar goes with it, since
@@ -426,7 +517,7 @@ module Rails
           type = InstallLayout::ARTIFACT_TYPES[entry.kind]
           next unless type
           next if @new_lock.entry(entry.path)
-          next unless InstallPlan.disabled_dest?(old_lock, type, entry.path, source_gem: entry.source_gem)
+          next unless InstallPlan.disabled_dest?(config, type, entry.path, source_gem: entry.source_gem)
 
           remove_or_carry(entry) { "disabled but locally modified; delete it by hand" }
         end

data/lib/rails/hyperdrive/install_plan.rb

@@ -53,7 +53,7 @@ module Rails
       # disables every variant and a postfixed name disables just one. The
       # postfixed form is honored whether or not a collision exists today, so
       # the opt-out survives a collision appearing or resolving.
-      def build(artifacts, lock: nil)
+      def build(artifacts, config: nil)
         result = Result.new(entries: [], disabled: [])
         artifacts.group_by { |a| [a.artifact_type, a.name] }.each do |(type, name), group|
           collision = group.size > 1
@@ -66,8 +66,8 @@ module Rails
               dest: InstallLayout.dest_for(type, final_name),
               collision: collision
             )
-            dropped = lock && (lock.disabled?(type, name) ||
-                               lock.disabled?(type, InstallLayout.postfixed_name(name, artifact.source_gem)))
+            dropped = config && (config.disabled?(type, name) ||
+                                 config.disabled?(type, InstallLayout.postfixed_name(name, artifact.source_gem)))
             (dropped ? result.disabled : result.entries) << entry
           end
         end
@@ -77,13 +77,13 @@ module Rails
       # A supporting file is disabled through its owning skill's name. Given the
       # installing gem, a canonically-installed file also answers to the
       # postfixed name that disabled it while it was one of several variants.
-      def disabled_dest?(lock, type, dest, source_gem: nil)
+      def disabled_dest?(config, type, dest, source_gem: nil)
         name = InstallLayout.installed_name(type, dest)
         return false unless name
         lookup = type == :skill_support ? :skill : type
         base = InstallLayout.base_name(name)
-        return true if lock.disabled?(lookup, name) || lock.disabled?(lookup, base)
-        !source_gem.nil? && lock.disabled?(lookup, InstallLayout.postfixed_name(base, source_gem))
+        return true if config.disabled?(lookup, name) || config.disabled?(lookup, base)
+        !source_gem.nil? && config.disabled?(lookup, InstallLayout.postfixed_name(base, source_gem))
       end
     end
   end