rigortype 0.3.5 → 0.3.7

data/lib/rigor/analysis/runner.rb

@@ -120,23 +120,65 @@ module Rigor
         Effects::FileCollection.merge_all(effect_collections)
       end
 
+      # The run's as-written superclass table — what `effect.liskov-widened` reads. Served straight from
+      # the summary entry on a warm hit (#482), where merging every collection to recover one of its
+      # tables would be the whole cost the split removes.
+      def effect_ancestry
+        @cached_effect_ancestry || effect_collection.superclasses
+      end
+
       # Issue #382 — the same collections keyed by the path that produced each, which is the form the two
       # caches persist: `{ "lib/a.rb" => FileCollection, … }`. The merged {#effect_collection} cannot be
       # persisted per file (merging is where the path is deliberately dropped), and per file is what an
       # ADR-46 recheck needs — it re-collects the changed closure and serves the rest from the snapshot.
       def effect_collections_by_path
         pooled = @pool_coordinator.collected_effects
-        pooled.empty? ? @file_effects.dup : @file_effects.merge(pooled)
+        base = forced_file_effects
+        pooled.empty? ? base.dup : base.merge(pooled)
+      end
+
+      # #482 — the per-file collections of a run served from the summary entry, loaded on the first
+      # question that genuinely needs them. A served run adopts the table, the sources and the ancestry
+      # from the small entry and never touches the collections blob; this is the escape hatch that makes
+      # that split safe, because a consumer the split did not anticipate loads the blob here instead of
+      # silently reading an empty table. Nil loader (an analyzing run) is the identity.
+      def forced_file_effects
+        loader = @cached_collections_loader
+        return @file_effects if loader.nil?
+
+        @cached_collections_loader = nil
+        loaded = loader.call
+        @file_effects = loaded if loaded.is_a?(Hash)
+        @file_effects
+      end
+
+      # Issue #382 — adopt persisted collections as this run's own. The warm-hit half of the whole-run
+      # effects slot: the analysis did not run, so `#assemble_run_diagnostics` never reached
+      # {#close_effect_graph}. The slot stores the propagated table BESIDE the collections — the whole-run
+      # entry is already invalidated by every analyzed file (the same post-run dependency descriptor as
+      # the diagnostics slot) and by every meaning input (the effects identity), which is exactly the
+      # invalidation a stored closure needs — so a warm hit adopts both and re-runs nothing. An entry
+      # from before the table rode along reads as a miss (`#peek_effect_collections`' shape guard), and
+      # the ADR-46 incremental snapshot still persists per-file collections only: a recheck re-collects a
+      # partial closure, which is the case a stored table genuinely cannot serve.
+      def adopt_effect_collections(collections, table: nil)
+        @file_effects = collections
+        if table
+          @effect_table = table
+        else
+          close_effect_graph
+        end
       end
 
-      # Issue #382 — adopt persisted collections as this run's own and close the graph over them. The
-      # warm-hit half of the whole-run effects slot: the analysis did not run, so `#assemble_run_diagnostics`
-      # never reached {#close_effect_graph} and the fixpoint is run here instead. The fixpoint is ALWAYS
-      # re-run rather than persisted — it is the cheap half, and a stored table would have to be invalidated
-      # by every input a summary has.
-      def adopt_effect_collections(collections)
-        @file_effects = collections
-        close_effect_graph
+      # #482 — the warm-hit half after the split: everything a served run reads, with the collections left
+      # behind a loader ({#forced_file_effects}). `sources` and `ancestry` are the two derived tables a
+      # served run would otherwise have to merge the whole collection set to recover.
+      def adopt_effect_summary(table:, sources:, ancestry:, collections_loader:)
+        @effect_table = table
+        @cached_effect_sources = sources
+        @cached_effect_ancestry = ancestry
+        @cached_collections_loader = collections_loader
+        @file_effects = {}
       end
 
       # Issue #382 — whether this run's effect collections came from the whole-run effects slot rather than
@@ -154,6 +196,8 @@ module Rigor
       # its entry points are named by *file* globs (`effects.snapshot.reach:`, the `unused --entry-point`
       # syntax), so the key has to be traced back to the file it was written in.
       def effect_sources
