rigortype 0.3.5 → 0.3.7

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_discoverer.rb

@@ -36,7 +36,11 @@ module Rigor
         def initialize(io_boundary:, search_paths:, base_classes:)
           @io_boundary = io_boundary
           @search_paths = search_paths
-          @base_classes = base_classes.to_set
+          # De-rooted for the same reason superclass names are ({#visit_class}): the match is by exact
+          # spelling, so a channel written `< ::ApplicationCable::Channel` — or a configured
+          # `channel_base_classes: ["::ApplicationCable::Channel"]` — would otherwise never match, and the
+          # channel would go undiscovered and its `broadcast_to` call sites report `unknown-channel`.
+          @base_classes = base_classes.to_set { |name| strip_root(name.to_s) }
         end
 
         # @return [ChannelIndex]
@@ -51,11 +55,39 @@ module Rigor
               entries << build_entry(class_name, path, body)
             end
           end
-          ChannelIndex.new(entries)
+          ChannelIndex.new(merge_redeclarations(entries))
         end
 
         private
 
+        # Collapses the entries that declare the SAME constant into one, so {ChannelIndex} — which keys its
+        # by-name view by `class_name` — receives at most one row per channel.
+        #
+        # A channel is routinely declared more than once: the real class in `app/channels/chat_channel.rb`
+        # and a second file reopening it (`class ::ChatChannel`, `class ChatChannel`) to add an action.
+        # Ruby's own semantics are ADDITIVE, so the rows are UNIONed: action methods and literal stream
+        # names union, and `dynamic_streams` ORs — any dynamic registration anywhere in the class means no
+        # literal name can be proven missing, which is the false-positive-safe reading. Taking the last row
+        # instead dropped the earlier declaration's actions and streams whenever it sorted later in the glob.
+        # `file_path` stays the earlier declaration's; nothing reads it by name.
+        def merge_redeclarations(entries)
+          return entries if entries.length < 2
+
+          entries.each_with_object({}) do |entry, acc|
+            name = entry.class_name
+            acc[name] = acc.key?(name) ? merged_entry(acc[name], entry) : entry
+          end.values
+        end
+
+        # `base` is the earlier declaration, `addition` the later one. See {#merge_redeclarations}.
+        def merged_entry(base, addition)
+          base.with(
+            action_methods: (base.action_methods | addition.action_methods).freeze,
+            stream_names: (base.stream_names | addition.stream_names).freeze,
+            dynamic_streams: base.dynamic_streams || addition.dynamic_streams
+          )
+        end
+
         def read_safely(path)
           @io_boundary.read_file(path)
         rescue Plugin::AccessDeniedError, Errno::ENOENT
@@ -65,7 +97,8 @@ module Rigor
         def ruby_files_under(roots)
           roots.flat_map do |root|
             absolute = File.expand_path(root)
-            next [] unless File.directory?(absolute)
+            # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+            next [] unless @io_boundary.directory?(absolute)
 
             Dir.glob(File.join(absolute, "**", "*.rb"))
           end
@@ -86,22 +119,37 @@ module Rigor
           class_local_name = constant_path_name(node.constant_path)
           return if class_local_name.nil?
 
-          full_name = (lexical_path + [class_local_name]).join("::")
-          superclass = constant_path_name(node.superclass) if node.superclass
+          full_name = declared_constant_name(class_local_name, lexical_path)
+          superclass = strip_root(constant_path_name(node.superclass)) if node.superclass
           yield full_name, node.body if superclass && @base_classes.include?(superclass)
 
-          inner_path = lexical_path + [class_local_name]
-          walk_for_channels(node.body, inner_path, &) if node.body
+          walk_for_channels(node.body, [full_name], &) if node.body
         end
 
         def visit_module(node, lexical_path, &)
           module_local_name = constant_path_name(node.constant_path)
           return if module_local_name.nil?
 
-          inner_path = lexical_path + [module_local_name]
+          inner_path = [declared_constant_name(module_local_name, lexical_path)]
           walk_for_channels(node.body, inner_path, &) if node.body
         end
 
