rigortype 0.3.8 → 0.3.9

data/lib/rigor/inference/scope_indexer.rb

@@ -7,6 +7,7 @@ require_relative "../type"
 require_relative "../source/constant_path"
 require_relative "../source/node_children"
 require_relative "../cache/file_digest"
+require_relative "../analysis/check_rules/published_constant_guard"
 require_relative "anonymous_meta_class"
 require_relative "def_handle"
 require_relative "index_write_widening"
@@ -46,27 +47,42 @@ module Rigor
       # seed bundle through `Marshal` unchanged.
       CONSTANT_UNPUBLISHABLE = :unpublishable
 
+      # Issue #668 — the census key a constant write through a base no name reaches is filed under:
+      # `*::LIMIT` for `k::LIMIT = 7`. `*` is not a constant character, so the key can never collide with a
+      # name a program writes, while its LAST SEGMENT is the real one — which is what the ADR-46 `constant:`
+      # edge and {Analysis::Incremental.changed_constant_publications} key on, so both keep working unchanged.
+      DYNAMIC_TARGET_PREFIX = "*::"
+
       module_function
 
       # Build the scope index for a Prism program subtree.
       #
-      # @param root [Prism::Node] usually a `Prism::ProgramNode`, but any
+      # @param root — usually a `Prism::ProgramNode`, but any
       #   subtree the caller wants the indexer to walk works.
-      # @param default_scope [Rigor::Scope] the scope used for the root,
+      # @param default_scope — the scope used for the root,
       #   and the fallback returned for any Prism node not contained in
       #   `root`'s subtree.
-      # @param converged_loop_recording [Boolean] display-path flag —
+      # @param converged_loop_recording — display-path flag —
       #   when true the evaluator re-records fixpoint-tracked loop
       #   bodies from their CONVERGED bindings so per-line probes
       #   (`rigor annotate`) reflect the post-writeback state, not the
       #   cap-N intermediate constants. Off for the check path.
-      # @return [Hash{Prism::Node => Rigor::Scope}] identity-comparing
+      # @return identity-comparing
       #   table whose default value is `default_scope`.
+      # The no-op re-anchoring table (#722 residue 2): shared so the overwhelmingly common
+      # nothing-to-re-anchor walk allocates none.
+      EMPTY_RENAMES = {}.freeze
+
       def index(root, default_scope:, converged_loop_recording: false) # rubocop:disable Metrics/AbcSize
         # Slice A-declarations. Build the declaration overrides first so every scope handed to the StatementEvaluator
         # already carries the table; structural sharing through `Scope#with_local` / `#with_fact` / `#with_self_type`
         # propagates it across every derived scope.
-        declared_types, discovered_classes = build_declaration_artifacts(root)
+        # Issue #722 residue 2 — the project's settled declaration names are the oracle the file's own
+        # compact headers are re-anchored against. `discovered_class_sources` would be the more direct
+        # reading, but it is seeded only under `--record-dependencies`; this table is the one every run
+        # carries, and the fold has already applied its own re-anchoring to it.
+        declared_types, discovered_classes =
+          build_declaration_artifacts(root, default_scope.discovered_classes.keys.to_set)
         # Merge the indexer's findings on top of whatever the base scope already carries so callers that seed cross-file
         # class knowledge (e.g. the ADR-14 `SigGen::ObservationCollector` pre-walking project `lib/` before scanning
         # `spec/`) keep their seeds alongside the per-file declarations the indexer itself discovers. Indexer-found
@@ -110,6 +126,7 @@ module Rigor
           build_in_source_constants(root, seeded_scope), literal_mutations[:constants]
         )
         seeded_scope = seed_constant_tables(seeded_scope, default_scope, in_source_constants, root)
+        seeded_scope = seed_published_constant_ivars(seeded_scope, root)
 
         # Slice 7 phase 12. In-source method discovery. Walks every class/module body for `Prism::DefNode` and
         # recognised `define_method` calls and records the introduced method names. `rigor check` consults the table to
@@ -193,7 +210,11 @@ module Rigor
         # #526 — this file's extends folded against the MERGED instance def-nodes (so `extend M` sees a
         # sibling-file M through the cross-file seed). The project-wide fold in {#finalize_def_index}
         # covers cross-file CONSUMERS; this covers the file that declares the extend.