+        return @cached_effect_sources if @cached_effect_sources
+
         effect_collections.each_with_object({}) do |collection, out|
           path = collection.path
           next if path.nil?
@@ -248,6 +292,11 @@ module Rigor
         @file_effects = {}
         @effect_table = nil
         @effects_served_from_cache = false
+        # #482 — set only by a run served from the summary entry: the two derived tables it carries, and
+        # the loader that fetches the collections blob if anything still asks for per-file form.
+        @cached_effect_sources = nil
+        @cached_effect_ancestry = nil
+        @cached_collections_loader = nil
         @run_dependency_descriptor = nil
         # Memoised activation decision for the `call.self-undefined-method` rule (nil = not yet computed).
         # See `self_undefined_rule_active?`.
@@ -295,16 +344,31 @@ module Rigor
         @cached_plugin_prepare_diagnostics = [].freeze
         @project_discovered_classes = {}.freeze
         @project_discovered_def_nodes = {}.freeze
+        # Issue #681 — the `Module.nesting` recorded per declared `def`, keyed by node identity.
+        @project_discovered_def_nestings = {}.compare_by_identity.freeze
         @project_discovered_singleton_def_nodes = {}.freeze
         @project_discovered_def_sources = {}.freeze
         @project_discovered_singleton_def_sources = {}.freeze
         @project_discovered_superclasses = {}.freeze
+        # Issue #682 — the `Module.nesting` each class / module declaration HEADER is written in.
+        @project_discovered_header_nestings = {}.freeze
         @project_discovered_includes = {}.freeze
         @project_discovered_class_sources = {}.freeze
+        # Issue #644 — the cross-file VALUE-constant publication table (`{qualified name => Type::Constant}`,
+        # literal writes only) and its per-name write attribution. The first seeds `in_source_constants` on
+        # every per-file scope so `FOO = :sym` in one file reads as `:sym` in another; the second seeds
+        # `constant_sources` only on an ADR-46 recording run, where it is the positive edge's attribution.
+        @project_constant_values = {}.freeze
+        @project_constant_sources = {}.freeze
+        # ...and the raw per-(name, path) publication census the incremental producer diffs.
+        @project_constant_writes = {}.freeze
+        @published_constant_name_set = nil
         @project_discovered_method_visibilities = {}.freeze
         @project_discovered_methods = {}.freeze
         @project_data_member_layouts = {}.freeze
         @project_struct_member_layouts = {}.freeze
+        # Issue #684 — set per run by {#project_discovery_expansion}; nil on every path that does not widen.
+        @project_discovery_expansion = nil
         # ADR-67 WD6a — the call-site parameter-inference table, populated by the opt-in pre-pass in
         # `assemble_run_diagnostics` when `parameter_inference:` is enabled, then seeded onto every per-file
         # scope (sequential + fork-worker) through `project_scope_seed_tables`. Empty by default, so the gate-off
@@ -355,6 +419,7 @@ module Rigor
         return Result.new(diagnostics: [target_ruby_error]) if target_ruby_error
 
         expansion = expand_paths(paths)
+        @project_discovery_expansion = project_discovery_expansion(paths, expansion)
         @snapshots.reset_for_run
         # Per-run reset of the deferred-discovery memo (see `#ensure_project_discovery`).
         @project_discovery_done = false
@@ -481,6 +546,22 @@ module Rigor
         result.transform_values(&:freeze).freeze
       end
 
+      # Issue #644 — per-file PUBLICATION CENSUS: `{path => {qualified constant name => descriptor}}`, the
+      # value-constant twin of {#class_declarations}. The descriptor (`[literal]` or
+      # `ScopeIndexer::CONSTANT_UNPUBLISHABLE`) is load-bearing and a bare name set is not: a name's published
+      # answer is a function of the WHOLE project's write set for it, so what a recheck has to detect is a
+      # change in the census — a value edit, a write becoming unpublishable, a second declarer appearing or
+      # going away — not merely a name appearing.
+      # {Incremental.changed_constant_publications} diffs it; the reader's `constant:` edge is recorded on
+      # every reference, resolved or not, so the diff reaches it either way.
+      def constant_declarations
+        result = Hash.new { |hash, key| hash[key] = {} }
+        @project_constant_writes.each do |name, by_path|
+          by_path.each { |path, descriptor| result[path][name] = descriptor }
+        end
+        result.transform_values(&:freeze).freeze
+      end
+
       # ADR-67 WD6c lift — the inferred-param table this run seeded from (frozen; empty when
       # `parameter_inference:` is off or the pre-pass failed soft). The incremental session reads it back
       # after a baseline so the snapshot records the seeds the cached diagnostics were computed under.
