rigortype 0.3.5 → 0.3.7

data/lib/rigor/configuration.rb

@@ -144,10 +144,13 @@ module Rigor
       },
       "bundler" => {
         # Open item O4 — target-project Bundler awareness. When `bundle_path:` is set (or auto-detected),
-        # Rigor walks `<bundle_path>/ruby/*/gems/*/sig/` and adds each gem-shipped sig directory to
-        # `signature_paths:`. With O7's failure-memo in place, conflicts (a vendored sig already declares the
-        # same constant) degrade gracefully to "no RBS env" with a single-line warning naming the offending
-        # file, rather than hanging.
+        # Rigor walks `<bundle_path>/ruby/*/gems/*/sig/` (RubyGems-sourced gems) and
+        # `<bundle_path>/ruby/*/bundler/gems/*/sig/` (`git:`-sourced gems) and adds each gem-shipped sig
+        # directory to `signature_paths:`. A `path:`-sourced gem is not under either — Bundler uses the
+        # `path:` directory in place rather than copying it into the bundle root — so add its `sig/` directly
+        # via `signature_paths:` instead. With O7's failure-memo in place, conflicts (a vendored sig already
+        # declares the same constant) degrade gracefully to "no RBS env" with a single-line warning naming
+        # the offending file, rather than hanging.
         #
         # `bundle_path:` (String, optional): explicit path to the bundler install root (e.g.,
         # "vendor/bundle" or an absolute path). Resolved relative to the project root (`paths:`'s base) when

data/lib/rigor/effects/definition_lines.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "method_key"
+
+module Rigor
+  module Effects
+    # Where a method key's `def` is written, resolved from the file the key was already traced to
+    # (#435).
+    #
+    # A drift row names the file out of `Runner#effect_sources`, which rides the cached summary entry
+    # and is therefore free. The **line** is not in any value the effects surfaces hold: the discovery
+    # tables {EnvelopeCheck::Positions} reads are built by one Prism parse of every project file, which
+    # is exactly what [ADR-104](../../../docs/adr/104-effects-boot-slim-probe.md) removed from this
+    # command — a warm `rigor effects check` is fast *because* it never parses the project.
+    #
+    # So this parses the drift's own files and nothing else: an index is built the first time a row asks
+    # about a path, and a report with no rows builds none. The cost is proportional to the drift, not to
+    # the project — the {EnvelopeCheck::DeferredPositions} shape (#479) applied one layer up, and the
+    # reason it can be one layer up is that the caller already knows the file.
+    #
+    # It is deliberately not a second discovery pass. It answers `def`s and only `def`s: a key whose
+    # method has no Ruby `def` at all — a synthesized accessor — keeps the file and loses the line,
+    # which is the same degradation `Positions` makes when it falls back to the class's own source.
+    class DefinitionLines
+      TOPLEVEL = "<toplevel>"
+      private_constant :TOPLEVEL
+
+      NO_LINES = {}.freeze
+      private_constant :NO_LINES
+
+      # @param key [String] an effect unit key — `Tracer::Loud#emit`, `Net::HTTP.get`.
+      # @param path [String] the file the key was traced to.
+      # @return [Integer, nil] the `def`'s line, or nil when this file does not spell that key with a
+      #   `def` — an unreadable file, a syntax error, and a synthesized method all land here.
+      def for(key:, path:)
+        index_for(path)[key]
+      end
+
+      private
+
+      def index_for(path)
+        @indexes ||= {}
+        @indexes[path] ||= build_index(path)
+      end
+
+      # First `def` wins: a file that reopens the same method twice has two lines and only one of them is
+      # where a reader starts.
+      def build_index(path)
+        result = Prism.parse_file(path.to_s)
+        return NO_LINES unless result.success?
+
+        {}.tap { |index| walk(result.value, [], singleton: false, index: index) }
+      rescue StandardError
+        NO_LINES
+      end
+
+      # The nesting is tracked, never resolved: `class Tracer::Loud` inside `module Tracer` spells a key
+      # this cannot see, and answering it would need the constant resolution an engine-free path does not
+      # have. A key it cannot spell keeps its file, which is what the row printed before this class existed.
+      def walk(node, nesting, singleton:, index:)
+        case node
+        when Prism::ModuleNode, Prism::ClassNode
+          name = constant_name(node.constant_path)
+          return if name.nil?
+
+          walk_children(node.body, nesting + [name], singleton: false, index: index)
+        when Prism::SingletonClassNode
+          walk_children(node.body, nesting, singleton: true, index: index)
+        when Prism::DefNode
+          record(node, nesting, singleton: singleton, index: index)
+          walk_children(node.body, nesting, singleton: singleton, index: index)
+        else
+          walk_children(node, nesting, singleton: singleton, index: index)
+        end
+      end
+
+      def walk_children(node, nesting, singleton:, index:)
+        node&.compact_child_nodes&.each { |child| walk(child, nesting, singleton: singleton, index: index) }
+      end
+
+      def record(node, nesting, singleton:, index:)
+        separator = singleton || node.receiver.is_a?(Prism::SelfNode) ? "." : "#"
+        owner = nesting.empty? ? TOPLEVEL : nesting.join("::")
+        key = "#{owner}#{separator}#{node.name}"
+        index[key] ||= node.location.start_line
+      end
+
+      def constant_name(node)
+        case node
+        when Prism::ConstantReadNode then node.name.to_s
+        when Prism::ConstantPathNode then node.full_name
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/effects/envelope_check.rb

@@ -83,6 +83,21 @@ module Rigor
         end
       end
 
+      # {Positions} behind a thunk: the discovery tables — one Prism parse of every project file —
+      # are built on the first `.for`, which both judgments reach only once a finding is being
+      # constructed. A clean judgment, the common CI case, therefore forces no discovery and parses
+      # nothing; that is the whole point of this class existing rather than the pass forcing the
+      # tables up front.
+      class DeferredPositions
+        def initialize(&build)
+          @build = build
+        end
+
+        def for(key)
+          (@positions ||= @build.call).for(key)
+        end
+      end
+
       NO_FINDINGS = [].freeze
       private_constant :NO_FINDINGS
 
@@ -93,7 +108,9 @@ module Rigor
       # @param class_envelopes [Hash{String => Envelope}] class- / module-level envelopes, to distribute.
       # @param config_envelopes [Hash{String => Envelope}] `effects.envelopes:` entries already resolved
       #   to the classes they select ({ConfigEnvelopes.for_classes}), to distribute at the lowest precedence.
-      # @param positions [Positions] the discovery tables a finding's `def` position is read from.
+      # @param positions [Positions, DeferredPositions] the discovery tables a finding's `def`
+      #   position is read from — consulted only when a finding is built, so a deferred value's
+      #   discovery force is reached exactly as often as a finding exists.
       # @param apply_tolerated [Boolean] false judges against the undischarged-by-policy `proven` lane —
       #   the `--no-tolerated-effects` audit switch.
       # @return [Array<Finding>] sorted by position then key then label, so a run explains identically twice.

data/lib/rigor/effects/liskov_check.rb

@@ -112,11 +112,13 @@ module Rigor
 
         inherited = envelopes.fetch(ancestor_key)
         own = envelopes[key]
-        position = positions.for(key)
+        # The position is read inside the two collectors, after they know a finding exists: `.for` is
+        # what forces a deferred position table, and an inherited envelope nothing widens must not
+        # cost a whole-project discovery parse.
         if own && !own.top?
-          collect_declared(findings, key, ancestor_key, inherited, own, position)
+          collect_declared(findings, key, ancestor_key, inherited, own, positions)
         else
-          collect_proven(findings, table, key, ancestor_key, inherited, position, apply_tolerated)
+          collect_proven(findings, table, key, ancestor_key, inherited, positions, apply_tolerated)
         end
       end
 
@@ -135,16 +137,19 @@ module Rigor
         nil
       end
 
-      def collect_proven(findings, table, key, ancestor_key, inherited, position, apply_tolerated)
+      def collect_proven(findings, table, key, ancestor_key, inherited, positions, apply_tolerated)
         entry = table[key]
         return if entry.nil?
 
         exceeding = inherited.exceeded_by(apply_tolerated ? entry.undischarged : entry.proven)
+        return if exceeding.empty?
+
+        path, line = positions.for(key)
         exceeding.each do |label|
           trail = PathFinder.shortest(table, symbol: key, label: label)
           findings << Finding.new(
             key: key, label: label, ancestor_key: ancestor_key, ancestor_envelope: inherited,
-            own_envelope: nil, path: position.first, line: position.last,
+            own_envelope: nil, path: path, line: line,
             chain: trail&.chain || [key].freeze, origin: trail&.origin
           )
         end
@@ -152,11 +157,15 @@ module Rigor
 
       # Two authored bounds, compared by subsumption alone. `mutate.local` is tolerated here as it is
       # everywhere, so declaring it under an inherited `%a{pure}` is not a widening.
-      def collect_declared(findings, key, ancestor_key, inherited, own, position)
-        own.bound.to_a.reject { |label| inherited.tolerates?(label) }.each do |label|
+      def collect_declared(findings, key, ancestor_key, inherited, own, positions)
+        widened = own.bound.to_a.reject { |label| inherited.tolerates?(label) }
+        return if widened.empty?
+
+        path, line = positions.for(key)
+        widened.each do |label|
           findings << Finding.new(
             key: key, label: label, ancestor_key: ancestor_key, ancestor_envelope: inherited,
-            own_envelope: own, path: position.first, line: position.last, chain: nil, origin: nil
+            own_envelope: own, path: path, line: line, chain: nil, origin: nil
           )
         end
       end

data/lib/rigor/effects/plugin_facts.rb

@@ -326,7 +326,7 @@ module Rigor
         payload = [
           @labels_by_owner.sort.map { |owner, labels| [owner, labels.sort] },
           @class_rows.keys.sort_by { |singleton| singleton ? 1 : 0 }
-                          .map { |singleton| [singleton, sorted(@class_rows[singleton])] },
+                     .map { |singleton| [singleton, sorted(@class_rows[singleton])] },
           sorted(@path_rows), sorted(@self_rows), sorted(@result_rows),
           @edges.map { |edge| [edge.target.to_s, edge.receiver, edge.selector.to_s, edge.plugin_id] }.sort,
           @entry_points.map(&:to_h).sort_by { |preset| preset["name"] },

data/lib/rigor/effects/scanner.rb

@@ -107,10 +107,9 @@ module Rigor
       end
 
       def walk_namespace(node, prefix)
-        name = Source::ConstantPath.qualified_name(node.constant_path)
-        return node.rigor_each_child { |child| walk(child, prefix, false) } if name.nil?
+        nested = Source::ConstantPath.declaration_prefix(prefix, node.constant_path)
+        return node.rigor_each_child { |child| walk(child, prefix, false) } if nested.nil?
 
-        nested = prefix + [name]
         record_superclass(nested.join("::"), node, prefix) if node.is_a?(Prism::ClassNode)
         walk(node.body, nested, false) if node.body
       end

data/lib/rigor/effects/signature_sources.rb

@@ -21,10 +21,21 @@ module Rigor
       DEFAULT_ROOTS = ["sig"].freeze
 
       # A cheap text pre-filter for "does this source carry an effect annotation at all". It matches
-      # the two spellings the envelope reader honours and nothing else, so a signature tree with no
+      # the two payloads the envelope reader honours and nothing else, so a signature tree with no
       # effect annotation is answered by one regex per file and never parsed. It is a ROUTING test,
       # not the grammar — `RbsExtended.parse_effect_annotation` is still what decides meaning.
-      ANNOTATION_HINT = /%a\{\s*(?:pure\s*\}|rigor:v1:effect\b)/
+      #
+      # RBS accepts five bracket pairs for an annotation, and the reader sees only the text inside
+      # them, so the hint must accept all five too: routing on `%a{` alone made a `%a(pure)` project
+      # invisible to the run-cache probe, which then served the fast path while a bound existed —
+      # the silent-lane shape the #428 family is about. Over-matching (a mismatched closer) is safe:
+      # the cost is one declined fast path or one parsed file, never a missed bound.
+      ANNOTATION_BRACKETS = { "{" => "}", "(" => ")", "[" => "]", "|" => "|", "<" => ">" }.freeze
+      ANNOTATION_HINT = Regexp.union(
+        ANNOTATION_BRACKETS.map do |opener, closer|
+          /%a#{Regexp.escape(opener)}\s*(?:pure\s*#{Regexp.escape(closer)}|rigor:v1:effect\b)/
+        end
+      )
 
       # A `virtual:<plugin-id>:<source path>` buffer is rbs-inline's (or a plugin's) synthesized RBS for
       # a Ruby file the author actually wrote in. Naming that file is what a reader can act on, so the

data/lib/rigor/effects/snapshot.rb

@@ -38,7 +38,10 @@ module Rigor
     class Snapshot
       # Bumped when the file's shape changes in a way an older reader would misread. A bump makes every
       # existing file a regeneration event rather than a silent reinterpretation.
-      SCHEMA = 1
+      # 2 — `unresolved:` became a count (#434). A schema-1 file still loads, and its only reported
+      # difference is this field, so an existing project sees one regeneration line rather than a
+      # reinterpretation.
+      SCHEMA = 2
 
       HEADER = "# .rigor-effects.yml — generated by `rigor effects update`. Commit it; review its diff."
 
@@ -47,8 +50,16 @@ module Rigor
 
       # One row of either table.
       #
-      # `effects` and `declared` are sorted label arrays; `unresolved` is the sorted list of taint-cause
-      # renderings behind a false `exhaustive`, and is empty when the row is exhaustive.
+      # `effects` and `declared` are sorted label arrays; `unresolved` is HOW MANY taint causes sit behind
+      # a false `exhaustive`, and is zero when the row is exhaustive.
+      #
+      # A count rather than the causes themselves (#434). On redmine the cause renderings were 144,771 of
+      # the file's 293,276 bytes, on lines up to 821 characters — simultaneously the half a reviewer
+      # cannot read and the half that churns when an unrelated call moves. This file already makes that
+      # argument about origins ("a record keyed by them would churn on every refactor"); the causes are
+      # the same class of thing and were the one place it was not applied. What a reviewer needs from the
+      # record is the stable fact that the row is not exhaustive and by how much, which is what a count
+      # is; `rigor effects explain` names the causes on demand, against the live table.
       class Entry < Data.define(:key, :effects, :declared, :exhaustive, :unresolved)
         def exhaustive?
           exhaustive
@@ -61,7 +72,7 @@ module Rigor
           row = { "effects" => effects }
           row["declared"] = declared unless declared.empty?
           row["exhaustive"] = false unless exhaustive
-          row["unresolved"] = unresolved unless unresolved.empty?
+          row["unresolved"] = unresolved unless unresolved.zero?
           row
         end
 
@@ -73,10 +84,23 @@ module Rigor
             effects: string_list(row["effects"], key, "effects"),
             declared: string_list(row["declared"], key, "declared"),
             exhaustive: row.fetch("exhaustive", true) != false,
-            unresolved: string_list(row["unresolved"], key, "unresolved")
+            unresolved: unresolved_count(row["unresolved"], key)
           )
         end
 
+        # Tolerant of the schema-1 spelling, which was the list itself: the field's whole point now is a
+        # stable number, and a schema-1 file must LOAD so the header's own mismatch can be reported as
+        # the one regeneration event it is. Refusing to parse it would turn a migration into an error.
+        def self.unresolved_count(value, key)
+          case value
+          when nil then 0
+          when Integer then value
+          when Array then value.length
+          else raise ParseError, "#{key.inspect} unresolved: expected a count, got #{value.class}"
+          end
+        end
+        private_class_method :unresolved_count
+
         def self.string_list(value, key, field)
           return [].freeze if value.nil?
           raise ParseError, "#{key.inspect} #{field}: expected a list, got #{value.class}" unless value.is_a?(Array)
@@ -185,6 +209,29 @@ module Rigor
           parse(File.read(path, encoding: "UTF-8"))
         end
 
+        # A path as a reader sees it: project-relative when it is under the root, absolute when it is not.
+        #
+        # Public for the same reason {.render_causes} is — `reach:`'s entry-point globs and a drift row's
+        # source suffix (#435) must agree about what a project-relative path is, and a report that leaked
+        # `/private/tmp/nix-shell.../loud.rb` into a reviewer's terminal would be answering with this
+        # machine's layout rather than with the project's.
+        def relativize(path, project_root)
+          absolute = File.absolute_path(path.to_s)
+          root = "#{File.absolute_path(project_root.to_s).chomp('/')}/"
+          absolute.start_with?(root) ? absolute[root.length..] : absolute
+        end
+
+        # The taint causes as a reviewer reads them, from the closed enum of
+        # `docs/type-specification/effect-labels.md` — `dynamic-send`, `unresolved-self-call(save!)`.
+        #
+        # Public because two surfaces render the same causes and must not disagree about what one IS:
+        # a row's `unresolved:` count is the length of this list, and `rigor effects explain` prints the
+        # list itself for an `exhaustive → not` drift row (#434 / #435). One implementation, as WD3 asks.
+        def render_causes(causes)
+          causes.map { |cause, detail| detail.nil? || detail.empty? ? cause : "#{cause}(#{detail})" }
+                .uniq.sort.freeze
+        end
+
         private
 
         def parse_header(data)
@@ -241,12 +288,6 @@ module Rigor
           end
         end
 
-        def relativize(path, project_root)
-          absolute = File.absolute_path(path.to_s)
-          root = "#{File.absolute_path(project_root.to_s).chomp('/')}/"
-          absolute.start_with?(root) ? absolute[root.length..] : absolute
-        end
-
         # Each table takes the lanes at ITS own reading: `methods:` records the direct summary, so its
         # `declared:` is what this method's own body claims, and `reach:` records the transitive one, so
         # its `declared:` is the fixpoint's — a controller reaching an attributed gem call through two
@@ -261,19 +302,10 @@ module Rigor
             effects: proven.to_a,
             declared: declared.excluding_subsumed_by(proven).to_a,
             exhaustive: exhaustive,
-            unresolved: exhaustive ? [].freeze : render_causes(causes)
+            unresolved: exhaustive ? 0 : render_causes(causes).length
           )
         end
 
