rails-hyperdrive 0.3.0 → 0.5.0

data/lib/rails/hyperdrive/ancestor_locator.rb

@@ -0,0 +1,76 @@
+require "bundler"
+require "rails/hyperdrive/bundler_artifact_discovery"
+require "rails/hyperdrive/drift_verdict"
+require "rails/hyperdrive/skill_template"
+
+module Rails
+  module Hyperdrive
+    # Best-effort reconstruction of the install-ready body an artifact had at
+    # the gem version a lock entry records, read from installed gem
+    # directories. The result is sha-gated against the lock entry: anything
+    # that does not rebuild to exactly the recorded bytes counts as
+    # unavailable.
+    module AncestorLocator
+      module_function
+
+      # Never raises; any failure returns nil (ancestor unavailable).
+      def locate(kind:, relpath:, lock_entry:, final_name: nil, gem_paths: Gem.path, resolved: nil)
+        return nil unless lock_entry&.source_gem && lock_entry.source_version && lock_entry.source_sha
+        return nil if relpath.nil? || relpath.to_s.empty?
+
+        Array(gem_paths).each do |home|
+          gem_root = File.join(home.to_s, "gems", "#{lock_entry.source_gem}-#{lock_entry.source_version}")
+          body = read_candidate(gem_root, relpath.to_s, kind: kind, resolved: resolved)
+          next unless body
+
+          ready = install_ready(body, kind: kind, final_name: final_name)
+          return ready if DriftVerdict.body_sha(ready) == lock_entry.source_sha
+        rescue StandardError
+          next
+        end
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def read_candidate(gem_root, relpath, kind:, resolved:)
+        exact = File.join(gem_root, relpath)
+        if File.file?(exact)
+          return kind.to_s == "skill_support" ? File.binread(exact) : File.read(exact)
+        end
+        return nil unless relpath.end_with?(".md")
+
+        twin = "#{exact}.erb"
+        return nil unless File.file?(twin)
+
+        map = resolved || resolved_bundle
+        return nil unless map
+        SkillTemplate.render(File.read(twin), resolved: map)
+      end
+
+      def install_ready(body, kind:, final_name:)
+        case kind.to_s
+        when "skill"
+          ready = BundlerArtifactDiscovery.install_ready_body(
+            BundlerArtifactDiscovery::Artifact.new(artifact_type: :skill, body: body)
+          )
+          final_name ? ready.sub(/^name:\s*.+$/, "name: #{final_name}") : ready
+        when "guideline"
+          BundlerArtifactDiscovery.install_ready_body(
+            BundlerArtifactDiscovery::Artifact.new(artifact_type: :guideline, body: body)
+          )
+        else
+          body
+        end
+      end
+
+      def resolved_bundle
+        ::Bundler.load.specs.to_a.each_with_object({}) { |s, h| h[s.name.to_s] = s.version }
+      rescue StandardError
+        nil
+      end
+
+      private_class_method :read_candidate, :install_ready, :resolved_bundle
+    end
+  end
+end

data/lib/rails/hyperdrive/artifact_status.rb

@@ -15,7 +15,7 @@ module Rails
           case state
           when :missing  then "#{path} (from #{bundle_source})"
           when :outdated then "#{path} (#{locked_source} → #{bundle_source})"
-          when :orphaned then "#{path} (source #{locked_source} no longer in bundle)"
+          when :orphaned then "#{path} (no longer shipped by #{locked_source})"
           else path
           end
         end

data/lib/rails/hyperdrive/auto_install.rb

@@ -4,6 +4,7 @@ require "rails/hyperdrive/bundler_artifact_discovery"
 require "rails/hyperdrive/install_layout"
 require "rails/hyperdrive/install_pipeline"
 require "rails/hyperdrive/install_shell"
+require "rails/hyperdrive/lock_file"
 
 module Rails
   module Hyperdrive