@@ -588,6 +669,8 @@ module Rigor
       def evaluate_return_types_setup(paths, specs)
         expansion = expand_paths(paths || @configuration.paths)
         @project_discovery_done = false
+        # This entry point supplies its own expansion; it never widens (see {#project_discovery_expansion}).
+        @project_discovery_expansion = nil
         @run_generation = Object.new.freeze
         run_project_pre_passes(expansion: expansion)
         ensure_project_discovery(expansion)
@@ -674,9 +757,7 @@ module Rigor
         return nil unless @record_effects
 
         descriptor = effects_key_descriptor(key_descriptor)
-        cached = descriptor && peek_effect_collections(descriptor)
-        if cached
-          adopt_effect_collections(cached)
+        if descriptor && served_from_effect_entries?(descriptor)
           @effects_served_from_cache = true
           return nil
         end
@@ -686,6 +767,32 @@ module Rigor
         analysis
       end
 
+      # The two warm lanes, in cost order (#482).
+      #
+      # The summary entry is what a warm run wants: the table and the two derived tables, and no
+      # collections blob. Its absence is not a miss on its own — a run whose propagation fail-softed
+      # deliberately stores no table (see {#storable_effect_table}), and an entry written before the
+      # split has only the collections — so the second lane adopts the collections and re-runs the
+      # fixpoint over them, which is the pre-split behaviour and the retry the fail-soft posture wants.
+      # Only when neither entry answers does the run re-analyse.
+      #
+      # @return [Boolean] whether this run was served.
+      def served_from_effect_entries?(descriptor)
+        summary = peek_effect_summary(descriptor)
+        if summary
+          table, sources, ancestry = summary
+          adopt_effect_summary(table: table, sources: sources, ancestry: ancestry,
+                               collections_loader: -> { peek_effect_collections(descriptor) || {} })
+          return true
+        end
+
+        collections = peek_effect_collections(descriptor)
+        return false if collections.nil?
+
+        adopt_effect_collections(collections)
+        true
+      end
+
       def effects_key_descriptor(key_descriptor)
         Effects::Identity.descriptor(base: key_descriptor, configuration: @configuration,
                                      plugin_facts: effect_plugin_facts)
@@ -693,42 +800,92 @@ module Rigor
         nil
       end
 
-      # The read half. A miss, a stale dependency, a corrupt entry and a stored value of the wrong shape
-      # are one answer — nil, "collect it again" — because none of them can be told apart from the outside
-      # and all of them have the same remedy.
+      # The read half of the serving entry (#482). A miss, a stale dependency, a corrupt entry and a
+      # stored value of the wrong shape are one answer — nil, "collect it again" — because none of them
+      # can be told apart from the outside and all of them have the same remedy. An entry from before the
+      # split simply does not exist under this producer id, so an older cache re-collects once.
+      def peek_effect_summary(descriptor)
+        cached = @cache_store.peek_validated(
+          producer_id: RunCacheKey::RUN_EFFECTS_TABLE_PRODUCER_ID, key_descriptor: descriptor
+        )
+        return nil unless cached.is_a?(Array) && cached.length == 3
+        return nil unless cached[0].is_a?(Effects::EffectTable) && cached[1].is_a?(Hash) &&
+                          cached[2].is_a?(Hash)
+
+        cached
+      rescue StandardError
+        nil
+      end
+
+      # The read half of the collections entry — only ever asked by {#forced_file_effects}, on the paths
+      # that need per-file form. The stored shape is `[collections]`; an entry from before the split is
+      # `[collections, table]` and its first member is the same Hash, so it still reads.
       def peek_effect_collections(descriptor)
         cached = @cache_store.peek_validated(
           producer_id: RunCacheKey::RUN_EFFECTS_PRODUCER_ID, key_descriptor: descriptor
         )