-        # `unresolved:` says why the row is not exhaustive, from the closed taint-cause enum of
-        # `docs/type-specification/effect-labels.md` — `dynamic-send`, `unresolved-self-call(save!)`. The
-        # design note sketched this field as "call names"; the collector keeps causes rather than names,
-        # and for the causes that have one the detail already IS the call name.
-        def render_causes(causes)
-          causes.map { |cause, detail| detail.nil? || detail.empty? ? cause : "#{cause}(#{detail})" }
-                .uniq.sort.freeze
-        end
-
         # A synthesised default summary — an `attr_*` writer's `mutate.self`, and the `Struct` / `Data`
         # accessors that join it when discovery synthesises them — carries no information a reviewer acts
         # on: it restates the `attr_accessor` line. Recognised by its origins being exactly the synthesised

data/lib/rigor/effects/snapshot_diff.rb

@@ -107,6 +107,7 @@ module Rigor
         @undischarged = undischarged
         @added_symbols = 0
         @removed_symbols = 0
+        @suppressed = 0
         @events = build_events.freeze
         freeze
       end
@@ -123,9 +124,16 @@ module Rigor
       end
 
       # Renames are a removal plus an addition and are never reported as a lost effect; the footer is
-      # where the reviewer sees that the two counts balance.
+      # where the reviewer sees that the two counts balance. `suppressed` is the per-symbol events a
+      # regeneration event withheld — zero on an ordinary comparison.
       def footer