@@ -46,7 +47,8 @@ module Rails
         return skip(:not_development) unless development?(env)
         return skip(:not_initialized) unless File.exist?(File.join(root, InstallLayout::LOCK_PATH))
 
-        artifacts = BundlerArtifactDiscovery.discover
+        enabled = LockFile.load(File.join(root, InstallLayout::LOCK_PATH)).enabled_gems
+        artifacts = BundlerArtifactDiscovery.discover(enabled_gems: enabled)
         status = ArtifactStatus.compare(root: root, artifacts: artifacts)
 
         installed = []

data/lib/rails/hyperdrive/bundler_artifact_discovery.rb

@@ -1,5 +1,6 @@
 require "yaml"
 require "bundler"
+require "rails/hyperdrive/gem_manifest"
 require "rails/hyperdrive/skill_template"
 
 module Rails
@@ -10,6 +11,7 @@ module Rails
       Artifact = Struct.new(
         :name, :description, :target_gem, :versions, :artifact_type,
         :source_gem, :path, :body, :spec_version, :support_files,
+        :source_root, :support_root,
         keyword_init: true
       ) do
         def skill?
@@ -32,17 +34,30 @@ module Rails
       module_function
 
       # Non-fatal problems are appended to `warnings` and the artifact is
-      # dropped; discovery never raises.
-      def discover(specs: nil, warnings: [])
+      # dropped; discovery never raises. A gem that has not opted in as a
+      # companion is never scanned — its skills.sh content is only reported
+      # through `notices`.
+      def discover(specs: nil, warnings: [], enabled_gems: [], notices: [])
         specs ||= safe_bundler_specs
+        enabled = Array(enabled_gems).map(&:to_s)
         resolved = specs.each_with_object({}) { |s, h| h[s.name.to_s] = s.version }
 
         candidates = []
         specs.each do |spec|
-          each_artifact_path(spec, warnings: warnings) do |path, type|
-            artifact = parse(path, source_spec: spec, type: type, resolved: resolved, warnings: warnings)
+          unless opted_in?(spec, enabled_gems: enabled)
+            notice_skills_sh_content(spec, notices: notices)
+            next
+          end
+          manifest = GemManifest.load(spec, warnings: warnings)
+          seen = { skill: [], guideline: [] }
+          each_artifact_path(spec, warnings: warnings) do |path, type, support_root, key|
+            seen[type] << key
+            gate = type == :skill ? manifest.skill_gate(key) : manifest.guideline_gate(key)
+            artifact = parse(path, source_spec: spec, type: type, resolved: resolved,
+              warnings: warnings, support_root: support_root, gate: gate)
             candidates << artifact if artifact
           end
+          warn_unknown_manifest_keys(manifest, spec, seen, warnings)
         end
 
         # Collapse same-name variants within one source gem (highest
@@ -53,22 +68,97 @@ module Rails
         end
       end
 
+      # Yields each candidate with its manifest join key: a skill's relpath
+      # from its skills root, a guideline's filename. Keys are collected before
+      # parsing, so a candidate later dropped (e.g. an ERB render failure)
+      # still counts as known to the manifest.
       def each_artifact_path(spec, warnings: [])
-        skill_paths(spec, warnings: warnings).each { |p| yield p, :skill }
-        guideline_paths(spec).each { |p| yield p, :guideline }
+        skill_paths(spec, warnings: warnings).each { |path, support_root, rel| yield path, :skill, support_root, rel }
+        guideline_paths(spec).each { |p| yield p, :guideline, nil, File.basename(p) }
+      end
+
+      # The staleness signal for gating detached from content: an entry
+      # matching nothing means a renamed or removed skill dir/guideline.
+      def warn_unknown_manifest_keys(manifest, spec, seen, warnings)
+        (manifest.skill_keys - seen[:skill]).each do |key|
+          warnings << "#{spec.name}: manifest skills entry '#{key}' names no shipped skill directory"
+        end
+        (manifest.guideline_keys - seen[:guideline]).each do |key|
+          warnings << "#{spec.name}: manifest guidelines entry '#{key}' names no shipped guideline"
+        end
       end
 
       def skill_paths(spec, warnings: [])