-        cached.is_a?(Hash) ? cached : nil
+        return nil unless cached.is_a?(Array) && cached.first.is_a?(Hash)
+
+        cached.first
       rescue StandardError
         nil
       end
 
       # The write half, run only after a miss, so the block never recomputes anything: it hands over the
-      # collections the analysis just produced, validated against the same post-run dependency descriptor
-      # the diagnostics slot records. Fail-soft — a collection that will not Marshal (which nothing in
-      # {Effects::FileCollection} should be, and the fork pool already proves per file) costs the next run
-      # its warm start and nothing else.
+      # collections the analysis just produced — and the table the analysis already closed over them, so
+      # a warm hit re-runs neither the merge nor the fixpoint — validated against the same post-run
+      # dependency descriptor the diagnostics slot records. Fail-soft — a collection that will not
+      # Marshal (which nothing in {Effects::FileCollection} should be, and the fork pool already proves
+      # per file) costs the next run its warm start and nothing else.
+      # The write half, run only after a miss, so neither block recomputes anything. Two entries under one
+      # key descriptor and one dependency descriptor (#482): the summary a warm run serves from, and the
+      # collections the incremental and fail-soft paths read. The summary is written LAST, so a run
+      # interrupted between the two leaves a collections entry that the next run's summary miss simply
+      # re-collects — never a summary whose collections are absent.
       def store_effect_collections(descriptor, expansion, rbs_descriptor)
         return if descriptor.nil?
 
         collections = effect_collections_by_path
-        @cache_store.fetch_or_validate(
-          producer_id: RunCacheKey::RUN_EFFECTS_PRODUCER_ID, key_descriptor: descriptor,
-          generation_cap: RunCacheKey::EFFECTS_GENERATION_CAP
-        ) { [collections, run_dependency_descriptor(expansion, rbs_descriptor)] }
+        dependencies = run_dependency_descriptor(expansion, rbs_descriptor)
+        write_effect_entry(RunCacheKey::RUN_EFFECTS_PRODUCER_ID, descriptor, [collections], dependencies)
+        table = storable_effect_table(collections)
+        return nil if table.nil?
+
+        write_effect_entry(RunCacheKey::RUN_EFFECTS_TABLE_PRODUCER_ID, descriptor,
+                           [table, effect_sources, effect_collection.superclasses], dependencies)
         nil
       rescue StandardError
         nil
       end
-      private :serve_effect_collections, :effects_key_descriptor,
-              :peek_effect_collections, :store_effect_collections
+
+      def write_effect_entry(producer_id, descriptor, payload, dependencies)
+        @cache_store.fetch_or_validate(
+          producer_id: producer_id, key_descriptor: descriptor,
+          generation_cap: RunCacheKey::EFFECTS_GENERATION_CAP
+        ) { [payload, dependencies] }
+      end
+
+      # An empty table over non-empty summaries is {#close_effect_graph}'s fail-soft answer, not a
+      # result — persisting it would freeze one run's propagation failure into every warm hit until the
+      # next invalidation. Storing nil instead makes the warm hit re-run the fixpoint, which is exactly
+      # the retry the fail-soft posture wants.
+      def storable_effect_table(collections)
+        table = @effect_table
+        return nil if table.nil?
+        return nil if table.empty? && collections.any? { |_, collection| !collection.summaries.empty? }
+
+        table
+      end
+      private :serve_effect_collections, :served_from_effect_entries?,
+              :effects_key_descriptor, :peek_effect_summary,
+              :peek_effect_collections, :store_effect_collections, :write_effect_entry,
+              :storable_effect_table, :forced_file_effects
 
       # ADR-103 WD8 / #383 — the envelope check. Nothing at all without an `effects:` block, and nothing
       # under `effects.check: false`; with both, one walk of the project's own RBS for `%a{pure}` /
       # `%a{rigor:v1:effect …}`, and only if that finds an envelope does anything else run (the discovery