-        methods_table = fold_per_file_extends(root, def_nodes, singleton_def_nodes, seeded_scope)
+        #
+        # Issue #898 — and the same walk's table is now kept, merged over the cross-file seed the way
+        # `includes` is: `Narrowing` asks it what a class object's singleton ancestry holds.
+        file_extends, extends = merge_extend_tables(default_scope, root)
+        methods_table = fold_per_file_extends(file_extends, def_nodes, singleton_def_nodes, seeded_scope)
 
         seeded_scope.with_discovery(
           seeded_scope.discovery.with(
@@ -204,6 +225,7 @@ module Rigor
             discovered_superclasses: superclasses,
             discovered_header_nestings: header_nestings,
             discovered_includes: includes,
+            discovered_extends: extends,
             discovered_method_visibilities: method_visibilities,
             data_member_layouts: data_member_layouts,
             struct_member_layouts: struct_member_layouts
@@ -247,10 +269,20 @@ module Rigor
         merged.freeze
       end
 
+      # Issue #898 — one walk, two consumers: the raw per-file table the #526 method fold reads, and the
+      # same table merged over the cross-file seed for the scope. Returned as a pair so a caller cannot
+      # pair the fold with a table a different parse produced, as {#merge_ancestry_tables} is.
+      def merge_extend_tables(default_scope, root)
+        file_extends = build_discovered_extends(root)
+        merged = default_scope.discovered_extends.merge(
+          file_extends
+        ) { |_class, cross_file, per_file| (cross_file + per_file).uniq }
+        [file_extends, merged]
+      end
+
       # The per-file half of the #526 fold: mutable copies of the merged tables take the extends, and the
       # existence table (already seeded onto the scope) is rebuilt only when the fold touched it.
-      def fold_per_file_extends(root, def_nodes, singleton_def_nodes, seeded_scope)
-        extends = build_discovered_extends(root)
+      def fold_per_file_extends(extends, def_nodes, singleton_def_nodes, seeded_scope)
         methods_table = seeded_scope.discovered_methods
         return methods_table if extends.empty?
 
@@ -1476,7 +1508,7 @@ module Rigor
       # is a known in-place mutator (`MutationWidening`'s tables) or a plain attribute/index writer
       # (`name=` / `[]=`). Non-mutating reads never register, so `VERSION`-style constants keep their fold.
       #
-      # @return [Hash{Symbol => Object}] `:constants` — a Set of candidate qualified names (each mutation
+      # @return `:constants` — a Set of candidate qualified names (each mutation
       #   contributes every lexical-resolution candidate, `A::B::C` outward to bare `C`, mirroring how the
       #   reads resolve); `:cvars` — `{class_name => Set[Symbol]}`.
       def collect_literal_receiver_mutations(root)
@@ -1522,19 +1554,35 @@ module Rigor
         when Prism::ConstantReadNode
           constant_mutation_candidates(receiver.name.to_s, nesting, census[:constants])
         when Prism::ConstantPathNode
-          # The lexical candidates a PATH spelling reaches, for the same reason the bare arm above takes
-          # them: `Holder::TABLE[:k] = 1` inside `module Admin` mutates whatever `Holder::TABLE` resolves
-          # to there, and since [#690](https://github.com/rigortype/rigor/issues/690) the write accumulator
-          # keys that entry `Admin::Holder::TABLE`. Recording only the as-written name left the mutated
-          # constant matched by nothing and its closed empty shape intact — the very fold #540 exists to
-          # retract. Over-recording only widens, which is the direction this census is allowed to err in.
-          full = Source::ConstantPath.qualified_name_or_nil(receiver)
-          constant_mutation_candidates(full, nesting, census[:constants]) if full
+          path_mutation_candidates(receiver, nesting, census[:constants])
         when Prism::ClassVariableReadNode
           census[:cvars][qualified_prefix.join("::")] << receiver.name unless qualified_prefix.empty?
         end
       end
 
+      # The lexical candidates a PATH spelling reaches, for the same reason the bare arm takes them:
+      # `Holder::TABLE[:k] = 1` inside `module Admin` mutates whatever `Holder::TABLE` resolves to there,
+      # and since [#690](https://github.com/rigortype/rigor/issues/690) the write accumulator keys that
+      # entry `Admin::Holder::TABLE`. Recording only the as-written name left the mutated constant matched
+      # by nothing and its closed empty shape intact — the very fold #540 exists to retract. Over-recording
+      # only widens, which is the direction this census is allowed to err in.
+      #
+      # A ROOTED receiver is the one spelling that reaches no lexical candidate at all, so widening them is
+      # not erring in the allowed direction but discarding precision the code hands over
+      # ([#703](https://github.com/rigortype/rigor/issues/703)): `::Table::ROWS[k] = 1` names the top-level
+      # constant unconditionally, so the sibling `Admin::Table::ROWS` a bare spelling would also reach is
+      # untouched and keeps its empty-shape fold. This is the exemption #690 established on the WRITE side
+      # ({#constant_path_write_key}), which the two arms have to agree on: the strict render drops the root
+      # marker, so the rooted and unrooted spellings are indistinguishable by name alone.
+      def path_mutation_candidates(receiver, nesting, into)
+        full = Source::ConstantPath.qualified_name_or_nil(receiver)
+        return if full.nil?
+
+        return into << full if Source::ConstantPath.rooted?(receiver)
+
+        constant_mutation_candidates(full, nesting, into)
+      end
+
       # The receiver a node mutates, or nil when the node is not a mutation.
       def mutating_receiver_of(node)
         case node
@@ -1605,29 +1653,117 @@ module Rigor
       # `Scope#published_constant?`: a project-published constant the analysed file also assigns is one its
       # author can see, so the truthiness rules keep firing on it. Both are seeded here, where the per-file
       # table is still separable from the project seed it is about to merge over.
+      # Issue #667 — the alias table rides the same census and the same gate, because it answers the third
+      # half of the same question: which of THIS file's own constant names carry a value the author never
+      # saw. One census call now feeds both sets.
       def seed_constant_tables(seeded_scope, default_scope, in_source_constants, root)
         merged = merge_seeded_constants(default_scope.in_source_constants, in_source_constants)
+        published = default_scope.published_constant_names
+        census = published.empty? ? nil : constant_write_census(root)
         seeded_scope.with_discovery(
-          seeded_scope.discovery.with(in_source_constants: merged,
-                                      local_constant_names: local_constant_name_set(root, default_scope))
+          seeded_scope.discovery.with(
+            in_source_constants: merged,
+            local_constant_names: local_constant_name_set(census, published),
+            published_constant_alias_names: published_constant_alias_name_set(census, published)
+          )
         )
       end
 
       # The QUALIFIED names this file assigns that the project also published, frozen. Read from the same
-      # {#constant_writes_for_file} census the cross-file table is built from, not from the typed per-file
+      # {#constant_write_census} the cross-file table is built from, not from the typed per-file
       # table: the typed walk cannot see a multi-assign / `self::` / operator-write target, so deriving the
       # exemption from it would be a second source of truth blind to exactly the forms the census exists to
       # catch. Gated on the project having published anything at all, so a project with no cross-file value
       # constants pays no extra walk and allocates nothing; the result is filtered to the published names, so
       # what it holds is bounded by what the exemption can ever be asked about.
-      def local_constant_name_set(root, default_scope)
-        published = default_scope.published_constant_names
-        return Scope::DiscoveryIndex::EMPTY.local_constant_names if published.empty?
-
-        names = constant_writes_for_file(root).keys.select { |name| published.include?(name.split("::").last) }
+      #
+      # It reads the census's `declared` half rather than its keys ([#710](https://github.com/rigortype/rigor/issues/710)).
+      # The two consumers want opposite answers about a write whose base nothing names: the conflict rule asks
+      # "could another file's value for this name be wrong?" — yes, so the name stays censused — and this
+      # exemption asks "did this file declare it?" — no, `[Foo].each { |k| k::X = 1 }` declares `Foo::X`.
+      # Granting it un-withheld `flow.always-truthy-condition` for a name the file never wrote.
+      def local_constant_name_set(census, published)
+        return Scope::DiscoveryIndex::EMPTY.local_constant_names if census.nil?
+
+        names = census.declared.select { |name| published.include?(name.split("::").last) }
         names.empty? ? Scope::DiscoveryIndex::EMPTY.local_constant_names : names.to_set.freeze
       end
 
+      # Issue #667 — the last segments of the constants this file assigns straight from a constant the
+      # project published and this file does NOT itself declare. `MODE2 = AppConfig::MODE` renames a foreign
+      # declaration, so the local-declaration exemption releasing `MODE2` is the wrong answer: the author can
+      # see the alias but not the value. The source's own foreignness is asked against the census's
+      # `declared` half — the same suffix relation `Scope#published_constant?` uses — so a same-file
+      # `MODE2 = MODE1` pair stays fully reportable.
+      def published_constant_alias_name_set(census, published)
+        return Scope::DiscoveryIndex::EMPTY.published_constant_alias_names if census.nil?
+
+        names = census.aliases.filter_map do |target, source|
+          next unless published.include?(source.split("::").last)
+          next if census_declares_constant?(census.declared, source)
+
+          target.split("::").last
+        end
+        names.empty? ? Scope::DiscoveryIndex::EMPTY.published_constant_alias_names : names.to_set.freeze
+      end
+
+      def census_declares_constant?(declared, reference)
+        return true if declared.include?(reference)
+
+        suffix = "::#{reference}"
+        declared.any? { |name| name.end_with?(suffix) }
+      end
+
+      # Issue #667 — `{class name => Set[ivar name]}` for an ivar whose class-ivar seed is a copy of a
+      # foreign published constant (`@mode = AppConfig::MODE` in `initialize`). The cross-method half of the
+      # copy provenance: the write and the `@mode == :production` that reads it sit in different method
+      # bodies, so no flow edge connects them and the fact has to be censused per class, exactly as the
+      # ADR-58 nil seed it rides beside is. Runs only when the project published something.
+      def seed_published_constant_ivars(seeded_scope, root)
+        return seeded_scope if seeded_scope.published_constant_names.empty?
+
+        table = {}
+        walk_published_constant_ivars(root, [], seeded_scope, table)
+        return seeded_scope if table.empty?
+
+        seeded_scope.with_discovery(
+          seeded_scope.discovery.with(published_constant_ivars: table.transform_values(&:freeze).freeze)
+        )
+      end
+
+      def walk_published_constant_ivars(node, qualified_prefix, scope, table)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          child_prefix = Source::ConstantPath.declaration_prefix(qualified_prefix, node.constant_path)
+          if child_prefix
+            walk_published_constant_ivars(node.body, child_prefix, scope, table) if node.body
+            return
+          end
+        when Prism::DefNode
+          # A `def self.…` body writes the singleton's ivars, which take no instance seed at all.
+          return unless node.receiver.nil?
+        when Prism::InstanceVariableWriteNode
+          record_published_constant_ivar(node, qualified_prefix, scope, table)
+        end
+
+        node.rigor_each_child { |child| walk_published_constant_ivars(child, qualified_prefix, scope, table) }
+      end
+
+      # The class-ivar accumulator (already seeded when this runs) is the pre-gate: an ivar whose seed is not
+      # a `Type::Constant` can never fold a predicate, so there is nothing for the mark to withhold and the
+      # guard's one interprocedural hop is not worth paying for it.
+      def record_published_constant_ivar(node, qualified_prefix, scope, table)
+        return if qualified_prefix.empty?
+
+        class_name = qualified_prefix.join("::")
+        return unless scope.class_ivars_for(class_name)[node.name].is_a?(Type::Constant)
+        return unless Analysis::CheckRules::PublishedConstantGuard.rooted?(node.value, scope)
+
+        (table[class_name] ||= Set.new) << node.name
+      end
+
       def merge_seeded_constants(seeded, per_file)
         return per_file if seeded.nil? || seeded.empty?
 
@@ -1707,19 +1843,40 @@ module Rigor
       # there is still the enclosing declaration's and every walk below this stays as it was).
       #
       # {OPAQUE_SELF} where the new `self` reaches no class or module name: a `class_eval` receiver that is
-      # not a static constant path, an {OPAQUE_SELF_BLOCK_CALLS} body, and the `Class.new { … }` /
-      # `Module.new` / `Struct.new` / `Data.define` block, whose class is named only by a constant write the
-      # walk would have to thread down to it. Declining there costs a resolution the engine never had; naming
-      # the LEXICAL enclosure instead is the guess that fires, because it is the one name Ruby is guaranteed
-      # NOT to have written.
-      def rebound_block_self(node, qualified_prefix, default_scope = nil)
+      # not a static constant path, an {OPAQUE_SELF_BLOCK_CALLS} body, and a `Class.new { … }` /
+      # `Module.new` / `Struct.new` / `Data.define` block no enclosing constant write names. Declining there
+      # costs a resolution the engine never had; naming the LEXICAL enclosure instead is the guess that fires,
+      # because it is the one name Ruby is guaranteed NOT to have written.
+      #
+      # `meta_owner` is the name such a write DOES give the block's class, threaded one hop down by the
+      # caller ({#meta_new_block_owner}) ([#710](https://github.com/rigortype/rigor/issues/710)). It is
+      # supplied only by the publication census; the typed walk returns at a `ConstantWriteNode` without
+      # descending into its rvalue, so no `self::` write inside one reaches that walk at all.
+      def rebound_block_self(node, qualified_prefix, default_scope = nil, meta_owner = nil)
         return nil unless node.is_a?(Prism::CallNode) && node.block.is_a?(Prism::BlockNode)
-        return OPAQUE_SELF if OPAQUE_SELF_BLOCK_CALLS.include?(node.name) || meta_new_constant_rvalue?(node)
+        return OPAQUE_SELF if OPAQUE_SELF_BLOCK_CALLS.include?(node.name)
+        return meta_owner || OPAQUE_SELF if meta_new_constant_rvalue?(node)
         return nil unless SELF_REBINDING_EVAL_CALLS.include?(node.name)
 
         eval_receiver_self(node.receiver, qualified_prefix, default_scope)
       end
 
+      # Issue #710 — the qualified name a `Klass = Class.new { … }` gives the block's class, or nil when
+      # `node` is not that form. Ruby names the constructed class after the constant it is first assigned to,
+      # so `self::X = 7` in the block writes `Klass::X` and nothing about it is opaque. The recognition is
+      # {#meta_new_block_body}'s, shared with the block-as-method walk.
+      #
+      # A constant PATH write (`N::Made = Class.new { … }`) keeps the opaque answer even though that recognition
+      # now takes it ([#703](https://github.com/rigortype/rigor/issues/703)). This census keys a path write AS
+      # WRITTEN ({#constant_path_write_name}) rather than through the nesting, so naming the block's class here
+      # would publish a `self::X = …` inside it under a name Ruby does not give it; declining suppresses the
+      # name instead, which is the gradual direction. Moving it belongs with moving the census's own path key.
+      def meta_new_block_owner(node, qualified_prefix)
+        return nil unless node.is_a?(Prism::ConstantWriteNode) && meta_new_block_body(node)
+
+        qualified_write_name(qualified_prefix, node.name.to_s)
+      end
+
       # The `self` a `Recv.class_eval { … }` block runs under. An implicit or literal `self` receiver leaves
       # `self` where it was — nil, so nothing about the walk changes. A static constant path resolves the way
       # a path write's own namespace resolves ({#resolved_write_namespace}); anything else is opaque. A nil
@@ -1944,7 +2101,7 @@ module Rigor
           end
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       # Combined `walk_methods` + `walk_def_nodes` descent. The two walks had identical class / module / singleton-class
       # / meta-block traversals and both stopped at `DefNode`; the only divergences are leaf actions (recorded into the
       # right accumulator) and the original `walk_methods` returning at `AliasMethodNode` (its symbol-only children
@@ -1972,9 +2129,9 @@ module Rigor
               return
             end
           end
-        when Prism::ConstantWriteNode
-          if meta_new_block_body(node)
-            child_prefix = qualified_prefix + [node.name.to_s]
+        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+          child_prefix = meta_new_body_prefix(node, qualified_prefix)
+          if child_prefix
             record_meta_members(node.value, child_prefix, methods_acc)
             walk_methods_and_def_nodes(meta_new_block_body(node), child_prefix, false, methods_acc, def_nodes_acc,
                                        source_path)
@@ -2087,7 +2244,7 @@ module Rigor
           Source::ConstantPath.qualified_name(expression.target)
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       # v0.1.2 — when a `Const = Data.define(*sym) do ... end` / `Const = Struct.new(*sym) do ... end` constant write
       # carries a block, the block body holds method overrides whose canonical class is `Const`. Survey item (e)
@@ -2095,8 +2252,15 @@ module Rigor
       # ADR-16 Tier A "block-as-method" idiom at constant-write position. Returns the block body node (a
       # `Prism::StatementsNode`) when the rvalue matches; nil otherwise. Used by `walk_methods` / `walk_def_nodes` to
       # push `Const` onto the qualified prefix before recursing.
+      #
+      # Issue [#703](https://github.com/rigortype/rigor/issues/703) — a PATH write is the same idiom.
+      # `Holder::Thing = Struct.new(:a) do … end` inside a module is ordinary Ruby, and declining it here lost the
+      # factory registration, the member layout and the block's own defs together: the constant answered
+      # `singleton(Struct)` and its instance `Struct`, a class RBS knows, so every member read and every override
+      # call fired `call.undefined-method` on code Ruby runs. The name the write gives the class is
+      # {#meta_new_child_prefix}'s, so every walk that pushes it agrees.
       def meta_new_block_body(node)
-        return nil unless node.is_a?(Prism::ConstantWriteNode)
+        return nil unless node.is_a?(Prism::ConstantWriteNode) || node.is_a?(Prism::ConstantPathWriteNode)
 
         rvalue = node.value
         return nil unless rvalue.is_a?(Prism::CallNode)
@@ -2108,6 +2272,36 @@ module Rigor
         rvalue.block&.body
       end
 
+      # The qualified prefix a meta-new constant write names its class under, given the lexical prefix the write
+      # sits in — the segments every scope-free pre-pass pushes before descending into the block, and the key
+      # {#record_meta_new_constant?} files the discovered class under. Nil for a target that is neither form.
+      #
+      # A PATH write takes exactly what a compact `class Holder::Thing` header at the same position takes
+      # ({Source::ConstantPath.declaration_prefix}), rooted reset included. These pre-passes run before any scope
+      # exists, so the namespace cannot be resolved the way {#constant_path_write_key} resolves it for the typed
+      # table — but the two land on the same name anyway, because registering `Admin::Holder::Thing` here is what
+      # makes `Admin::Holder` a namespace {#resolved_write_namespace} knows.
+      #
+      # Where the namespace is NOT under the enclosure — a top-level `Loner` written as `Loner::Made = Struct.new(…)`
+      # inside `module Admin` — that qualification is a guess, and {#synthesize_namespace_prefixes} then answers a
+      # read of `Loner` there with the `Admin::Loner` it invented. That is the same answer the equivalent
+      # `class Loner::Made` header has always produced, from the same two functions: the two spellings of one
+      # declaration stay consistent rather than one of them carrying a second approximation of its own.
+      def meta_new_child_prefix(node, qualified_prefix)
+        case node
+        when Prism::ConstantWriteNode
+          qualified_prefix + [node.name.to_s]
+        when Prism::ConstantPathWriteNode
+          Source::ConstantPath.declaration_prefix(qualified_prefix, node.target)
+        end
+      end
+
+      # {#meta_new_child_prefix} for the walks that only care about a write carrying a BLOCK — nil where the rvalue
+      # opens none, so a block-less `Thing = Struct.new(:a)` keeps falling through to the ordinary child descent.
+      def meta_new_body_prefix(node, qualified_prefix)
+        meta_new_block_body(node) && meta_new_child_prefix(node, qualified_prefix)
+      end
+
       # `class Foo < Data.define(:a, :b)` / `class Bar < Struct.new(:x)` synthesizes reader methods (`a`, `b`, `x`) on
       # the subclass that no `def` / `attr_*` declares. Register them in the discovered-methods existence table so an
       # implicit-self read of a member inside the class body is known to exist — both for the existing undefined-method
@@ -2283,9 +2477,9 @@ module Rigor
               return
             end
           end
-        when Prism::ConstantWriteNode
-          if meta_new_block_body(node)
-            child_prefix = qualified_prefix + [node.name.to_s]
+        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+          child_prefix = meta_new_body_prefix(node, qualified_prefix)
+          if child_prefix
             walk_singleton_body(meta_new_block_body(node), child_prefix, false, accumulator)
             return
           end
@@ -2450,7 +2644,7 @@ module Rigor
       # the enclosing cref — `[]` for the first spelling, `["Admin"]` for the second. A class reopened under two
       # spellings keeps the LAST one walked, matching how `superclasses` itself merges.
       #
-      # @return [Array(Hash{String=>String}, Hash{String=>Array[String]})] `[superclasses, header_nestings]`
+      # @return })] `[superclasses, header_nestings]`
       def build_superclass_tables(root, source_path = nil)
         accumulator = { superclasses: {}, header_nestings: {} }
         walk_class_superclasses(root, [], accumulator, source_path)
@@ -2489,7 +2683,8 @@ module Rigor
       # prefix without resetting Ruby's nesting ([#708](https://github.com/rigortype/rigor/issues/708)).
       def record_declaration_ancestry(node, nesting, child_prefix, accumulator)
         full = child_prefix.join("::")
-        add_header_nesting(accumulator[:header_nestings], full, nesting) if declares_ancestor_name?(node)
+        names = declared_ancestor_names(node)
+        add_header_nesting(accumulator[:header_nestings], full, nesting, names) if names
         return unless node.is_a?(Prism::ClassNode)
 
         accumulator[:superclasses][full] = recorded_ancestor_name(node.superclass) if node.superclass
@@ -2513,8 +2708,10 @@ module Rigor
         "::#{name}"
       end
 
-      # Whether this declaration SITE writes an ancestor name — a superclass in its header, or a mixin call
-      # in its own body. Only such a site contributes a header nesting.
+      # The ancestor names this declaration SITE writes — the superclass in its header, and every mixin
+      # argument in its own body — or nil when the site writes none. Only a site that writes one
+      # contributes a header nesting, and the names are what key it: Ruby resolves each ancestor name in
+      # the cref of the site that WROTE it, and a class's sites need not agree on that cref.
       #
       # Issue #708's review: a per-CLASS union of every site's chain is wrong for a rooted reopen inside
       # another namespace. `class ::Foo; def extra = 1; end` written in `module Outer` contributed `["Outer"]`
@@ -2522,71 +2719,128 @@ module Rigor
       # Ruby never looks at, ahead of the right one, on a site that named no ancestor at all. A site that
       # writes no ancestor name has no ancestor for its cref to govern, so it has nothing to say here.
       #
+      # Issue #728: dropping those sites was necessary and not sufficient. When the rooted reopen genuinely
+      # names a mixin — `class ::Foo; include Helper; end` in `module Outer` — the site is recorded, and a
+      # per-class union then hands its `["Outer"]` to `Foo`'s superclass `Base` as well, which is the same
+      # `Outer::Base` on the same repro. Keying by the written name is what separates them: `Base` resolves
+      # in the empty chain of the top-level site that wrote `< Base`, `Helper` in the `["Outer"]` chain of
+      # the site that wrote `include Helper`, which is what Ruby does for each independently.
+      #
       # This keeps what the union was FOR. It was added because last-writer-wins let one rails TEST file
       # reopening `ActiveRecord::Relation` compactly beat the library declaration, costing the class all nine
-      # of its `include`d modules; that reopen writes no ancestor name either, so it now contributes nothing
+      # of its `include`d modules; that reopen writes no ancestor name either, so it contributes nothing
       # rather than winning — the protection comes from the recording rule instead of from a merge rule.
-      # Two sites that BOTH write ancestor names still union, which is the conservative reading of an
-      # ambiguity one table cannot represent.
       #
       # The mixin scan counts only a call whose `self` is the declaration itself, so it stops at every
       # construct that rebinds `self`: a nested `class` / `module` (that body's calls belong to the nested
       # class), a `class << self` body, and a block `#rebound_block_self` classifies as rebinding — the
       # `Class.new` / `Module.new` / `Struct.new` / `Data.define` and `class_eval` family. An `include`
       # written in any of those attaches to something other than this class, so treating it as this site's
-      # ancestor name reinstates exactly the defect above with a different spelling.
+      # ancestor name reinstates exactly the defect above with a different spelling. {#walk_class_includes}
+      # classifies the same shapes the same way since [#749](https://github.com/rigortype/rigor/pull/749),
+      # so the two walks agree on which site owns a mixin.
       #
-      # It stays structural rather than exhaustive: `self.include M` and `send(:include, M)` record nothing
-      # and fall back to the peel, which is this walk's pre-#682 answer and never a new firing — and the
-      # includes walk misses those two as well, so the class's ancestry agrees. For the REBINDING shapes it
-      # does not: `walk_class_includes` still charges an `include` written in a `class << self` body or a
-      # `Class.new` block to the enclosing class, where Ruby attaches it elsewhere. This scan is right and
-      # that one is wrong; the divergence is [#728](https://github.com/rigortype/rigor/issues/728).
-      def declares_ancestor_name?(node)
-        return true if node.is_a?(Prism::ClassNode) && node.superclass
-
+      # It stays structural rather than exhaustive: `self.include M` and `send(:include, M)` are recorded by
+      # neither walk, so the class's ancestry agrees. `Recv.class_eval { include M }` is the one shape where
+      # they diverge in the surviving direction — the includes walk names `Recv`, this one cannot see the
+      # site from `Recv`'s own declaration — and that is what {#add_header_nesting}'s unkeyed entry answers.
+      def declared_ancestor_names(node)
+        names = []
+        superclass = node.is_a?(Prism::ClassNode) ? node.superclass : nil
+        if superclass
+          recorded = recorded_ancestor_name(superclass)
+          names << recorded if recorded
+        end
         body = node.body
-        body ? mixin_call_in_body?(body) : false
+        mixin = body ? collect_mixin_names(body, names) : false
+        return names if superclass || mixin
+
+        nil
       end
 
-      def mixin_call_in_body?(node)
+      # Appends each mixin argument this body names to `names`, and answers whether it writes a mixin call
+      # at all — a `include some_method` writes one while naming nothing renderable, and the site still owns
+      # a chain for the names it does write. Arguments are rendered exactly as {#record_mixin_call} renders
+      # them, so a name recorded here is the same String the includes table stores and the resolver asks for.
+      def collect_mixin_names(node, names)
         return false unless node.is_a?(Prism::Node)
         return false if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode) ||
                         node.is_a?(Prism::SingletonClassNode)
-        return true if node.is_a?(Prism::CallNode) && node.receiver.nil? && MIXIN_CALL_NAMES.include?(node.name)
 
+        found = mixin_call?(node)
+        record_mixin_names(node, names) if found
         rebinds = rebound_block_self(node, EMPTY_PREFIX)
         node.rigor_each_child do |child|
           next if rebinds && child.is_a?(Prism::BlockNode)
 
-          return true if mixin_call_in_body?(child)
+          found = true if collect_mixin_names(child, names)
         end
-        false
+        found
       end
 
-      # Adds one declaration site's header nesting to the per-class table, UNIONING it with what a
-      # previous site recorded, most-qualified first. A class reopened under two spellings has two header
-      # nestings while the ancestor names its sites write collapse into ONE table, so taking either site's
-      # chain alone drops a candidate the other one had — and dropping a candidate drops an ancestor edge,
-      # the false-positive direction. Rails is the corpus case: `activerecord` declares
-      # `ActiveRecord::Relation` inside `module ActiveRecord` and one test file reopens it as the compact
-      # `class ActiveRecord::Relation`, so last-writer-wins cost the library class nine included modules.
-      # The union is the conservative reading of an ambiguity the per-class table cannot represent: it
-      # degrades such a class to the pre-fix candidate list rather than to a shorter one.
-      def add_header_nesting(table, name, entries)
-        existing = table[name]
-        return table[name] = entries.freeze if existing.nil?
-        return if entries.all? { |entry| existing.include?(entry) }
+      def mixin_call?(node)
+        node.is_a?(Prism::CallNode) && node.receiver.nil? && MIXIN_CALL_NAMES.include?(node.name)
+      end
 
-        table[name] = (existing | entries).sort_by { |entry| [-entry.split("::").size, entry] }.freeze
+      def record_mixin_names(node, names)
+        node.arguments&.arguments&.each do |arg|
+          mod = Source::ConstantPath.qualified_name(arg)
+          names << mod if mod
+        end
+      end
+
+      # Adds one declaration site's header nesting to the per-class table, under each ancestor NAME the site
+      # wrote plus one unkeyed entry.
+      #
+      # Issue #728 — the keyed entries are the answer proper: `Foo`'s superclass `Base` and the `Helper` a
+      # rooted reopen of `Foo` includes are resolved in different crefs by Ruby, and a per-class chain can
+      # only give them the same one. Two sites that write the SAME name still union, most-qualified first,
+      # since one table cannot say which of two spellings a later reader meant.
+      #
+      # The unkeyed entry ({Scope::DiscoveryIndex::UNKEYED_HEADER_NESTING}) is that union over every
+      # ancestor-naming site, and it
+      # answers an ancestor name no site recorded under its own key — a mixin the includes walk attributes
+      # to a class from OUTSIDE its declaration (`Recv.class_eval { include M }`), or a dynamic `include`
+      # argument this walk cannot render. It is the pre-#728 answer, so such a name is unchanged rather than
+      # degraded, and a shorter list there would drop an ancestor edge, the false-positive direction.
+      def add_header_nesting(table, name, entries, ancestor_names)
+        bucket = { Scope::DiscoveryIndex::UNKEYED_HEADER_NESTING => entries }
+        ancestor_names.each { |raw| bucket[raw] = entries }
+        merge_header_nesting_bucket(table, name, bucket)
       end
 
       # {#add_header_nesting} over a whole table, for the per-file and cross-file merges.
       def merge_header_nestings(target, incoming)
-        incoming.each { |name, entries| add_header_nesting(target, name, entries) }
+        incoming.each { |name, bucket| merge_header_nesting_bucket(target, name, bucket) }
         target
       end
 
+      # Merges one class's bucket into the table WITHOUT mutating what is already there: a per-file table is
+      # merged into a shallow `dup` of the cross-file seed, whose buckets the seed still owns.
+      def merge_header_nesting_bucket(table, name, incoming)
+        existing = table[name]
+        return table[name] = frozen_bucket(incoming) if existing.nil?
+
+        merged = existing.dup
+        incoming.each do |raw, entries|
+          previous = merged[raw]
+          merged[raw] = previous.nil? ? entries.freeze : union_header_nesting(previous, entries)
+        end
+        table[name] = merged.freeze
+      end
+
+      def frozen_bucket(bucket)
+        return bucket if bucket.frozen?
+
+        bucket.each_value(&:freeze).freeze
+      end
+
+      def union_header_nesting(existing, entries)
+        return existing if entries.all? { |entry| existing.include?(entry) }
+
+        (existing | entries).sort_by { |entry| [-entry.split("::").size, entry] }.freeze
+      end
+
       # #319 — `Class.new(Parent) do ... end` names its superclass in the first positional. Recording it under the
       # call site's anonymous name keeps `Parent`'s surface reachable from the block body (whose `self_type` is now
       # `Singleton[<anonymous>]`) and from an instance of the resulting class, so giving the anonymous class an
@@ -2639,8 +2893,9 @@ module Rigor
             walk_data_member_layouts(node.body, child_prefix, accumulator) if node.body
             return
           end
-        when Prism::ConstantWriteNode
-          record_data_member_layout(accumulator, qualified_prefix + [node.name.to_s], node.value)
+        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+          child_prefix = meta_new_child_prefix(node, qualified_prefix)
+          record_data_member_layout(accumulator, child_prefix, node.value) if child_prefix
         end
 
         node.rigor_each_child do |child|
@@ -2689,8 +2944,9 @@ module Rigor
             walk_struct_member_layouts(node.body, child_prefix, accumulator) if node.body
             return
           end
-        when Prism::ConstantWriteNode
-          record_struct_member_layout(accumulator, qualified_prefix + [node.name.to_s], node.value)
+        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+          child_prefix = meta_new_child_prefix(node, qualified_prefix)
+          record_struct_member_layout(accumulator, child_prefix, node.value) if child_prefix
         end
 
         node.rigor_each_child do |child|
@@ -2755,7 +3011,8 @@ module Rigor
           # Issue #728 — `class << self; include M; end` mixes M into the SINGLETON: it contributes class
           # methods, not the instance surface this table feeds. Descending with no owner keeps any nested
           # declaration walked (a `ClassNode` child sets its own owner) while the mixin calls in the
-          # singleton body record nothing, which is what `extends` is for.
+          # singleton body record nothing, which is what `extends` is for — and since #915 the extend walk
+          # does take them, so the form is recorded rather than dropped.
           current_class = nil
         when Prism::CallNode
           record_mixin_call(node, current_class, accumulator)
@@ -2808,13 +3065,16 @@ module Rigor
       # order-sensitivity (only SUBSEQUENT defs become module functions) is deliberately over-approximated
       # — the extra names only suppress `undefined-method` and enable inference on calls that raise at
       # runtime, both the ADR-5-safe direction.
+      #
+      # Issue #915 — plus `class << self; include M; end`, the same singleton ancestor spelled through the
+      # singleton-class body. It folds like an `extend` because Ruby makes it one.
       def build_discovered_extends(root)
         accumulator = {}
         walk_class_extends(root, [], nil, accumulator)
         accumulator.transform_values { |mods| mods.uniq.freeze }.freeze
       end
 
-      def walk_class_extends(node, qualified_prefix, current_class, accumulator)
+      def walk_class_extends(node, qualified_prefix, current_class, accumulator, in_singleton: false)
         return unless node.is_a?(Prism::Node)
 
         case node
@@ -2825,18 +3085,35 @@ module Rigor
             walk_class_extends(node.body, child_prefix, full, accumulator) if node.body
             return
           end
+        when Prism::SingletonClassNode
+          # Issue #915 — `class << self` opens the enclosing declaration's OWN singleton, so an `include`
+          # written in it is the same singleton ancestor an `extend` in the class body would add. Only the
+          # `self` form is followed: `class << obj` names something this walk cannot resolve to a class.
+          # Nested declarations inside the body take the `ClassNode` branch above and reset the flag with
+          # their own owner, so the marker cannot leak past the singleton body it belongs to.
+          in_singleton = node.expression.is_a?(Prism::SelfNode)
+          current_class = nil unless in_singleton
         when Prism::CallNode
-          record_extend_call(node, current_class, accumulator)
+          record_extend_call(node, current_class, accumulator, in_singleton: in_singleton)
         end
 
         node.rigor_each_child do |child|
-          walk_class_extends(child, qualified_prefix, current_class, accumulator)
+          walk_class_extends(child, qualified_prefix, current_class, accumulator, in_singleton: in_singleton)
         end
       end
 
-      def record_extend_call(node, current_class, accumulator)
+      # Inside a `class << self` body the mixin calls are the singleton-side ones and `extend` is not:
+      # `class << self; extend M; end` puts M on the singleton's OWN singleton, one level further out than
+      # anything this table describes, and `module_function` in a singleton body is not the scope toggle
+      # {#build_discovered_extends} over-approximates. So the two arms are disjoint rather than additive.
+      def record_extend_call(node, current_class, accumulator, in_singleton: false)
         return unless current_class && node.receiver.nil?
 
+        if in_singleton
+          record_extend_targets(node, current_class, accumulator) if MIXIN_CALL_NAMES.include?(node.name)
+          return
+        end
+
         case node.name
         when :extend then record_extend_targets(node, current_class, accumulator)
         when :module_function
@@ -2918,9 +3195,9 @@ module Rigor
               return current_visibility
             end
           end
-        when Prism::ConstantWriteNode
-          if meta_new_block_body(node)
-            child_prefix = qualified_prefix + [node.name.to_s]
+        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
+          child_prefix = meta_new_body_prefix(node, qualified_prefix)
+          if child_prefix
             walk_method_visibilities(meta_new_block_body(node), child_prefix, false, :public, accumulator)
             return current_visibility
           end
@@ -3190,9 +3467,7 @@ module Rigor
       # `Singleton[Object]` fallback anyway. The residual leak is `Class`-only (`M.new`, `M.superclass`), which mistypes
       # only code that raises `NoMethodError` at runtime.
       #
-      # @param paths [Array<String>] project file paths.
-      # @param buffer [Rigor::Analysis::BufferBinding, nil]
-      # @return [Hash{String => Rigor::Type::Singleton}]
+      # @param paths — project file paths.
       def discovered_classes_for_paths(paths, buffer: nil)
         accumulator = {}
         paths.each do |path|
@@ -3220,9 +3495,8 @@ module Rigor
       # monkey-patch on a core/stdlib/gem class is called cross-file (ADR-17). First write wins, matching `def_nodes`'
       # own merge order.
       #
-      # @param paths [Array<String>] project file paths.
-      # @param buffer [Rigor::Analysis::BufferBinding, nil]
-      # @return [Hash{Symbol => Hash}]
+      # @param paths — project file paths.
+      # @return
       #   `{ def_nodes:, def_sources:, superclasses:, includes:, class_sources: }`
       def discovered_def_index_for_paths(paths, buffer: nil)
         acc = new_def_index_accumulator
@@ -3246,7 +3520,7 @@ module Rigor
       # all of them (recon §2 dedup). A per-file live index (built + folded, exactly as
       # {#discovered_project_index_incremental}'s changed-file branch) yields the live def nodes the signature
       # reads their parameter structure from.
-      # @return [Hash{Symbol => Object}] `{ def_index:, code_fingerprints:, declaration_signatures: }`.
+      # @return `{ def_index:, code_fingerprints:, declaration_signatures: }`.
       def scan_summary_for_paths(paths, buffer: nil)
         acc = new_def_index_accumulator
         code_fingerprints = {}
@@ -3436,9 +3710,8 @@ module Rigor
       # rescue's real target) contributes nothing to either table. The subset-scoped callers
       # ({IncrementalSession}, `coverage --protection`) keep calling the individual methods unchanged.
       #
-      # @param paths [Array<String>] project file paths.
-      # @param buffer [Rigor::Analysis::BufferBinding, nil]
-      # @return [Hash{Symbol => Object}] `{ classes: Hash, def_index: Hash }`.
+      # @param paths — project file paths.
+      # @return `{ classes: Hash, def_index: Hash }`.
       def discovered_project_index_for_paths(paths, buffer: nil)
         classes = {}
         acc = new_def_index_accumulator
@@ -3451,7 +3724,28 @@ module Rigor
           # Skip files that fail to parse or read; the per-file analyzer surfaces the parse error separately.
           next
         end
-        { classes: classes.freeze, def_index: finalize_def_index(acc) }
+        finalize_project_index(classes, acc)
+      end
+
+      # The shared tail of the two whole-project discovery walks: settles the def-index and re-anchors the
+      # `classes` table it accumulated beside it.
+      def finalize_project_index(classes, acc)
+        def_index = finalize_def_index(acc)
+        { classes: rename_compact_classes(classes, def_index[:compact_header_renames]).freeze,
+          def_index: def_index }
+      end
+
+      # Issue #722 residue 2 — the `classes` table is accumulated beside the def-index rather than inside it,
+      # so it is re-anchored here from the renames the fold settled. The value is rebuilt, not moved: it is a
+      # `Singleton[…]` of the key, and a moved key with the old singleton inside would type `Outer::Leaf` as
+      # `Wrap::Outer::Leaf` at every reference.
+      def rename_compact_classes(classes, renames)
+        return classes if renames.nil? || renames.empty?
+
+        classes.each_with_object({}) do |(name, type), out|
+          renamed = rename_compact_name(renames, name)
+          out[renamed] = renamed == name ? type : Type::Combinator.singleton_of(renamed)
+        end
       end
 
       # ADR-85 WD2 — the incremental cross-file discovery pass. The bundle-driven twin of
@@ -3468,10 +3762,9 @@ module Rigor
       # lazily. On a cold run (`seed_bundles` empty) every file is re-walked, so the index is entirely live —
       # identical to {#discovered_project_index_for_paths} — while the bundles are built for the next run.
       #
-      # @param paths [Array<String>] project file paths, in canonical order.
-      # @param seed_bundles [Hash{String => Hash}] the prior run's per-file bundles, keyed by logical path.
-      # @param buffer [Rigor::Analysis::BufferBinding, nil]
-      # @return [Hash{Symbol => Object}] `{ classes:, def_index:, bundles: }`.
+      # @param paths — project file paths, in canonical order.
+      # @param seed_bundles — the prior run's per-file bundles, keyed by logical path.
+      # @return `{ classes:, def_index:, bundles: }`.
       def discovered_project_index_incremental(paths, seed_bundles:, buffer: nil)
         classes = {}
         acc = new_def_index_accumulator
@@ -3500,7 +3793,7 @@ module Rigor
           # Skip files that fail to parse / read; the per-file analyzer surfaces the parse error separately.
           next
         end
-        { classes: classes.freeze, def_index: finalize_def_index(acc), bundles: bundles }
+        finalize_project_index(classes, acc).merge(bundles: bundles)
       end
 
       # Builds ONE file's isolated def-index contribution (live `Prism::DefNode`s) by folding it into a fresh
@@ -3567,6 +3860,9 @@ module Rigor
         accumulate_module_lists(acc[:includes], file_index[:includes])
         accumulate_module_lists(acc[:extends], file_index[:extends] || {})
         file_index[:class_sources].each { |cn, files| (acc[:class_sources][cn] ||= Set.new).merge(files) }
+        # Issue #722 residue 2 — a pre-#722 seed bundle carries no candidates; the SCHEMA bump makes such a
+        # blob a cold rebuild, but default so any in-flight fold stays total.
+        acc[:compact_headers].merge!(file_index[:compact_headers] || {})
         acc[:data_member_layouts].merge!(file_index[:data_member_layouts])
         acc[:struct_member_layouts].merge!(file_index[:struct_member_layouts])
       end
@@ -3605,6 +3901,9 @@ module Rigor
           method_visibilities: file_index[:method_visibilities],
           methods: file_index[:methods],
           class_source_names: file_index[:class_sources].keys,
+          # Issue #722 residue 2 — plain data, so the bundle stays Marshal-clean and a warm incremental file
+          # re-anchors its compact headers the way a cold walk of it does.
+          compact_headers: file_index[:compact_headers],
           # Issue #644 — the file's publication census (`name => [literal] | :unpublishable`; the path is
           # the bundle key). Plain data, so the bundle stays Marshal-clean.
           constant_writes: file_index[:constant_writes].transform_values { |by_path| by_path.values.first },
@@ -3632,6 +3931,7 @@ module Rigor
           method_visibilities: bundle[:method_visibilities],
           methods: bundle[:methods],
           class_sources: bundle[:class_source_names].to_h { |name| [name, Set[path]] },
+          compact_headers: bundle[:compact_headers] || {},
           # Issue #644 — a pre-#644 bundle carries no census; the SCHEMA bump makes such a blob a cold
           # rebuild, but default so any in-flight fold stays total.
           constant_writes: (bundle[:constant_writes] || {}).transform_values { |descriptor| { path => descriptor } },
@@ -3669,12 +3969,19 @@ module Rigor
           singleton_def_nodes: {}, def_sources: {}, singleton_def_sources: {},
           superclasses: {}, header_nestings: {}, includes: {}, extends: {}, method_visibilities: {}, methods: {},
           class_sources: {},
+          # Issue #722 residue 2 — compact-header re-anchor candidates, adjudicated in {#finalize_def_index}.
+          compact_headers: {},
           constant_writes: {},
           data_member_layouts: {}, struct_member_layouts: {} }
       end
 
       # Post-processes and freezes a fully-folded def-index accumulator.
       def finalize_def_index(acc)