-        roots = [File.join(spec.full_gem_path, "lib", spec.name, "hyperdrive", "skills")]
+        roots = [
+          File.join(spec.full_gem_path, "lib", spec.name, "hyperdrive", "skills"),
+          File.join(spec.full_gem_path, "skills")
+        ]
         if (override = skills_dir_override(spec))
           roots << File.join(spec.full_gem_path, override)
         end
-        found = roots.flat_map { |root| Dir.glob(File.join(root, "**", "{SKILL.md,SKILL.md.erb}")) }.uniq
-        found.group_by { |p| File.dirname(p) }.flat_map do |dir, group|
-          next group unless group.size > 1
-          warnings << "skip #{File.join(dir, "SKILL.md.erb")}: SKILL.md in the same directory takes precedence"
-          group.select { |p| File.basename(p) == "SKILL.md" }
+
+        candidates = []
+        seen = {}
+        roots.each do |root|
+          Dir.glob(File.join(root, "**", "{SKILL.md,SKILL.md.erb}"))
+             .group_by { |p| File.dirname(p) }.each do |dir, group|
+            next if seen[File.expand_path(dir)]
+            seen[File.expand_path(dir)] = true
+            candidates << {
+              dir: dir,
+              rel: dir.delete_prefix(root).delete_prefix("/"),
+              path: resolve_same_dir_tie(dir, group, warnings)
+            }
+          end
         end
+
+        pair_with_templates(candidates, spec, warnings: warnings)
+      end
+
+      def resolve_same_dir_tie(dir, group, warnings)
+        return group.first unless group.size > 1
+        warnings << "skip #{File.join(dir, "SKILL.md.erb")}: SKILL.md in the same directory takes precedence"
+        group.find { |p| File.basename(p) == "SKILL.md" }
+      end
+
+      # A dir holding a static SKILL.md pairs with <templates root>/<same
+      # relative path>/SKILL.md.erb in a distinct dir: the rendered template is
+      # the definition, the static dir the support root. The static SKILL.md is
+      # never parsed — falling back to it when the template fails to render
+      # would silently un-condition the skill.
+      def pair_with_templates(candidates, spec, warnings:)
+        templates_root = File.join(spec.full_gem_path, skill_templates_dir(spec))
+
+        pairs = {}
+        candidates.each do |cand|
+          next unless File.basename(cand[:path]) == "SKILL.md"
+          template_dir = File.expand_path(File.join(templates_root, cand[:rel]))
+          next if template_dir == File.expand_path(cand[:dir])
+          template = File.join(template_dir, "SKILL.md.erb")
+          next unless File.file?(template)
+          warn_template_extras(template_dir, warnings)
+          pairs[cand[:dir]] = { template: template, template_dir: template_dir }
+        end
+
+        consumed = pairs.values.map { |p| p[:template_dir] }
+        candidates.filter_map do |cand|
+          if (pair = pairs[cand[:dir]])
+            [pair[:template], cand[:dir], cand[:rel]]
+          elsif consumed.include?(File.expand_path(cand[:dir]))
+            nil
+          else
+            [cand[:path], File.dirname(cand[:path]), cand[:rel]]
+          end
+        end
+      end
+
+      # The content dir is the single source of truth for supporting files.
+      def warn_template_extras(template_dir, warnings)
+        extras = Dir.glob(File.join(template_dir, "**", "*"))
+                    .select { |f| File.file?(f) && f != File.join(template_dir, "SKILL.md.erb") }
+        return if extras.empty?
+        warnings << "#{template_dir}: ignoring #{extras.size} file(s) besides SKILL.md.erb; " \
+                    "supporting files ship in the paired content directory"
       end
 
       def guideline_paths(spec)
@@ -76,6 +166,39 @@ module Rails
         Dir.glob(File.join(root, "*.md"))
       end
 