-      # tables the `def` positions come from are forced from inside the pass, lazily, for that reason).
+      # tables the `def` positions come from are forced from inside the judgment, on the first finding
+      # built — a judged-clean envelope forces no discovery at all).
       #
       # The environment is the one the cacheable path already resolved when there is one, so a warm run
       # reads the envelopes off the loader it built anyway rather than building a second.
@@ -745,7 +902,7 @@ module Rigor
           # ADR-103 WD1 / #386 — the nominal relation `effect.liskov-widened` reads, from the collector's
           # own as-written superclass table, so the Liskov check and the closed-world proven lane resolve
           # the same ancestry. Lazy: only a project that declared an envelope pays the merge.
-          ancestry: -> { effect_collection.superclasses },
+          ancestry: -> { effect_ancestry },
           apply_tolerated: !@no_tolerated_effects,
           # #387 — the same compiled plugin tables the collection window scanned under, so an envelope may
           # name a label a plugin opened and the unknown-label check agrees with the scan.
@@ -836,6 +993,10 @@ module Rigor
         close_effect_graph
         diagnostics += @diagnostic_aggregator.rbs_quarantined_signature_diagnostics
         diagnostics += @diagnostic_aggregator.rbs_environment_build_failed_diagnostics
+        # Issue #696 — after its env-wide twin and before the synthesized-namespace notice: the three
+        # `rbs.coverage.*` build conditions surface widest-consequence first, and their relative order is
+        # the diagnostic output contract.
+        diagnostics += @diagnostic_aggregator.rbs_definition_build_failed_diagnostics
         diagnostics += @diagnostic_aggregator.rbs_synthesized_namespace_diagnostics
         diagnostics += @diagnostic_aggregator.conforms_to_diagnostics
         diagnostics += @diagnostic_aggregator.rbs_extended_reporter_diagnostics
@@ -958,15 +1119,33 @@ module Rigor
       end
 
       def build_run_dependency_descriptor(expansion, rbs_descriptor)
-        entries = analyzed_file_entries(expansion) + pre_eval_file_entries + rbs_descriptor.files
+        entries = analyzed_file_entries(expansion) + discovery_file_entries(expansion) +
+                  pre_eval_file_entries + rbs_descriptor.files
+        globs = []
         @plugin_registry.plugins.each do |plugin|
           # Read the boundary WITHOUT triggering its lazy `@io_boundary ||=` initializer: plugin instances
           # are frozen after the run, and a plugin that never built a boundary read no files through it,
           # so it contributes no dependencies.
           boundary = plugin.instance_variable_get(:@io_boundary)
           entries.concat(boundary.cache_descriptor.files) if boundary
+          plugin.class.producers.each_value do |prod|
+            globs.concat(plugin.send(:watch_glob_entries, prod[:watch])) if prod[:watch]
+          end
         end
-        Cache::Descriptor.new(files: entries)
+        Cache::Descriptor.new(files: entries, globs: globs.uniq)
+      end
+
+      # Issue #684 — the project files this run DISCOVERED but did not analyse. A widened run's diagnostics
+      # are a function of them (that is the entire point: the method whose absence would have been reported
+      # is defined in one of them), so the run-result cache must invalidate when one changes. Empty on every
+      # run whose discovery expansion is its analysis expansion, which is every whole-project run.
+      def discovery_file_entries(expansion)
+        return [] if @project_discovery_expansion.nil?
+
+        analyzed = expansion.fetch(:files).to_set
+        analyzed_file_entries(
+          { files: @project_discovery_expansion.fetch(:files).reject { |path| analyzed.include?(path) } }
+        )
       end
 
       def analyzed_file_entries(expansion)
@@ -1062,12 +1241,18 @@ module Rigor
       def apply_discovery_result(discovery)
         @project_discovered_classes = discovery.discovered_classes
         @project_discovered_def_nodes = discovery.discovered_def_nodes