+        # Issue #722 residue 2 — settle the compact-header keys FIRST: every whole-project pass below reads
+        # class-keyed tables, and the renames are only knowable now that `class_sources` spans the project.
+        renames = compact_header_renames(acc[:compact_headers] || {}, acc[:class_sources].keys.to_set)
+        apply_compact_header_renames!(acc, renames) unless renames.empty?
+        acc[:compact_header_renames] = renames
         # Issue #644 — resolve the cross-file constant-reassignment rule here, where the whole project's
         # write census is known, and turn the surviving literals into their published `Type::Constant`.
         acc[:constant_values], acc[:constant_sources] = finalize_constant_writes(acc[:constant_writes])
@@ -3733,7 +4040,8 @@ module Rigor
         merge_header_nestings(acc[:header_nestings], header_nestings)
         accumulate_module_lists(acc[:includes], includes)
         accumulate_module_lists(acc[:extends], build_discovered_extends(root))
-        record_class_sources(acc[:class_sources], path, root, superclasses, includes, file_def_nodes)
+        record_class_sources(acc[:class_sources], path, root, superclasses, includes, file_def_nodes,
+                             acc[:compact_headers])
         merge_constant_literal_tables(acc, root, path)
         merge_class_keyed_index_tables(acc, root, file_methods)
         merge_member_layout_tables(acc, root)