+      # Many gemspecs package files via `git ls-files`, so a contributor-facing
+      # skills/ dir ships by accident — package contents don't signal consumer
+      # intent. Only an explicit signal makes a gem's content installable.
+      def opted_in?(spec, enabled_gems:)
+        return true if enabled_gems.include?(spec.name.to_s)
+        return true if metadata_present?(spec, "rails_hyperdrive_skills_dir")
+        return true if metadata_present?(spec, "rails_hyperdrive_skill_templates_dir")
+        return true if metadata_present?(spec, "rails_hyperdrive_targets")
+        return true if GemManifest.opt_in?(spec)
+
+        convention_root = File.join(spec.full_gem_path, "lib", spec.name, "hyperdrive")
+        Dir.glob(File.join(convention_root, "skills", "**", "{SKILL.md,SKILL.md.erb}")).any? ||
+          Dir.glob(File.join(convention_root, "guidelines", "*.md")).any?
+      end
+
+      def metadata_present?(spec, key)
+        return false unless spec.respond_to?(:metadata)
+        raw = spec.metadata && spec.metadata[key]
+        !raw.to_s.strip.empty?
+      end
+
+      # Report-only, glob-only (no file reads): SKILL.md presence is the
+      # signal, and SKILL.md.erb is excluded — raw ERB is not skills.sh
+      # content. Parse problems surface as warnings once the gem is enabled.
+      def notice_skills_sh_content(spec, notices:)
+        found = Dir.glob(File.join(spec.full_gem_path, "skills", "**", "SKILL.md"))
+        return if found.empty?
+
+        count = found.map { |p| File.dirname(p) }.uniq.size
+        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"
+      end
+
       # ".." segments are rejected to prevent escaping the gem root.
       def skills_dir_override(spec)
         return nil unless spec.respond_to?(:metadata)
@@ -85,7 +208,19 @@ module Rails
         raw.to_s
       end
 
-      def parse(path, source_spec:, type:, resolved:, warnings:)
+      def skill_templates_dir(spec)
+        default = File.join("lib", spec.name, "hyperdrive", "skills")
+        return default unless spec.respond_to?(:metadata)
+        raw = spec.metadata && spec.metadata["rails_hyperdrive_skill_templates_dir"]
+        return default if raw.nil? || raw.to_s.strip.empty?
+        return default if raw.to_s.split(%r{[/\\]}).include?("..")
+        raw.to_s
+      end
+
+      # Frontmatter's schema is exactly name and description; any other key is
+      # unknown to the parser and rides untouched in the installed body.
+      def parse(path, source_spec:, type:, resolved:, warnings:, gate:, support_root: nil)
+        support_root ||= File.dirname(path)
         body = File.read(path)
         if erb_template?(path)
           begin
@@ -101,25 +236,20 @@ module Rails
           return nil
         end
 
-        meta        = YAML.safe_load(frontmatter, permitted_classes: [Symbol]) || {}
+        # Date is permitted because unknown frontmatter keys are user content;
+        # a bare date value must not fail the parse.
+        meta        = YAML.safe_load(frontmatter, permitted_classes: [Symbol, Date]) || {}
         name        = meta["name"]
         description = meta["description"]
-        versions    = meta["versions"]
-
-        unless name && description && meta["gem"] && versions
-          warnings << "skip #{path}: missing a required field (name, description, gem, versions)"
-          return nil
-        end
 
-        targets = parse_targets(meta["gem"])
-        if targets.nil? || targets.empty?
-          warnings << "skip #{name} (from #{source_spec.name}): gem: must name a gem, a comma-separated list, or a YAML list"
+        unless name && description
+          warnings << "skip #{path}: missing a required field (name, description)"
           return nil
         end
 
-        matched = match_targets(targets, versions, resolved)
+        matched = match_targets(gate.targets, gate.versions, resolved)
         if matched.empty?