+        @project_discovered_def_nestings = discovery.discovered_def_nestings
         @project_discovered_singleton_def_nodes = discovery.discovered_singleton_def_nodes
         @project_discovered_def_sources = discovery.discovered_def_sources
         @project_discovered_singleton_def_sources = discovery.discovered_singleton_def_sources
         @project_discovered_superclasses = discovery.discovered_superclasses
+        @project_discovered_header_nestings = discovery.discovered_header_nestings
         @project_discovered_includes = discovery.discovered_includes
         @project_discovered_class_sources = discovery.discovered_class_sources
+        @project_constant_values = discovery.constant_values
+        @published_constant_name_set = nil
+        @project_constant_sources = discovery.constant_sources
+        @project_constant_writes = discovery.constant_writes
         @project_discovered_method_visibilities = discovery.discovered_method_visibilities
         @project_discovered_methods = discovery.discovered_methods
         @project_data_member_layouts = discovery.data_member_layouts
@@ -1087,6 +1272,8 @@ module Rigor
         return if @project_discovery_done
 
         @project_discovery_done = true
+        # Issue #684 — the cross-file index spans the PROJECT even when the analysis targets a file list.
+        expansion = @project_discovery_expansion || expansion
         if @collect_seed_bundles
           # ADR-85 WD2 — rebuild discovery from the prior run's bundles (re-walking only changed files) and
           # capture the refreshed bundle set for the session to persist.
@@ -1099,6 +1286,39 @@ module Rigor
         end
       end
 
+      # Issue #684 — the file set the cross-file DISCOVERY pre-pass walks, when that is wider than the set
+      # being analysed. nil means "the same one", which is every whole-project run.
+      #
+      # `rigor check path/to/one_file.rb` — what an editor integration, a pre-commit hook and
+      # `git diff --name-only | xargs rigor check` all do — discovered only the files it was handed, so a
+      # class the project declares in `sig/` WITHOUT declaring every one of its methods drew a false
+      # `call.undefined-method` for any method whose defining file was outside the invocation. The class was
+      # RBS-known, source discovery could not supply the method, and the rule fired on correct code. The
+      # same check over the containing DIRECTORY reported nothing, which is also why per-directory sums
+      # over a tree over-reported against a whole-tree run (14 diagnostics of this shape against 2 during
+      # the #652 work).
+      #
+      # Discovery is a parse pass, not an analysis: 0.55s over Rigor's own 444-file `lib` cold, and under
+      # ADR-85 seed bundles a warm run re-walks only what changed. The alternative — standing the rule down
+      # whenever evidence might be missing — buys the same FP safety by making `rigor check one_file.rb`
+      # answer a different question than `rigor check .`, and the diagnostics for a file should not depend
+      # on what else was on the command line.
+      #
+      # Excluded, each because its expansion is already the one it means: the LSP `prebuilt:` path (which
+      # seeds discovery from a snapshot), editor `buffer:` mode, `run_source`'s in-memory single file, and
+      # ADR-46's `analyze_only` subset mode (which already passes the full expansion and filters later).
+      def project_discovery_expansion(paths, expansion)
+        return nil unless widen_discovery_to_project?(paths)
+
+        widened = expand_paths(@configuration.paths | paths)
+        widened.fetch(:files).size > expansion.fetch(:files).size ? widened : nil
+      end
+
+      def widen_discovery_to_project?(paths)
+        @prebuilt.nil? && @buffer.nil? && @in_memory_sources.nil? && @analyze_only.nil? &&
+          paths != @configuration.paths
+      end
+
       # ADR-46 — the dependency-recording and subset-analysis modes read the discovery tables OUTSIDE the
       # analysis assembly (`Runner#symbol_fingerprints` / `#class_declarations`, consumed by
       # {IncrementalSession} after the run), so they force the build eagerly — matching the pre-slice-1
@@ -1109,7 +1329,8 @@ module Rigor
       end
 
       private :run_project_pre_passes, :adopt_prebuilt_project_scan, :apply_pre_passes_result,
-              :apply_discovery_result, :ensure_project_discovery, :force_eager_discovery?
+              :apply_discovery_result, :ensure_project_discovery, :force_eager_discovery?,
+              :project_discovery_expansion, :widen_discovery_to_project?
 
       # Ruby versions probed (ascending) to discover the lowest one this Prism build accepts for
       # `version:`. Prism exposes no version list, so the floor is found empirically — only when a