@@ -3773,9 +4081,9 @@ module Rigor
       # ancestry edges. {Scope#superclass_of} / {Scope#includes_of} record this set when resolving the edge during
       # dependency recording (ADR-46). The class-declaration walk (`collect_class_decls`) catches bodyless / def-less
       # reopenings the other three builders miss.
-      def record_class_sources(class_sources, path, root, superclasses, includes, file_def_nodes)
+      def record_class_sources(class_sources, path, root, superclasses, includes, file_def_nodes, compacts = nil)
         names = Set.new
-        collect_class_decls(root, [], decls = {})
+        collect_class_decls(root, [], decls = {}, compacts)
         names.merge(decls.keys)
         names.merge(superclasses.keys)
         names.merge(includes.keys)
@@ -3823,10 +4131,25 @@ module Rigor
       #
       # A name written TWICE in one file is unpublishable too, which is what makes a conditional
       # `X = :a if c` / `X = :b` pair gradual rather than pinned to whichever arm the walk saw first.
-      def constant_writes_for_file(root)
-        writes = {}
-        walk_constant_write_census(root, [], writes, Set.new)
-        writes
+      def constant_writes_for_file(root) = constant_write_census(root).writes
+
+      # The tables one file's publication census fills in a single walk, carried together so the walk's two
+      # `self`-tracking parameters stay within the signature budget. `writes` is the census itself; `seen`
+      # the names already recorded, so a repeat write retracts whatever either rvalue was; `declared` the
+      # subset whose write NAMES its target, which is the only half {Scope#local_constant_names} may exempt
+      # ([#710](https://github.com/rigortype/rigor/issues/710)).
+      # `aliases` is `{qualified target name => the constant reference its rvalue names}` for the one
+      # unpublishable rvalue shape whose provenance is still knowable ([#667](https://github.com/rigortype/rigor/issues/667)):
+      # a plain `MODE2 = AppConfig::MODE`. The census cannot publish a VALUE for it — resolving the source
+      # is the typed walk's job, not this syntactic one — but it can record that the name is a rename of
+      # another, which is all the withholding guard needs.
+      CensusTables = Data.define(:writes, :seen, :declared, :aliases)
+      private_constant :CensusTables
+
+      def constant_write_census(root)
+        tables = CensusTables.new(writes: {}, seen: Set.new, declared: Set.new, aliases: {})
+        walk_constant_write_census(root, [], tables)
+        tables
       end
 
       # Mirrors {#walk_constant_writes}'s traversal for the forms it shares — the lexical class/module prefix