-          warnings << "skip #{name} (from #{source_spec.name}): #{no_match_reason(targets, versions, resolved)}"
+          warnings << "skip #{name} (from #{source_spec.name}): #{no_match_reason(gate.targets, gate.versions, resolved)}"
           return nil
         end
 
@@ -127,16 +257,18 @@ module Rails
           name: name.to_s,
           description: description.to_s,
           target_gem: matched,
-          versions: versions,
+          versions: gate.versions,
           artifact_type: type,
           source_gem: source_spec.name.to_s,
           path: path,
           body: body,
           spec_version: source_spec.version.to_s,
+          source_root: source_spec.full_gem_path.to_s,
+          support_root: support_root,
           support_files:
             if type == :skill
               conditioned_support_files(
-                File.dirname(path), meta["conditional"],
+                support_root, gate.conditional,
                 resolved: resolved, warnings: warnings,
                 label: "#{name} (from #{source_spec.name})"
               )
@@ -144,7 +276,7 @@ module Rails
               []
             end
         )
-      rescue Psych::SyntaxError
+      rescue Psych::Exception
         warnings << "skip #{path}: malformed YAML frontmatter"
         nil
       end
@@ -182,7 +314,7 @@ module Rails
         shipped = files.map { |f| f[:path] }
         conditions.each_key do |key|
           if SKILL_FILE_NAMES.include?(key)
-            warnings << "#{label}: conditional key '#{key}' ignored; the skill's own gem:/versions: gate the whole skill"
+            warnings << "#{label}: conditional key '#{key}' ignored; the entry's own gem:/versions: gate the whole skill"
           elsif !shipped.include?(key)
             warnings << "#{label}: conditional key '#{key}' names no shipped supporting file"
           end
@@ -200,14 +332,14 @@ module Rails
           return true
         end
 
-        targets = entry["gem"] && parse_targets(entry["gem"])
+        targets = entry["gem"] && GemManifest.parse_targets(entry["gem"])
         if targets.nil? || targets.empty?
           warnings << "#{label}: conditional entry for '#{key}' needs gem: naming a gem, a comma-separated list, or a YAML list; installing the file"
           return true
         end
 
         versions = entry["versions"]
-        if malformed_requirements?(versions)
+        if GemManifest.malformed_requirements?(versions)
           warnings << "#{label}: conditional entry for '#{key}' has an unparsable versions: requirement; installing the file"
           return true
         end
@@ -215,20 +347,6 @@ module Rails
         match_targets(targets, versions, resolved).any?
       end
 
-      # versions: is optional in a conditional entry; nil means unconstrained.
-      def malformed_requirements?(versions)
-        requirements = versions.is_a?(Hash) ? versions.values : [versions]
-        requirements.compact.any? do |req|
-          parts = Array(req).flat_map { |s| s.is_a?(String) ? s.split(",").map(&:strip) : s }
-          begin
-            Gem::Requirement.new(*parts)
-            false
-          rescue ArgumentError
-            true
-          end
-        end
-      end
-
       def render_support_templates(files, skill_dir, resolved:, warnings:)
         plain_paths = files.map { |f| f[:path] }
         files.filter_map do |file|
@@ -253,6 +371,8 @@ module Rails
         path.end_with?(".md.erb")
       end
 
+      # Guideline frontmatter is stripped because the installed file is
+      # @-included eagerly into agent context, where it would be inert noise.
       def install_ready_body(artifact)
         return artifact.body if artifact.skill?
 
@@ -271,12 +391,6 @@ module Rails
         [lines[1...absolute_closing].join, lines[(absolute_closing + 1)..].join]
       end
 
-      def parse_targets(raw)
-        entries = raw.is_a?(Array) ? raw : [raw]
-        return nil if entries.any? { |e| e.nil? || e.is_a?(Array) || e.is_a?(Hash) }
-        entries.flat_map { |e| e.to_s.split(",") }.map(&:strip).reject(&:empty?)
-      end
-
       def match_targets(targets, versions, resolved)
         return ["*"] if targets.include?("*")
 
@@ -308,12 +422,15 @@ module Rails
         []
       end
 