@@ -1240,6 +1461,7 @@ module Rigor
           synthesized_namespaces_snapshot: -> { @snapshots.synthesized_namespaces },
           quarantined_signatures_snapshot: -> { @snapshots.quarantined_signatures },
           env_build_failure_snapshot: -> { @snapshots.env_build_failure },
+          definition_build_failures_snapshot: -> { @snapshots.definition_build_failures },
           conformance_results_snapshot: -> { @snapshots.conformance_results }
         )
       end
@@ -1458,6 +1680,9 @@ module Rigor
         tables[:run_generation] = @run_generation if @run_generation
         tables[:discovered_classes] = @project_discovered_classes unless @project_discovered_classes.empty?
         tables[:discovered_def_nodes] = @project_discovered_def_nodes unless @project_discovered_def_nodes.empty?
+        unless @project_discovered_def_nestings.empty?
+          tables[:discovered_def_nestings] = @project_discovered_def_nestings
+        end
         unless @project_discovered_singleton_def_nodes.empty?
           tables[:discovered_singleton_def_nodes] = @project_discovered_singleton_def_nodes
         end
@@ -1465,6 +1690,9 @@ module Rigor
         unless @project_discovered_superclasses.empty?
           tables[:discovered_superclasses] = @project_discovered_superclasses
         end
+        unless @project_discovered_header_nestings.empty?
+          tables[:discovered_header_nestings] = @project_discovered_header_nestings
+        end
         tables[:discovered_includes] = @project_discovered_includes unless @project_discovered_includes.empty?
         unless @project_discovered_method_visibilities.empty?
           tables[:discovered_method_visibilities] = @project_discovered_method_visibilities
@@ -1472,14 +1700,22 @@ module Rigor
         tables[:discovered_methods] = @project_discovered_methods unless @project_discovered_methods.empty?
         seed_opt_in_pre_pass_tables(tables)
         seed_member_layout_tables(tables)
-        # ADR-46 slice 1 — the class-declaration source map is read only by the ancestry accessors during
-        # dependency recording, so seed it only when recording is on; a normal run never carries it.
-        if @record_dependencies && !@project_discovered_class_sources.empty?
-          tables[:discovered_class_sources] = @project_discovered_class_sources
-        end
+        seed_dependency_attribution_tables(tables)
         tables
       end
 
+      # ADR-46 slice 1 / issue #644 — the two SOURCE-ATTRIBUTION tables, read only by the recording accessors
+      # (`Scope#record_class_dependency` for the class-declaration map, `Scope#record_constant_dependency`
+      # for the constant-write map). A normal run carries neither. Extracted to keep
+      # {#project_scope_seed_tables} under the complexity budget.
+      def seed_dependency_attribution_tables(tables)
+        return unless @record_dependencies
+
+        tables[:discovered_class_sources] = @project_discovered_class_sources unless
+          @project_discovered_class_sources.empty?
+        tables[:constant_sources] = @project_constant_sources unless @project_constant_sources.empty?
+      end
+
       # Issue #260 — the mutable starting point {#project_scope_seed_tables} fills in: a copy of the opt-in
       # `discovery_seed:` when one was supplied, otherwise the empty Hash every other run has always started
       # from. Extracted so the seed costs {#project_scope_seed_tables} no branch of its complexity budget.
@@ -1499,9 +1735,33 @@ module Rigor
       # Extracted to keep {#project_scope_seed_tables} under the complexity budget.
       def seed_opt_in_pre_pass_tables(tables)
         tables[:param_inferred_types] = @project_param_inferred_types unless @project_param_inferred_types.empty?