-        { added_symbols: @added_symbols, removed_symbols: @removed_symbols }
+        { added_symbols: @added_symbols, removed_symbols: @removed_symbols, suppressed: @suppressed }
+      end
+
+      # Whether the two sides were computed under different rules (#434). The per-symbol comparison is
+      # then meaningless rather than merely noisy, which is why {#build_events} withholds it.
+      def regeneration?
+        @events.any? { |event| event.category == REGENERATION }
       end
 
       def events_for(table)
@@ -145,10 +153,25 @@ module Rigor
         ADDITIVE_CATEGORIES.include?(event.category)
       end
 
+      # A regeneration event withholds the per-symbol comparison rather than printing it (#434).
+      #
+      # The header says the record was written under different rules, so the two sides are not
+      # comparable — a claim this class already makes in its own documentation and then contradicted by
+      # emitting every row anyway. On redmine a moved `config_digest:` produced one regeneration line
+      # followed by 482 `-symbol` lines, none of which was a review signal: they say the recorded set was
+      # computed differently, which the header already said once.
+      #
+      # The table comparison still RUNS, because its per-symbol counters are what tell the reader the
+      # scale of what is withheld. Only the events are dropped.
       def build_events
         return [missing_snapshot_event] if @recorded.nil?
 
-        header_events + TABLES.flat_map { |table| table_events(table) }
+        header = header_events
+        table = TABLES.flat_map { |name| table_events(name) }
+        return table if header.empty?
+
+        @suppressed = table.length
+        header
       end
 
       def missing_snapshot_event

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -57,8 +57,12 @@ module Rigor
       #   When non-nil and non-empty, only `sig/` directories whose gem `(name, version, platform)` tuple
       #   matches a lockfile entry are returned. Bundle entries absent from the lockfile (or at a drifted
       #   version) are silently dropped — the lockfile is treated as the source of truth for "what gems this