-      private_class_method :each_artifact_path, :skill_paths, :guideline_paths,
-                           :skills_dir_override, :parse, :support_files_for,
+      private_class_method :each_artifact_path, :warn_unknown_manifest_keys, :skill_paths,
+                           :guideline_paths,
+                           :resolve_same_dir_tie, :pair_with_templates, :warn_template_extras,
+                           :opted_in?, :metadata_present?, :notice_skills_sh_content,
+                           :skills_dir_override, :skill_templates_dir, :parse, :support_files_for,
                            :conditioned_support_files, :apply_conditional_filter,
-                           :conditional_satisfied?, :malformed_requirements?,
+                           :conditional_satisfied?,
                            :render_support_templates, :erb_template?,
-                           :split_frontmatter, :parse_targets, :match_targets,
+                           :match_targets,
                            :version_satisfied?, :no_match_reason, :safe_bundler_specs
     end
   end

data/lib/rails/hyperdrive/canonical_skill_render.rb

@@ -0,0 +1,105 @@
+require "fileutils"
+require "yaml"
+require "rails/hyperdrive/bundler_artifact_discovery"
+require "rails/hyperdrive/skill_template"
+
+module Rails
+  module Hyperdrive
+    # Renders each SKILL.md.erb template in a companion gem repo to the static
+    # SKILL.md it pairs with, using the canonical fail-open binding.
+    # Companion-repo dev tooling: problems raise.
+    module CanonicalSkillRender
+      Error = Class.new(StandardError)
+
+      Rendered = Struct.new(:template, :dest, :body, keyword_init: true)
+
+      module_function
+
+      def write(gemspec: nil, dir: Dir.pwd)
+        render_all(gemspec: gemspec, dir: dir).each do |r|
+          FileUtils.mkdir_p(File.dirname(r.dest))
+          File.write(r.dest, r.body)
+        end
+      end
+
+      def stale(gemspec: nil, dir: Dir.pwd)
+        render_all(gemspec: gemspec, dir: dir).reject do |r|
+          File.file?(r.dest) && File.read(r.dest) == r.body
+        end
+      end
+
+      def render_all(gemspec: nil, dir: Dir.pwd)
+        spec_path = resolve_gemspec_path(gemspec, dir)
+        spec = Gem::Specification.load(spec_path)
+        raise Error, "could not load gemspec #{spec_path}" unless spec
+
+        gem_root = File.dirname(File.expand_path(spec_path))
+        skills_root = File.join(gem_root, metadata_dir(spec, "rails_hyperdrive_skills_dir"))
+        templates_root = File.join(gem_root, metadata_dir(spec, "rails_hyperdrive_skill_templates_dir"))
+
+        Dir.glob(File.join(templates_root, "**", "SKILL.md.erb")).sort.map do |template|
+          rel = File.dirname(template).delete_prefix(templates_root).delete_prefix("/")
+          dest_dir = File.join(skills_root, rel)
+          # A SKILL.md written beside the SKILL.md.erb would take precedence
+          # over it at discovery time, silently demoting the skill to its
+          # static face.
+          if File.expand_path(dest_dir) == File.expand_path(File.dirname(template))
+            raise Error, "#{template}: content dir equals template dir; set " \
+                         "spec.metadata[\"rails_hyperdrive_skills_dir\"] to a separate root"
+          end
+
+          body = render_template(template)
+          validate_output!(body, template)
+          Rendered.new(template: template, dest: File.join(dest_dir, "SKILL.md"), body: body)
+        end
+      end
+
+      def resolve_gemspec_path(explicit, dir)
+        if explicit && !explicit.to_s.strip.empty?
+          path = File.expand_path(explicit.to_s, dir)
+          raise Error, "gemspec not found: #{path}" unless File.file?(path)
+          return path
+        end
+
+        found = Dir.glob(File.join(dir, "*.gemspec"))
+        case found.size
+        when 1 then File.expand_path(found.first)
+        when 0 then raise Error, "no .gemspec found in #{dir}; pass an explicit path, " \
+                                 "e.g. rake \"hyperdrive:skills:render[path/to/name.gemspec]\""
+        else raise Error, "multiple gemspecs found in #{dir} " \
+                          "(#{found.map { |f| File.basename(f) }.join(", ")}); pass an explicit path"
+        end
+      end
+
+      def metadata_dir(spec, key)
+        default = File.join("lib", spec.name, "hyperdrive", "skills")
+        raw = spec.metadata && spec.metadata[key]
+        return default if raw.nil? || raw.to_s.strip.empty?
+        raise Error, "gemspec metadata #{key} must not contain '..' segments" if
+          raw.to_s.split(%r{[/\\]}).include?("..")
+        raw.to_s
+      end
+
+      def render_template(template)
+        SkillTemplate.render_canonical(File.read(template))
+      rescue SyntaxError, StandardError => e
+        raise Error, "#{template}: canonical render failed (#{e.message})"
+      end
+
+      # A static face with unusable frontmatter would ship a broken skill to
+      # consumers that read it directly.
+      def validate_output!(body, template)
+        frontmatter, = BundlerArtifactDiscovery.split_frontmatter(body)
+        raise Error, "#{template}: rendered output has no YAML frontmatter" unless frontmatter
+
+        meta = YAML.safe_load(frontmatter, permitted_classes: [Symbol]) || {}
+        return if meta["name"] && meta["description"]
+        raise Error, "#{template}: rendered frontmatter lacks name: or description:"
+      rescue Psych::SyntaxError
+        raise Error, "#{template}: rendered frontmatter is not parseable YAML"
+      end
+
+      private_class_method :resolve_gemspec_path, :metadata_dir, :render_template, :validate_output!
+    end
+  end
+end