+        # The full constant name a `class` / `module` declaration defines, given the rendered local name
+        # and the enclosing lexical path. A ROOTED local name (`class ::ChatChannel`) names the top-level
+        # constant whatever the nesting, so the lexical path is dropped and the `::` with it; otherwise the
+        # name is appended to the path (`class ChatChannel` inside `module Admin` → `Admin::ChatChannel`).
+        def declared_constant_name(local_name, lexical_path)
+          return strip_root(local_name) if local_name.start_with?("::")
+
+          (lexical_path + [local_name]).join("::")
+        end
+
+        # `::ChatChannel` → `ChatChannel`; a name without the root marker is returned unchanged (nil stays
+        # nil).
+        def strip_root(name)
+          name&.delete_prefix("::")
+        end
+
         def build_entry(class_name, path, body)
           actions = []
           (body&.compact_child_nodes || []).each do |node|
@@ -154,6 +202,8 @@ module Rigor
           true
         end
 
+        # Renders a constant-path node as a String, KEEPING the leading `::` of a rooted path —
+        # {#declared_constant_name} reads it as "reset the lexical path" before the marker is dropped.
         def constant_path_name(node)
           return nil if node.nil?
 

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_index.rb

@@ -26,19 +26,27 @@ module Rigor
 
         attr_reader :entries
 
+        # `entries` is expected UNIQUE by `class_name`: the by-name Hash is keyed by it, so a second row for
+        # a channel would replace the first outright. {ChannelDiscoverer#merge_redeclarations} is the single
+        # home of that guarantee — a reopened class arrives as one merged row, never as two.
         def initialize(entries)
           @entries = entries.freeze
           @by_name = entries.to_h { |entry| [entry.class_name, entry] }.freeze
           freeze
         end
 
+        # Entries are keyed by the de-rooted constant path (`"ChatChannel"`, `"Admin::ChatChannel"` — never
+        # `"::ChatChannel"`; see {ChannelDiscoverer}), while a QUERY may legitimately arrive rooted:
+        # `::ChatChannel.broadcast_to(...)` renders its receiver as `"::ChatChannel"`. The root marker is
+        # dropped here, once, so no caller needs a `find(name) || find("::#{name}")` retry (#621).
+        #
         # @return [Entry, nil]
         def find(class_name)
-          @by_name[class_name.to_s]
+          @by_name[strip_leading_namespace(class_name.to_s)]
         end
 
         def known?(class_name)
-          @by_name.key?(class_name.to_s)
+          @by_name.key?(strip_leading_namespace(class_name.to_s))
         end
 
         def empty?
@@ -64,6 +72,11 @@ module Rigor
         def any_dynamic_streams?
           @entries.any?(&:dynamic_streams)
         end
+
+        private
+
+        # `::ChatChannel` → `ChatChannel`. The query-side half of the key contract — see {#find}.
+        def strip_leading_namespace(name) = name.delete_prefix("::")
       end
     end
   end

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable.rb