-      #   project actually declares". Pass `nil` (the default) to keep the pre-Layer-3 behaviour of
-      #   returning every non-skipped `sig/` under the bundle.
+      #   project actually declares". A git-sourced directory carries no version to compare (see
+      #   {.gem_name_from_sig_path}), so for those the filter instead requires the matching `locked_gems`
+      #   entry to have `git_source: true` — name alone is not enough, since a gem that moved off a `git:`
+      #   source keeps its stale `bundler/gems/` directory under the SAME name until a `bundle clean`. Pass
+      #   `nil` (the default) to keep the pre-Layer-3 behaviour of returning every non-skipped `sig/` under
+      #   the bundle.
       # @return [Array<Pathname>] every `<gem-dir>/sig` directory under the resolved bundle path, minus any
       #   whose gem name is in `skip_gems` and (when `locked_gems` is supplied) minus any whose `(name,
       #   version, platform)` does not match a lockfile entry.
@@ -72,14 +76,41 @@ module Rigor
         )
         return [] if resolved.nil?
 
-        # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig/` is the canonical bundler layout. `*` on the ruby
-        # version dir picks up whichever Ruby the bundle was installed for.
-        all = Dir.glob(resolved.join("ruby", "*", "gems", "*", "sig")).map { |d| Pathname.new(d) }
+        # Two bundler-install layouts, both under the same `ruby/X.Y.Z/` root (`*` picks up whichever Ruby
+        # the bundle was installed for):
+        #
+        # - `gems/<name>-<ver>/sig/` — the RubyGems-sourced layout, the canonical case.
+        # - `bundler/gems/<repo>-<12-hex-revision>/sig/` — `git:`-sourced gems (`Bundler::Source::Git#
+        #   install_path`); the directory name carries the git repository's basename and a 12-character
+        #   revision prefix, not the gem name or version. Before this, a fork's own `sig/` was invisible to
+        #   rigor no matter how it was authored — see issue #611.
+        #
+        # `path:`-sourced gems are NOT under either glob: Bundler does not copy them into the bundle root at
+        # all (`Bundler::Source::Path#path` is the user's own `path:` directory, used in place), so there is
+        # no bundle-relative location to walk. A `path:`-sourced gem's `sig/` is only reachable by adding it
+        # directly to the project's `signature_paths:` — which already works today and needs no discovery.
+        all = (Dir.glob(resolved.join("ruby", "*", "gems", "*", "sig")) +
+               Dir.glob(resolved.join("ruby", "*", "bundler", "gems", "*", "sig"))).map { |d| Pathname.new(d) }
         filtered = all.reject { |sig_dir| skip_gems.include?(gem_name_from_sig_path(sig_dir)) }
         return filtered if locked_gems.nil? || locked_gems.empty?
 
         expected_dirs = expected_gem_dirs(locked_gems)