data/lib/rails/hyperdrive/drift_verdict.rb

@@ -1,11 +1,9 @@
 require "digest"
-require "rails/hyperdrive/audit_header"
 
 module Rails
   module Hyperdrive
-    # The lock's source_sha is computed over the install-ready body before any
-    # header injection, so hashing an installed file's comparable bytes
-    # (disk_sha) reproduces it exactly for an unedited file.
+    # Installed files are byte-identical to their install-ready body, so an
+    # unedited file's disk hash reproduces the lock's source_sha exactly.
     module DriftVerdict
       STATES = %i[current outdated edited missing orphaned].freeze
 
@@ -16,25 +14,22 @@ module Rails
         Digest::SHA256.hexdigest(content.to_s)
       end
 
-      # AuditHeader.strip's line matching can raise on binary content, so
-      # skill_support files compare as raw bytes.
-      def disk_sha(file, kind:)
-        return body_sha(File.binread(file)) if kind.to_s == "skill_support"
-        body_sha(AuditHeader.strip(File.read(file)))
+      def disk_sha(file)
+        body_sha(File.binread(file))
       end
 
-      # A file counts as unedited when its comparable bytes still hash to what
-      # the lock recorded at install time, not to what the gem ships now.
+      # A file counts as unedited when its bytes still hash to what the lock
+      # recorded at install time, not to what the gem ships now.
       def unedited?(file, lock_entry:)
-        disk_sha(file, kind: lock_entry.kind) == lock_entry.source_sha
+        disk_sha(file) == lock_entry.source_sha
       end
 
       # gem_sha nil means the bundle no longer offers this destination.
-      def verdict(file:, kind:, lock_entry:, gem_sha:)
+      def verdict(file:, lock_entry:, gem_sha:)
         return File.exist?(file) ? :orphaned : :missing if gem_sha.nil?
         return :missing unless File.exist?(file)
         return :edited if lock_entry.nil?
-        return :edited if disk_sha(file, kind: kind) != lock_entry.source_sha
+        return :edited if disk_sha(file) != lock_entry.source_sha
         lock_entry.source_sha == gem_sha ? :current : :outdated
       end
     end