@@ -3835,60 +4158,66 @@ module Rigor
       # `||=` constant write, a `ConstantTargetNode` under a `MultiWriteNode` (`A, B = :x, :y`), a `self::X =`
       # whose target renders no qualified name, and the inner write of a chain (`C = D = :x`), which is why a
       # `ConstantWriteNode` descends into its own rvalue instead of returning.
-      def walk_constant_write_census(node, qualified_prefix, writes, seen, self_owner = nil)
+      def walk_constant_write_census(node, qualified_prefix, tables, self_owner = nil, meta_owner = nil)
         return unless node.is_a?(Prism::Node)
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
           child_prefix = Source::ConstantPath.declaration_prefix(qualified_prefix, node.constant_path)
           if child_prefix
-            walk_constant_write_census(node.body, child_prefix, writes, seen) if node.body
+            walk_constant_write_census(node.body, child_prefix, tables) if node.body
             return
           end
         else
-          census_constant_write(node, qualified_prefix, writes, seen, self_owner)
+          census_constant_write(node, qualified_prefix, tables, self_owner)
         end
 
-        rebound = rebound_block_self(node, qualified_prefix)
+        rebound = rebound_block_self(node, qualified_prefix, nil, meta_owner)
+        # A `ConstantWriteNode`'s only child is its rvalue, so this reaches exactly the call whose block the
+        # constant names — and nil everywhere else, leaving every other descent as it was.
+        child_meta_owner = meta_new_block_owner(node, qualified_prefix)
         node.rigor_each_child do |child|
           owner = rebound && child.is_a?(Prism::BlockNode) ? rebound : self_owner