@@ -65,7 +65,10 @@ module Rigor
     class Actioncable < Rigor::Plugin::Base
       manifest(
         id: "actioncable",
-        version: "0.1.0",
+        # Bumped 2026-09-02 (#621) — channel keys and base-class names are de-rooted at the producer and a
+        # reopened class's actions and streams are UNIONed rather than clobbered, so a cached 0.1.0 index
+        # can be missing a whole channel (`< ::ApplicationCable::Channel`) or half its stream names.
+        version: "0.2.0",
         description: "Validates ActionCable broadcast call shape against discovered channels.",
         config_schema: {
           "channel_search_paths" => { kind: :array, default: ["app/channels"] },

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/analyzer.rb

@@ -53,7 +53,9 @@ module Rigor
           return [] if class_name.nil?
           return [] if RESERVED_CLASS_METHODS.include?(call_node.name)
 
-          class_entry = mailer_index.find(class_name) || mailer_index.find("::#{class_name}")
+          # `MailerIndex#find` de-roots the query itself (#621) — a `::UserMailer.welcome` receiver and a
+          # plain `UserMailer.welcome` reach the same entry with no retry arm here.
+          class_entry = mailer_index.find(class_name)
           return [] if class_entry.nil?
 
           action_entry = class_entry.find_action(call_node.name)

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_discoverer.rb

@@ -46,7 +46,10 @@ module Rigor
         def initialize(io_boundary:, search_paths:, base_classes:, views_root: DEFAULT_VIEWS_ROOT)
           @io_boundary = io_boundary
           @search_paths = search_paths
-          @base_classes = base_classes.to_set
+          # De-rooted for the same reason superclass names are ({#visit_class}): the match is by exact
+          # spelling, so a configured `mailer_base_classes: ["::ApplicationMailer"]` would otherwise never
+          # match anything a declaration can render.
+          @base_classes = base_classes.to_set { |name| strip_root(name.to_s) }
           @views_root = views_root
         end
 
@@ -86,7 +89,8 @@ module Rigor
         def ruby_files_under(roots)
           roots.flat_map do |root|
             absolute = File.expand_path(root)
-            next [] unless File.directory?(absolute)
+            # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+            next [] unless @io_boundary.directory?(absolute)
 
             Dir.glob(File.join(absolute, "**", "*.rb"))
           end
@@ -107,16 +111,15 @@ module Rigor
           class_local_name = constant_path_name(node.constant_path)
           return if class_local_name.nil?
 
-          full_name = (lexical_path + [class_local_name]).join("::")
-          superclass = constant_path_name(node.superclass) if node.superclass
+          full_name = declared_constant_name(class_local_name, lexical_path)
+          superclass = strip_root(constant_path_name(node.superclass)) if node.superclass
           if superclass && @base_classes.include?(superclass)
             def_nodes = collect_action_defs(node.body)
             includes = collect_includes(node.body)
             yield full_name, def_nodes, includes
           end
 
-          inner_path = lexical_path + [class_local_name]
-          walk_for_mailers(node.body, inner_path, &) if node.body
+          walk_for_mailers(node.body, [full_name], &) if node.body
         end
 
         # Collects qualified-constant names passed to `include X` calls inside the class body. Used to
@@ -130,8 +133,8 @@ module Rigor
             next unless node.is_a?(Prism::CallNode) && node.receiver.nil? && node.name == :include
 
             (node.arguments&.arguments || []).each do |arg|
-              name = constant_path_name(arg)
-              names << name.delete_prefix("::") if name
+              name = strip_root(constant_path_name(arg))
+              names << name if name
             end
           end
           names
@@ -148,16 +151,19 @@ module Rigor
             local_name = constant_path_name(node.constant_path)
             return if local_name.nil?
 
-            full_name = (lexical_path + [local_name.delete_prefix("::")]).join("::")
+            full_name = declared_constant_name(local_name, lexical_path)
             if node.body
               def_nodes = collect_action_defs(node.body)
               entries = def_nodes.to_h { |def_node| [def_node.name, build_action_entry(def_node)] }
-              accumulator[full_name] = entries unless entries.empty?
-              collect_module_actions(node.body, lexical_path + [local_name.delete_prefix("::")], accumulator)
+              # UNIONed, never assigned: a concern module reopened in a second file adds actions rather
+              # than replacing the ones the first declaration spelled (same rule as {MailerIndex}'s
+              # per-class merge).
+              accumulator[full_name] = (accumulator[full_name] || {}).merge(entries) unless entries.empty?
+              collect_module_actions(node.body, [full_name], accumulator)
             end
           when Prism::ClassNode
             local_name = constant_path_name(node.constant_path)
-            inner = local_name ? lexical_path + [local_name.delete_prefix("::")] : lexical_path
+            inner = local_name ? [declared_constant_name(local_name, lexical_path)] : lexical_path
             collect_module_actions(node.body, inner, accumulator) if node.body
           else
             node.rigor_each_child { |child| collect_module_actions(child, lexical_path, accumulator) }
@@ -168,10 +174,27 @@ module Rigor
           module_local_name = constant_path_name(node.constant_path)
           return if module_local_name.nil?
 
-          inner_path = lexical_path + [module_local_name]
+          inner_path = [declared_constant_name(module_local_name, lexical_path)]
           walk_for_mailers(node.body, inner_path, &) if node.body
         end
 
+        # The full constant name a `class` / `module` declaration defines, given the rendered local name
+        # and the enclosing lexical path. A ROOTED local name (`class ::UserMailer`) names the top-level
+        # constant whatever the nesting, so the lexical path is dropped and the `::` with it; otherwise the
+        # name is appended to the path (`class UserMailer` inside `module Admin` → `Admin::UserMailer`).
+        def declared_constant_name(local_name, lexical_path)
+          return strip_root(local_name) if local_name.start_with?("::")
+
+          (lexical_path + [local_name]).join("::")
+        end
+
+        # `::UserMailer` → `UserMailer`; a name without the root marker is returned unchanged (nil stays nil).
+        def strip_root(name)
+          name&.delete_prefix("::")
+        end
+
+        # Renders a constant-path node as a String, KEEPING the leading `::` of a rooted path —
+        # {#declared_constant_name} reads it as "reset the lexical path" before the marker is dropped.
         def constant_path_name(node)
           return nil if node.nil?
 
@@ -334,7 +357,9 @@ module Rigor
           # ADR-39: the real ActiveSupport::Inflector resolves the mailer's view directory
           # (`Foo::BarMailer` → `foo/bar_mailer`), so a divergence from Rails' real underscore can't
           # point the missing-view check at the wrong directory.
-          underscore_path = Rigor::Plugin::Inflector.underscore(class_name.delete_prefix("::"))
+          # `class_name` is already de-rooted ({#declared_constant_name}), so no root marker can reach the
+          # inflection.
+          underscore_path = Rigor::Plugin::Inflector.underscore(class_name)
           mailer_dir = File.join(views_root_absolute, underscore_path)
 
           VIEW_FORMATS.any? do |format|

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_index.rb

@@ -40,19 +40,32 @@ module Rigor
 
         attr_reader :entries
 
+        # `entries` holds one row PER DECLARATION — a mailer declared in two files contributes two — because
+        # {#find_by_file} anchors the `missing-view` diagnostics on the file each action's `def` lives in.
+        # The by-name view a call site consults is the UNION of a class's declarations ({.merge_entry}): a
+        # reopen ADDS actions rather than replacing the class, so keeping the last row alone reported
+        # `unknown-action` on every action the other declaration spelled (#621).
         def initialize(entries)
           @entries = entries.freeze
-          @by_name = entries.to_h { |entry| [entry.class_name, entry] }.freeze
+          @by_name = entries.each_with_object({}) do |entry, acc|
+            name = entry.class_name
+            acc[name] = acc.key?(name) ? self.class.merge_entry(acc[name], entry) : entry
+          end.freeze
           freeze
         end
 
+        # Entries are keyed by the de-rooted constant path (`"UserMailer"`, `"Admin::UserMailer"` — never
+        # `"::UserMailer"`; see {MailerDiscoverer}), while a QUERY may legitimately arrive rooted:
+        # `::UserMailer.welcome(u)` renders its receiver as `"::UserMailer"`. The root marker is dropped
+        # here, once, so no caller needs a `find(name) || find("::#{name}")` retry (#621).
+        #
         # @return [ClassEntry, nil]
         def find(class_name)
-          @by_name[class_name.to_s]
+          @by_name[strip_leading_namespace(class_name.to_s)]
         end
 
         def known?(class_name)
-          @by_name.key?(class_name.to_s)
+          @by_name.key?(strip_leading_namespace(class_name.to_s))
         end
 
         # @param file_path [String] absolute path of a mailer file (canonicalised — see plugin entry's
@@ -73,6 +86,26 @@ module Rigor
         def names
           @by_name.keys
         end
+
+        # Unions two declarations of the SAME mailer class. `base` is the earlier row, `addition` the later
+        # one; Ruby's own semantics are additive, so nothing either declaration spelled is lost. Actions are
+        # name-keyed (a redefinition in the later file wins, as it does at load time), `missing_views` and
+        # `unresolved_includes` union, and `file_path` stays the earlier declaration's — the merged row is
+        # only ever reached by name, never by {#find_by_file}, which reads the per-declaration `entries`.
+        def self.merge_entry(base, addition)
+          base.with(
+            actions: base.actions.merge(addition.actions),
+            missing_views: (base.missing_views | addition.missing_views).freeze,
+            unresolved_includes: (base.unresolved_includes | addition.unresolved_includes).freeze
+          )
+        end
+
+        # `::UserMailer` → `UserMailer`. The query-side half of the key contract — see {#find}.
+        def self.strip_leading_namespace(name) = name.delete_prefix("::")
+
+        private
+
+        def strip_leading_namespace(name) = self.class.strip_leading_namespace(name)
       end
     end
   end

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer.rb

@@ -47,7 +47,11 @@ module Rigor
         # `send` / `__send__` / `method` and friends so dynamic-dispatch idioms
         # (`Mailer.respond_to?(action)` / `Mailer.public_send(action)`) stop firing `unknown-action`
         # against the Ruby reflection method.
-        version: "0.4.0",
+        #
+        # Bumped 2026-09-02 (#621) — mailer keys are de-rooted at the producer and a reopened class's
+        # actions are UNIONed rather than clobbered, so a cached 0.4.0 index can be missing actions this
+        # version knows about.
+        version: "0.5.0",
         description: "Validates ActionMailer call shape and view template existence.",
         config_schema: {
           "mailer_search_paths" => { kind: :array, default: ["app/mailers"] },
@@ -120,7 +124,7 @@ module Rigor
             severity: :warning,
             rule: "missing-view",
             message: "`#{class_entry.class_name}##{action_name}` has no view template " \
-                     "under `#{@views_root}/#{Rigor::Plugin::Inflector.underscore(class_entry.class_name.delete_prefix('::'))}/`"
+                     "under `#{@views_root}/#{Rigor::Plugin::Inflector.underscore(class_entry.class_name)}/`"
           )
         end
       end

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/analyzer.rb

@@ -247,26 +247,42 @@ module Rigor
           return nil if class_index.nil?
 
           class_node = ancestors[class_index]
+          # A ROOTED enclosing module (`module ::Admin`) resets the qualifier chain, exactly as it does in
+          # {ControllerDiscoverer} — the two sides must render the same key or the lookup silently misses
+          # (#621).
           enclosing = ancestors[0...class_index]
                       .grep(Prism::ModuleNode)
-                      .flat_map { |n| namespace_segments_for(n) }
+                      .each_with_object([]) do |module_node, chain|
+                        chain.clear if rooted_declaration?(module_node)
+                        chain.concat(namespace_segments_for(module_node))
+                      end
           qualified_name_with_enclosing(class_node.constant_path, enclosing)
         end
 
+        # True when the declaration's constant path is explicitly rooted (`class ::Foo`, `class ::Foo::Bar`)
+        # — the leftmost segment is a `ConstantPathNode` with no parent. Mirrors
+        # {ControllerDiscoverer#rooted_declaration?}.
+        def rooted_declaration?(declaration_node)
+          node = declaration_node.constant_path
+          node = node.parent while node.is_a?(Prism::ConstantPathNode) && node.parent
+          node.is_a?(Prism::ConstantPathNode)
+        end
+
         def namespace_segments_for(declaration_node)
           path = qualified_name_for(declaration_node.constant_path)
           path ? path.split("::") : []
         end
 
-        # Resolves a class-name AST node against an enclosing namespace chain. A `ConstantPathNode`
-        # (e.g. `class Admin::Foo`) is already absolute and ignores the chain; a `ConstantReadNode`
-        # (bare `class Foo` inside `module Admin`) is qualified against it.
+        # Resolves a class-name AST node against an enclosing namespace chain. A `ConstantPathNode` is
+        # already absolute and ignores the chain — either because it is qualified (`class Admin::Foo`) or
+        # because it is ROOTED (`class ::Foo`), which names the top-level constant whatever the nesting
+        # (#621). A `ConstantReadNode` (bare `class Foo` inside `module Admin`) is qualified against it.
         def qualified_name_with_enclosing(node, enclosing)
           return nil unless node.is_a?(Prism::Node)
 
           local = qualified_name_for(node)
           return nil if local.nil?
-          return local if node.is_a?(Prism::ConstantPathNode) && !node.parent.nil?
+          return local if node.is_a?(Prism::ConstantPathNode)
           return local if enclosing.empty?
 
           "#{enclosing.join('::')}::#{local}"

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_discoverer.rb

@@ -56,7 +56,8 @@ module Rigor
         def ruby_files_under(roots)
           roots.flat_map do |root|
             absolute = File.expand_path(root)
-            next [] unless File.directory?(absolute)
+            # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+            next [] unless @io_boundary.directory?(absolute)
 
             Dir.glob(File.join(absolute, "**", "*.rb"))
           end
@@ -69,12 +70,34 @@ module Rigor
 
           walk_declarations(parse_result.value, namespace: []) do |declaration_node, enclosing|
             entry = build_entry(declaration_node, enclosing)
-            entries[entry.class_name] = entry if entry.class_name
+            next unless entry.class_name
+
+            existing = entries[entry.class_name]
+            entries[entry.class_name] = existing ? merge_entry(existing, entry) : entry
           end
         rescue Plugin::AccessDeniedError, Errno::ENOENT
           nil
         end
 
+        # Unions two declarations of the SAME constant. A controller or concern is routinely declared more
+        # than once — the real class in `app/controllers/accounts_controller.rb` and a second file reopening
+        # it (`class ::AccountsController`, `class AccountsController`) to add an action or a filter target.
+        # Ruby's own semantics are ADDITIVE, so nothing either declaration spelled is lost. Assigning the
+        # later entry instead dropped the earlier one's `def`s, and `before_action :a_method_the_first_file
+        # _defines` then surfaced a false `unknown-filter-method` on correct code (#621).
+        #
+        # `parent_class_name` takes the first non-nil — a reopen normally omits `< Parent`, and two
+        # declarations that both spell one name the same class. `enclosing_namespace` stays the earlier
+        # declaration's: it is the lexical scope the merged include / parent names resolve against, and an
+        # unresolvable name degrades to {ControllerIndex#unresolved_include?}, which silences the rule.
+        def merge_entry(base, addition)
+          base.with(
+            defined_methods: (base.defined_methods | addition.defined_methods).freeze,
+            parent_class_name: base.parent_class_name || addition.parent_class_name,
+            included_module_names: (base.included_module_names | addition.included_module_names).freeze
+          )
+        end
+
         # Walks every `ClassNode` / `ModuleNode` in the AST, yielding `[declaration_node,
         # enclosing_namespace_array]` for each. `enclosing` is the chain of module / class qualifiers
         # OUTSIDE the yielded declaration (e.g. for `module Admin; class AccountsController; end; end`
@@ -86,7 +109,10 @@ module Rigor
 
           if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
             yield node, namespace
-            inner_namespace = namespace + namespace_segments_for(node)
+            # A ROOTED declaration (`class ::Foo`) names the top-level constant whatever its nesting, so it
+            # RESETS the qualifier chain its body sees rather than extending the enclosing one (#621).
+            inner_namespace = rooted_declaration?(node) ? [] : namespace
+            inner_namespace += namespace_segments_for(node)
             return if node.body.nil?
 
             walk_declarations(node.body, namespace: inner_namespace, &)
@@ -119,21 +145,34 @@ module Rigor
           )
         end
 
-        # Resolves the declared name against the enclosing namespace chain. A `ConstantPathNode` (e.g.
-        # `Admin::Foo` in `class Admin::Foo`) is already absolute and ignores the enclosing chain. A
-        # `ConstantReadNode` (bare `Foo` in `module Admin; class Foo`) is qualified against the chain so
-        # the name becomes `Admin::Foo`.
+        # Resolves the declared name against the enclosing namespace chain. A `ConstantPathNode` is already
+        # absolute and ignores the enclosing chain — either because it is qualified (`Admin::Foo` in
+        # `class Admin::Foo`) or because it is ROOTED (`::Foo`), which names the top-level constant
+        # whatever the nesting (#621). A `ConstantReadNode` (bare `Foo` in `module Admin; class Foo`) is
+        # qualified against the chain so the name becomes `Admin::Foo`.
+        #
+        # {#qualified_name_for} already renders a rooted path WITHOUT its leading `::`, so the entry key is
+        # the plain spelling every consumer anchors on.
         def qualified_name_with_enclosing(node, enclosing)
           return nil unless node.is_a?(Prism::Node)
 
           local = qualified_name_for(node)
           return nil if local.nil?
-          return local if node.is_a?(Prism::ConstantPathNode) && !node.parent.nil?
+          return local if node.is_a?(Prism::ConstantPathNode)
           return local if enclosing.empty?
 
           "#{enclosing.join('::')}::#{local}"
         end
 
+        # True when the declaration's constant path is explicitly rooted (`class ::Foo`,
+        # `class ::Foo::Bar`) — the leftmost segment is a `ConstantPathNode` with no parent. The analyzer
+        # carries the same predicate, because both sides must agree on the key a call site looks up.
+        def rooted_declaration?(declaration_node)
+          node = declaration_node.constant_path
+          node = node.parent while node.is_a?(Prism::ConstantPathNode) && node.parent
+          node.is_a?(Prism::ConstantPathNode)
+        end
+
         def parent_name_for(declaration_node)
           return nil unless declaration_node.is_a?(Prism::ClassNode) && declaration_node.superclass
 

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_index.rb

@@ -38,9 +38,14 @@ module Rigor
           freeze
         end
 
+        # Entries are keyed by the de-rooted constant path (`"AccountsController"`,
+        # `"Admin::AccountsController"` — never `"::AccountsController"`; see {ControllerDiscoverer}),
+        # while a QUERY may legitimately arrive rooted. The root marker is dropped at every lookup entry
+        # point, once, so no caller needs a `find(name) || find("::#{name}")` retry (#621).
+        #
         # @return [Entry, nil]
         def find(class_name)
-          @entries[class_name]
+          @entries[strip_leading_namespace(class_name)]
         end
 
         # Resolves the **effective** method set for a controller, including methods contributed by
@@ -56,7 +61,7 @@ module Rigor
           seen_classes = {}
           seen_modules = {}
           methods = []
-          current = class_name
+          current = strip_leading_namespace(class_name)
           while current && !seen_classes[current]
             seen_classes[current] = true
             entry = @entries[current]
@@ -87,6 +92,7 @@ module Rigor
         #   may legitimately contribute the filter (either directly, or via its own ancestor chain which
         #   the static analyzer cannot follow), and there's no way to verify.
         def unresolved_include?(class_name)
+          class_name = strip_leading_namespace(class_name)
           entry = @entries[class_name]
           return false if entry.nil?
 
@@ -132,7 +138,7 @@ module Rigor
         end
 
         def known?(class_name)
-          @entries.key?(class_name)
+          @entries.key?(strip_leading_namespace(class_name))
         end
 
         def class_names
@@ -141,6 +147,10 @@ module Rigor
 
         private
 
+        # `::AccountsController` → `AccountsController`. The query-side half of the key contract — see
+        # {#find}.
+        def strip_leading_namespace(name) = name&.delete_prefix("::")
+
         def collect_methods(name, seen, into)
           return if name.nil?