-        filtered.select { |sig_dir| expected_dirs.include?(sig_dir.parent.basename.to_s) }
+        filtered.select do |sig_dir|
+          if git_sourced_layout?(sig_dir)
+            # A git install's directory name carries no resolvable version (see above), so the lockfile
+            # filter can only check the gem NAME, not `(name, version)` — but name alone is not enough: a
+            # gem that used to be `git:`-sourced and has since moved to a released version keeps its old
+            # `bundler/gems/<repo>-<sha>/` directory sitting in the bundle tree until a `bundle clean`, and
+            # its NAME is still present in the lockfile (now via the rubygems entry). Matching on name only
+            # would silently readmit that stale git install — this repo's own `vendor/bundle` had exactly
+            # this after `binpacker` moved from `git:` to a released gem. `locked_gems` must say this name is
+            # CURRENTLY git-sourced, not merely present.
+            locked = locked_gems[gem_name_from_sig_path(sig_dir)]
+            !!locked&.git_source
+          else
+            expected_dirs.include?(sig_dir.parent.basename.to_s)
+          end
+        end
       end
 
       # `{name => LockedGem}` → set of canonical bundler gem directory basenames. Pure-Ruby gems install as
@@ -98,19 +129,39 @@ module Rigor
       end
       private_class_method :expected_gem_dirs
 