-          walk_constant_write_census(child, qualified_prefix, writes, seen, owner)
+          walk_constant_write_census(child, qualified_prefix, tables, owner, child_meta_owner)
         end
       end
 
       # Censuses `node` when it is any constant-assigning form. Only a plain `ConstantWriteNode` /
       # `ConstantPathWriteNode` can contribute a VALUE; every other form is recorded unpublishable, which
       # suppresses publication of the name exactly as a second file's write would.
-      def census_constant_write(node, qualified_prefix, writes, seen, self_owner = nil)
+      def census_constant_write(node, qualified_prefix, tables, self_owner = nil)
         case node
         when Prism::ConstantWriteNode
           record_constant_write_census(qualified_write_name(qualified_prefix, node.name.to_s),
-                                       constant_literal_value(node.value), writes, seen)
+                                       constant_literal_value(node.value), tables,
+                                       alias_of: constant_alias_source(node.value))
         when Prism::ConstantPathWriteNode
           record_constant_write_census(constant_path_write_name(node.target, qualified_prefix, self_owner),
-                                       constant_path_write_literal(node, self_owner), writes, seen)
+                                       constant_path_write_literal(node, self_owner), tables,
+                                       nameable: nameable_write_target?(node.target, self_owner),
+                                       alias_of: constant_alias_source(node.value))
         when Prism::ConstantOperatorWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantAndWriteNode
-          record_constant_write_census(qualified_write_name(qualified_prefix, node.name.to_s), nil, writes, seen)
+          record_constant_write_census(qualified_write_name(qualified_prefix, node.name.to_s), nil, tables)
         when Prism::ConstantPathOperatorWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathAndWriteNode
           record_constant_write_census(constant_path_write_name(node.target, qualified_prefix, self_owner),
-                                       nil, writes, seen)
+                                       nil, tables, nameable: nameable_write_target?(node.target, self_owner))
         when Prism::MultiWriteNode
-          census_multi_write_constants(node, qualified_prefix, writes, seen, self_owner)
+          census_multi_write_constants(node, qualified_prefix, tables, self_owner)
         end
       end
 
       # `A, B = :x, :y` and `A, *rest = …`. A destructured element's value is a projection of the right-hand
       # side, which this syntactic walk does not evaluate, so every constant target is censused unpublishable.
-      def census_multi_write_constants(node, qualified_prefix, writes, seen, self_owner = nil)
+      def census_multi_write_constants(node, qualified_prefix, tables, self_owner = nil)
         targets = node.lefts + node.rights
         targets << node.rest if node.rest
         targets.each do |target|
           case target
           when Prism::ConstantTargetNode
-            record_constant_write_census(qualified_write_name(qualified_prefix, target.name.to_s), nil, writes, seen)
+            record_constant_write_census(qualified_write_name(qualified_prefix, target.name.to_s), nil, tables)
           when Prism::ConstantPathTargetNode
             record_constant_write_census(constant_path_write_name(target, qualified_prefix, self_owner),
-                                         nil, writes, seen)
+                                         nil, tables, nameable: nameable_write_target?(target, self_owner))
           end
         end
       end
@@ -3901,25 +4230,37 @@ module Rigor
       # censuses key a path write differently until that is settled.
       # `self::BAR = …` names whatever `self` is at that point, which the walk carries in `self_owner`
       # ([#705](https://github.com/rigortype/rigor/issues/705)) — the enclosing lexical namespace in an
-      # ordinary body, the receiver inside a `class_eval` block. Where that `self` is {OPAQUE_SELF}, and for
+      # ordinary body, the receiver inside a `class_eval` block, and the constant a `Klass = Class.new { … }`
+      # assigns the block's class to ({#meta_new_block_owner}). Where that `self` is {OPAQUE_SELF}, and for
       # any other dynamic receiver (`klass::BAR = …`), the target is "some class, then `::BAR`" and the name