-        return if @project_pre_eval_constants.empty?
+        constants = merged_seed_constants
+        return if constants.empty?
+
+        tables[:in_source_constants] = constants
+        names = published_constant_name_set
+        tables[:published_constant_names] = names unless names.empty?
+      end
+
+      # Issue #644 — the seeded `in_source_constants` table, joining the two cross-file constant producers.
+      # The whole-project literal table wins over a `pre_eval:` publication of the same name: both describe
+      # the same assignment, the literal table pins the value the write actually carries while ADR-17's
+      # widener erases it to the class, and listing a file under `pre_eval:` must never LOSE precision. The
+      # per-file table still wins over both (`ScopeIndexer.index`'s merge) — same-file stays the most
+      # specific authority.
+      # Issue #644 — the LAST SEGMENTS of the published table, the run-wide half of
+      # `Scope#published_constant?`. Seeded on EVERY run (unlike `constant_sources`, which only a recording
+      # run needs) because {CheckRules::PublishedConstantGuard} asks the question on every `if` / `unless`.
+      def published_constant_name_set
+        @published_constant_name_set ||=
+          @project_constant_values.keys.to_set { |name| name.split("::").last }.freeze
+      end
+
+      def merged_seed_constants
+        return @project_constant_values if @project_pre_eval_constants.empty?
+        return @project_pre_eval_constants if @project_constant_values.empty?
 
-        tables[:in_source_constants] = @project_pre_eval_constants
+        @project_pre_eval_constants.merge(@project_constant_values).freeze
       end
 
       # ADR-46 — seed the instance + singleton `"path:line"` def-source tables (each only when non-empty).

data/lib/rigor/analysis/worker_session.rb

@@ -235,6 +235,14 @@ module Rigor
       # Read-once snapshot of the per-worker reporters so the caller (or the eventual Phase 4b pool
       # aggregator) can merge into a single coordinator-side reporter. Both reporters dedupe at write time,
       # so a post-hoc concat + de-dup at the entry-key level is sound.
+      #
+      # Issue #696 — `definition_build_failures` rides this channel rather than a coordinator-side snapshot,
+      # and it has to. Under the pool the PARENT never analyses a file, so its loader never demands a
+      # definition and never enters the failing build; a diagnostic wired off the parent's loader would
+      # appear at `--workers=0` and vanish at `--workers=N`, which is the same "reports less depending on
+      # how you ran it" defect the diagnostic exists to end. Draining it out of the workers is what makes
+      # the two paths say the same thing. The payload is `[String, String, String, Array<String>]` tuples —
+      # Marshal-clean for the fork backend and shareable for the Ractor one.
       def drain_reporters
         {
           rbs_extended: {
@@ -242,7 +250,8 @@ module Rigor
             lossy_projections: @rbs_extended_reporter.lossy_projections
           },
           boundary_cross: @boundary_cross_reporter.entries,
-          source_rbs_synthesis: @source_rbs_synthesis_reporter.entries
+          source_rbs_synthesis: @source_rbs_synthesis_reporter.entries,
+          definition_build_failures: @environment&.rbs_loader&.definition_build_failures || []
         }
       end
 

data/lib/rigor/bleeding_edge.rb

@@ -107,14 +107,15 @@ module Rigor
         id: "reject-unparseable-signatures",
         kind: :severity,
         summary: "A broken `signature_paths:` RBS set fails the run instead of degrading it silently. An " \
-                 "unparseable `.rbs` is otherwise skipped with a warning, and a duplicate-declaration " \
-                 "conflict (a file that parses fine but collides on resolve — typically against Rigor's " \
-                 "own bundled RBS) collapses the whole env with a warning; either way the run gets quieter " \
-                 "rather than cleaner. This treats both as a build error, the way a broken source file " \
-                 "already is.",
+                 "unparseable `.rbs` is otherwise skipped with a warning; a duplicate-declaration conflict " \
+                 "(a file that parses fine but collides on resolve — typically against Rigor's own bundled " \
+                 "RBS) collapses the whole env with a warning; and a duplicate METHOD definition collapses " \
+                 "one class's method surface the same way. Each leaves the run quieter rather than " \
+                 "cleaner. This treats all three as a build error, the way a broken source file already is.",
         severity_overrides: {
           "rbs.coverage.quarantined-signature" => :error,
-          "rbs.coverage.environment-build-failed" => :error
+          "rbs.coverage.environment-build-failed" => :error,
+          "rbs.coverage.definition-build-failed" => :error
         }.freeze
       ),
       Feature.new(