-      # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig` → `<name>`. The gem directory follows the canonical
-      # `<name>-<version>` pattern; we strip everything from the last hyphen onwards to recover the name.
-      # (Platform-tagged variants like `ffi-1.17.4-aarch64-linux-gnu/` keep their platform suffix in the
-      # version part, so the first hyphen from the right is still the name boundary.)
+      # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig` → `<name>`, or
+      # `<bundle>/ruby/X.Y.Z/bundler/gems/<repo>-<12-hex-revision>/sig` → `<repo>`. The two bundler-install
+      # layouts name their gem directory differently, so which suffix to strip depends on which layout
+      # `sig_dir` came from:
+      #
+      # - rubygems layout: `<name>-<version>` (platform-tagged variants like `ffi-1.17.4-aarch64-linux-gnu/`
+      #   keep their platform suffix in the version part) — the version always starts with a digit, so strip
+      #   from the first `-` followed by a digit.
+      # - git layout: `<repo-basename>-<12-hex-char-revision>` (`Bundler::Source::Git#install_path`) — no
+      #   version at all, and the repository name need not equal the gem name (a fork hosted under a
+      #   different repo name, a monorepo). Strip the fixed-width hex suffix instead; best-effort only, since
+      #   the true gem name isn't recoverable from the filesystem without running Bundler.
       #
       # Public so the O4 Layer 3 slice-3 coverage report (`RbsCoverageReport`) can classify discovered bundle
       # sigs against locked gem names without re-running discovery.
       def self.gem_name_from_sig_path(sig_dir)
         gem_dir = sig_dir.parent.basename.to_s