-      # falls back to the bare last segment — the one spelling that class could make it, `Object`. Suppressing
-      # a top-level name is gradual typing, which is the safe direction here; the VALUE is what such a write
-      # must not contribute ({#constant_path_write_literal}).
+      # falls back to the WILDCARD {DYNAMIC_TARGET_PREFIX} key, which {#finalize_constant_writes} expands
+      # into a retraction of every censused name with that last segment
+      # ([#668](https://github.com/rigortype/rigor/issues/668)). The bare last segment — the pre-#668
+      # fallback — was the single name such a write can never create, so filing it there suppressed the one
+      # name the form cannot touch and left published every name it can. The VALUE is what such a write must
+      # not contribute either ({#constant_path_write_literal}), and the fallback name is withheld from the
+      # local-declaration exemption ({#local_constant_name_set}).
       def constant_path_write_name(target, qualified_prefix, self_owner = nil)
         full = Source::ConstantPath.qualified_name_or_nil(target)
         return full if full
 
         base = target.name&.to_s
         return nil if base.nil?
-        return base unless target.parent.is_a?(Prism::SelfNode)
+        return dynamic_target_key(base) unless target.parent.is_a?(Prism::SelfNode)
 
-        self_write_name(qualified_prefix, self_owner, base) || base
+        self_write_name(qualified_prefix, self_owner, base) || dynamic_target_key(base)
+      end
+
+      def dynamic_target_key(segment) = "#{DYNAMIC_TARGET_PREFIX}#{segment}"
+
+      # The last segment a wildcard census key stands for, or nil for an ordinary qualified name.
+      def dynamic_target_segment(name)
+        name.delete_prefix(DYNAMIC_TARGET_PREFIX) if name.start_with?(DYNAMIC_TARGET_PREFIX)
       end
 
       # The publishable literal a path write contributes — none, whenever its base is not statically
       # nameable ([#705](https://github.com/rigortype/rigor/issues/705)). `[Foo].each { |k| k::X = 1 }`
-      # renders as the bare `X`, and publishing `1` under it handed every reader of the top-level `X` a value
+      # renders under the wildcard key, and publishing `1` there handed every reader of a project `X` a value
       # the program never has: `X == 2` folded to `false`, and in the WRITING file — where
       # `Scope#local_constant_names` exempts the name from #644's withholding guard —
       # `flow.always-truthy-condition` then fired on correct code.
@@ -3950,10 +4291,40 @@ module Rigor
       # Records one censused write. `seen` carries the names this file has already written, so a repeat write
       # retracts the publishable descriptor whatever either rvalue was — neither arm of an in-file
       # reassignment is ever published, and the name still counts as written.
-      def record_constant_write_census(full, literal, writes, seen)
+      #
+      # `nameable` is false only for the wildcard fallback {#constant_path_write_name} takes when nothing
+      # names the write's base. Such a key belongs in `writes` — another file's value for a name it reaches
+      # is not to be trusted — and NOT in `declared`, which answers the opposite question
+      # ([#710](https://github.com/rigortype/rigor/issues/710)). The two are separate tables rather than one
+      # richer descriptor because a name can be written both ways in one file, and then the file DID declare
+      # it however the two writes are ordered.
+      def record_constant_write_census(full, literal, tables, nameable: true, alias_of: nil)
         return if full.nil?
 
-        writes[full] = seen.add?(full) ? (literal || CONSTANT_UNPUBLISHABLE) : CONSTANT_UNPUBLISHABLE
+        tables.declared << full if nameable
+        first_write = tables.seen.add?(full)
+        tables.writes[full] = first_write ? (literal || CONSTANT_UNPUBLISHABLE) : CONSTANT_UNPUBLISHABLE
+        record_constant_alias_census(full, alias_of, tables, first_write && nameable)
+      end
+
+      # Issue #667 — a name written TWICE is not an alias of anything the walk can name, exactly as it is
+      # unpublishable above; the `delete` is what retracts a first write's record when the second arrives.
+      def record_constant_alias_census(full, alias_of, tables, keep)
+        if keep && alias_of
+          tables.aliases[full] = alias_of
+        else
+          tables.aliases.delete(full)
+        end
+      end
+
+      # The constant reference an rvalue names, or nil when it names none. `AppConfig::MODE` renders
+      # qualified; a path that renders no qualified name falls back to its own last segment, which is all
+      # `Scope#published_constant?` can be asked about anyway.
+      def constant_alias_source(rvalue)
+        case rvalue
+        when Prism::ConstantReadNode then rvalue.name.to_s
+        when Prism::ConstantPathNode then Source::ConstantPath.qualified_name_or_nil(rvalue) || rvalue.name&.to_s
+        end
       end
 
       # The frozen-scalar literal fold: `[value]` for a publishable rvalue, nil to decline. The one-element
@@ -3983,20 +4354,51 @@ module Rigor
       # fold time) so the fold stays order-independent, which is what lets the ADR-85 incremental path re-fold
       # a changed file's contribution in place.
       #
-      # @return [Array(Hash, Hash)] `[{name => Type}, {name => Set[path]}]`.
+      # A {DYNAMIC_TARGET_PREFIX} key is not a name and never publishes; it is expanded by
+      # {#apply_dynamic_target_writes} into a retraction over the names it could have written.
+      #
+      # @return `[{name => Type}, {name => Set[path]}]`.
       def finalize_constant_writes(writes)
         values = {}
         sources = {}
+        dynamic = {}
         writes.each do |name, by_path|
-          sources[name] = by_path.keys.to_set.freeze
+          segment = dynamic_target_segment(name)
+          next dynamic[segment] = by_path.keys.to_set if segment
+
+          sources[name] = by_path.keys.to_set
           next unless by_path.size == 1
 
           descriptor = by_path.values.first
           values[name] = Type::Combinator.constant_of(descriptor.first) if descriptor.is_a?(Array)
         end
+        apply_dynamic_target_writes(values, sources, dynamic)
         [values, sources]
       end
 
+      # Issue #668 — expands each wildcard census key. `k::LIMIT = 7` can create `Anything::LIMIT`, so it
+      # retracts every censused name whose last segment is `LIMIT` and joins the writing file to that name's
+      # attribution; the bare `LIMIT` is retracted along with the rest, being the one name the analyzer
+      # cannot rule out either (`k` may be `Object`). Over-retracting makes readers gradual, which is the
+      # direction the census's whole decline list takes; leaving a name published that a dynamic write may
+      # already have replaced is the single failure the census exists to prevent.
+      #
+      # The wildcard key survives into the attribution so a producer with no censused name of its own — a
+      # `pre_eval:` publication for a file outside `paths:` — can still see the conflict
+      # ({Analysis::Runner#publishable_pre_eval_constants}).
+      def apply_dynamic_target_writes(values, sources, dynamic)
+        return if dynamic.empty?
+
+        sources.each do |name, paths|
+          writers = dynamic[name.split("::").last]
+          next if writers.nil?
+
+          paths.merge(writers)
+          values.delete(name)
+        end
+        dynamic.each { |segment, paths| sources[dynamic_target_key(segment)] = paths }
+      end
+
       # Merges one file's `class → method → DefNode` map into the cross-file `def_nodes` index and records each method's
       # first- seen `"path:line"` definition site in `def_sources` (ADR-17 — the un-registered-project-patch signal
       # `call.undefined-method` and `rigor triage` key on).
@@ -4012,7 +4414,7 @@ module Rigor
 
       # Cross-file counterpart of `record_declarations` — registers every `class` / `module` declaration under its
       # qualified name and descends into the body (so `module Foo; class Bar` registers both `Foo` and `Foo::Bar`).
-      def collect_class_decls(node, qualified_prefix, accumulator)
+      def collect_class_decls(node, qualified_prefix, accumulator, compacts = nil)
         return unless node.is_a?(Prism::Node)
 
         case node
@@ -4021,13 +4423,119 @@ module Rigor
           if child_prefix
             full = child_prefix.join("::")
             accumulator[full] = Type::Combinator.singleton_of(full)
-            return collect_class_decls(node.body, child_prefix, accumulator) if node.body
+            record_compact_header(compacts, qualified_prefix, node.constant_path, full) if compacts
+            return collect_class_decls(node.body, child_prefix, accumulator, compacts) if node.body
           end
         when Prism::ConstantWriteNode
           record_class_new_constant_decl(node, qualified_prefix, accumulator)
         end
 