-        # Strip `-<version>` and any platform suffix. The version always starts with a digit, so split at
-        # the first `-` followed by a digit.
-        gem_dir.sub(/-\d.*\z/, "")
+        if git_sourced_layout?(sig_dir)
+          gem_dir.sub(/-[0-9a-f]{12}\z/, "")
+        else
+          gem_dir.sub(/-\d.*\z/, "")
+        end
+      end
+
+      # True when `sig_dir` sits under the `bundler/gems/` (git-sourced) layout rather than the plain
+      # `gems/` (rubygems-sourced) layout — `<bundle>/ruby/X.Y.Z/bundler/gems/<dir>/sig` vs.
+      # `<bundle>/ruby/X.Y.Z/gems/<dir>/sig`. A directory-shape check, not a name-shape guess: the two glob
+      # roots in {.discover} are already disjoint, so this just recovers which one a given path came from.
+      def self.git_sourced_layout?(sig_dir)
+        gem_dir = sig_dir.parent
+        gem_dir.parent.basename.to_s == "gems" && gem_dir.parent.parent.basename.to_s == "bundler"
       end
+      private_class_method :git_sourced_layout?
 
       # Returns `Pathname` resolved bundle path, or `nil` when neither explicit nor auto-detected. Public
       # for the stats banner so end users can see what rigor picked up.

data/lib/rigor/environment/lockfile_resolver.rb

@@ -22,13 +22,19 @@ module Rigor
       #
       # `version` is the resolved version string (e.g. "8.0.1"); `platform` is the lockfile's platform tag,
       # normalised to `"ruby"` when the lockfile records `ruby` and to the raw String otherwise (e.g.
-      # "aarch64-linux-gnu").
-      LockedGem = Data.define(:name, :version, :platform) do
-        def initialize(name:, version:, platform:)
+      # "aarch64-linux-gnu"). `git_source` is true when the lockfile's `GIT` stanza (rather than `GEM`)
+      # resolved this gem — see {BundleSigDiscovery}, which needs it to tell a genuine git install apart
+      # from a same-named gem the bundle tree has an out-of-band `bundler/gems/` leftover for (e.g. a
+      # dependency that moved from a `git:` source to a released version without a `bundle clean`, so its
+      # git-installed directory is still sitting there under the OLD source's name). Defaults `false` so
+      # existing callers that construct a `LockedGem` without an opinion stay conservative.
+      LockedGem = Data.define(:name, :version, :platform, :git_source) do
+        def initialize(name:, version:, platform:, git_source: false)
           super(
             name: -name.to_s,
             version: -version.to_s,
-            platform: -platform.to_s
+            platform: -platform.to_s,
+            git_source: git_source ? true : false
           )
         end
       end
@@ -94,8 +100,12 @@ module Rigor
           # (references/rbs/sig/shims/bundler.rbs) does NOT declare `LazySpecification#platform` so the call
           # site needs a suppression marker.
           platform = spec.platform.to_s # rigor:disable undefined-method
+          # `#source` is the `Bundler::Source::*` this spec resolved from — `Git` for a `GIT` lockfile
+          # stanza, `Rubygems` for a `GEM` one, `Path`/`Gemspec` for `path:`. Only `Git` sources land under
+          # {BundleSigDiscovery}'s `bundler/gems/` walk.
           h[spec.name.to_s] = LockedGem.new(
-            name: spec.name, version: spec.version.to_s, platform: platform
+            name: spec.name, version: spec.version.to_s, platform: platform,
+            git_source: spec.source.is_a?(Bundler::Source::Git)
           )
         end
         locked.freeze