-        node.rigor_each_child { |child| collect_class_decls(child, qualified_prefix, accumulator) }
+        node.rigor_each_child { |child| collect_class_decls(child, qualified_prefix, accumulator, compacts) }
+      end
+
+      # Issue [#722](https://github.com/rigortype/rigor/issues/722) residue 2 — records what a COMPACT header
+      # written inside an enclosing namespace would name if its leading segment fell through to the top level.
+      # `class Outer::Leaf` inside `module Wrap` is keyed `Wrap::Outer::Leaf` by the per-node
+      # {Source::ConstantPath.declaration_prefix}, but Ruby resolves the leading `Outer` by ORDINARY constant
+      # lookup: it reopens `::Outer::Leaf` unless `Wrap::Outer` exists. Whether it exists is a whole-project
+      # fact, so the candidate is recorded here and adjudicated once the fold knows every declared name
+      # ({#compact_header_renames}).
+      #
+      # @param compacts — `{recorded name => [namespace the header needs, name it falls through to]}`.
+      def record_compact_header(compacts, qualified_prefix, constant_path, full)
+        return if qualified_prefix.empty?
+        return unless constant_path.is_a?(Prism::ConstantPathNode)
+        return if Source::ConstantPath.rooted?(constant_path)
+
+        rendered = Source::ConstantPath.qualified_name(constant_path)
+        return unless rendered&.include?("::")
+
+        compacts[full] = [(qualified_prefix + [rendered.split("::").first]).join("::"), rendered]
+      end
+
+      # Issue #722 residue 2 — the whole-project adjudication of {#record_compact_header}'s candidates:
+      # `{name the walk recorded => name Ruby actually reopens}`.
+      #
+      # A candidate moves only when the project ANSWERS BOTH halves of Ruby's lookup: the namespace the
+      # nesting would supply (`Wrap::Outer`) is declared nowhere, and the top level the segment falls through
+      # to (`Outer`) IS declared. The second half is the false-positive bound, not a convenience — a
+      # `Wrap::Outer` that merely never appears in project source (a gem, an RBS-only class) is a namespace
+      # that DOES exist at runtime, and re-anchoring on its absence would answer with a wrong class where
+      # today's mis-keying only answers with silence.
+      #
+      # `declared_names` is the RAW declared set (`class_sources`), never the table
+      # {#synthesize_namespace_prefixes} has run over: that synthesis invents `Wrap::Outer` from
+      # `Wrap::Outer::Leaf` itself, so consulting it would make every candidate look already-resolved.
+      def compact_header_renames(compacts, declared_names)
+        compacts.each_with_object({}) do |(recorded, (required_namespace, reanchored)), out|
+          next if declared_names.include?(required_namespace)
+          next unless declared_names.include?(reanchored.split("::").first)
+
+          out[recorded] = reanchored
+        end
+      end
+
+      # Rewrites `name` when it is, or is nested under, a re-anchored compact header. Nested declarations
+      # ride the same move: `class Outer::Leaf` inside `module Wrap` carrying a `class Inner` filed the inner
+      # class under `Wrap::Outer::Leaf::Inner`, and it reopens `::Outer::Leaf::Inner` for the same reason.
+      def rename_compact_name(renames, name)
+        return name if renames.empty?
+
+        string = name.to_s
+        renamed = renames[string]
+        return renamed if renamed
+
+        renames.each do |recorded, reanchored|
+          return "#{reanchored}#{string[recorded.length..]}" if string.start_with?("#{recorded}::")
+        end
+        string
+      end
+
+      # Re-keys one class-keyed table. A rename lands a declaration on a key the table may ALREADY hold —
+      # which is the whole point: `class Outer::Leaf` written twice, once at the top level and once inside
+      # `module Wrap`, is one class with both bodies. So the arriving contribution is COMBINED with the
+      # sitting one under the table's own fold semantics rather than replacing it; a plain `transform_keys`
+      # dropped the top-level body's methods outright.
+      def rekey_class_table(table, renames)
+        table.each_with_object({}) do |(name, value), out|
+          renamed = rename_compact_name(renames, name)
+          sitting = out[renamed]
+          out[renamed] = sitting.nil? ? value : combine_rekeyed_entries(sitting, value)
+        end
+      end
+
+      # The per-shape combine {#rekey_class_table} applies. Every class-keyed table's value is a Hash of
+      # per-member entries, a Set or Array of names, or a single scalar fact (a superclass name, a member
+      # layout); the first two union, and a scalar keeps the entry already sitting, matching the first-wins
+      # fold `class_sources` and the `"path:line"` source tables use.
+      def combine_rekeyed_entries(sitting, arriving)
+        case sitting
+        when Hash then sitting.merge(arriving)
+        when Set, Array then sitting | arriving
+        else sitting
+        end
+      end
+
+      # Applies {#compact_header_renames} to every class-keyed table of a folded def-index accumulator, plus
+      # the nesting chains whose entries are class names. Runs before {#finalize_def_index}'s own whole-project
+      # passes so those see the settled keys.
+      def apply_compact_header_renames!(acc, renames)
+        %i[def_nodes singleton_def_nodes def_sources singleton_def_sources superclasses header_nestings
+           includes extends method_visibilities methods class_sources data_member_layouts
+           struct_member_layouts constant_writes].each do |key|
+          acc[key] = rekey_class_table(acc[key], renames)
+        end
+        # A `header_nestings` value is a BUCKET (`raw header → chain`, plus the unkeyed union), not a
+        # chain: mapping the bucket itself turned every entry into a `[raw, chain]` pair rendered as a
+        # string, and the next per-file merge (`merge_header_nesting_bucket`) and every
+        # `Scope#recorded_header_nesting` lookup then raised on an Array where a Hash was expected — an
+        # internal analyzer error on every file of a project with one compact header (#984).
+        acc[:header_nestings] = acc[:header_nestings].transform_values do |bucket|
+          bucket.transform_values { |chain| chain.map { |entry| rename_compact_name(renames, entry) } }
+        end
+        acc[:def_nestings].transform_values! do |chain|
+          chain&.map { |entry| rename_compact_name(renames, entry) }
+        end
       end
 
       # T1 (template-corpora survey) — record a class-creating constant write (`Const = Class.new(Super)`, the bare
@@ -4100,13 +4608,30 @@ module Rigor
       # remain real references (resolved through the ordinary lexical walk), so we annotate ONLY the topmost path node.
       # Nested declarations contribute their fully qualified path: `class A::B; class C; ...` produces `A::B` for the
       # outer and `A::B::C` for the inner.
-      def build_declaration_artifacts(root)
+      # @param declared_names — the project's RAW declared-class names, the oracle
+      #   {#compact_header_renames} adjudicates this file's compact headers against.
+      def build_declaration_artifacts(root, declared_names = nil)
         identity_table = {}.compare_by_identity
         discovered = {}
-        record_declarations(root, [], identity_table, discovered)
+        record_declarations(root, [], identity_table, discovered,
+                            file_compact_header_renames(root, declared_names))
         [identity_table.freeze, synthesize_namespace_prefixes(discovered).freeze]
       end
 
+      # Issue #722 residue 2 — this file's share of the fold's re-anchoring, adjudicated against the project
+      # names the fold has already settled. Empty (so the per-node answer stands) whenever the caller has no
+      # project table to consult: a `Scope.empty` probe sees one file and cannot know what else declares
+      # `Wrap::Outer`, and guessing there is the false positive the whole rule is bounded to avoid.
+      def file_compact_header_renames(root, declared_names)
+        return EMPTY_RENAMES if declared_names.nil? || declared_names.empty?
+
+        compacts = {}
+        collect_class_decls(root, [], {}, compacts)
+        return EMPTY_RENAMES if compacts.empty?
+
+        compact_header_renames(compacts, declared_names)
+      end
+
       # Issue #528 — every proper prefix of a discovered COMPACT class name is a namespace module that
       # provably exists at runtime, even when no `module X` declaration is anywhere in the source
       # (Zeitwerk derives it from the directory: mastodon writes `class Api::V1::AccountsController`
@@ -4132,30 +4657,35 @@ module Rigor
         discovered.merge(additions)
       end
 
-      def record_declarations(node, qualified_prefix, identity_table, discovered)
+      def record_declarations(node, qualified_prefix, identity_table, discovered, renames = EMPTY_RENAMES)
         return unless node.is_a?(Prism::Node)
 
         case node
         when Prism::ModuleNode, Prism::ClassNode
-          return if record_class_or_module?(node, qualified_prefix, identity_table, discovered)
-        when Prism::ConstantWriteNode
+          return if record_class_or_module?(node, qualified_prefix, identity_table, discovered, renames)
+        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
           return if record_meta_new_constant?(node, qualified_prefix, identity_table, discovered)
         end
 
         node.rigor_each_child do |child|
-          record_declarations(child, qualified_prefix, identity_table, discovered)
+          record_declarations(child, qualified_prefix, identity_table, discovered, renames)
         end
       end
 
-      def record_class_or_module?(node, qualified_prefix, identity_table, discovered)
+      def record_class_or_module?(node, qualified_prefix, identity_table, discovered, renames = EMPTY_RENAMES)
         child_prefix = Source::ConstantPath.declaration_prefix(qualified_prefix, node.constant_path)
         return false unless child_prefix
 
-        full = child_prefix.join("::")
+        # Issue #722 residue 2 — the per-file twin of the fold's re-anchoring. The file's own declaration
+        # table merges OVER the project seed, so without this a compact header would re-publish the key the
+        # fold already moved and a reference written INSIDE the enclosing namespace would resolve to it
+        # again. The adjudication itself is the project's: `renames` arrives already settled.
+        full = rename_compact_name(renames, child_prefix.join("::"))
+        child_prefix = full.split("::")
         singleton = Type::Combinator.singleton_of(full)
         identity_table[node.constant_path] = singleton
         discovered[full] = singleton
-        record_declarations(node.body, child_prefix, identity_table, discovered) if node.body
+        record_declarations(node.body, child_prefix, identity_table, discovered, renames) if node.body
         true
       end
 
@@ -4168,13 +4698,20 @@ module Rigor
       # - `Const = Data.define(*Symbol) [do ... end]`
       # - `Const = Struct.new(*Symbol [, keyword_init: ...]) [do ... end]`
       #
+      # Issue [#703](https://github.com/rigortype/rigor/issues/703) — and their `Holder::Const = …` spellings, which
+      # name a class just as unconditionally. Until this arm took them, `Holder::Thing.new(1)` fell to the default
+      # `Class#new` envelope on `singleton(Struct)` and handed every reader a bare `Struct`.
+      #
       # The block body, if present, is recursed into so any nested class/module declarations in the override block (rare
       # but legal) still feed the discovered table.
       def record_meta_new_constant?(node, qualified_prefix, identity_table, discovered)
         factory_call = resolve_meta_factory_call(node.value)
         return false unless factory_call
 
-        full = (qualified_prefix + [node.name.to_s]).join("::")
+        child_prefix = meta_new_child_prefix(node, qualified_prefix)
+        return false if child_prefix.nil?
+
+        full = child_prefix.join("::")
         discovered[full] = Type::Combinator.singleton_of(full)
         record_declarations(node.value, qualified_prefix, identity_table, discovered)
         true