rigortype 0.3.5 → 0.3.7

data/lib/rigor/analysis/reachability/scan.rb

@@ -28,15 +28,34 @@ module Rigor
 
         # One constant reference. `from` is the fully-qualified name of the innermost enclosing declaration, or
         # nil for a reference written at file level — that is what makes the graph a reachability graph rather
-        # than a reference count (ADR-102 WD2). `role` is the referring FILE's role (WD8).
-        Reference = Data.define(:as_written, :nesting, :from, :role, :path, :line)
+        # than a reference count (ADR-102 WD2). `role` is the referring FILE's role (WD8). `rooted` is true
+        # when the constant was written with a leading `::` (#625).
+        Reference = Data.define(:as_written, :nesting, :from, :role, :path, :line, :rooted) do
+          def initialize(rooted: false, **) = super
+        end
 
         # ADR-102 WD4 — a site where a constant is reached by a mechanism the static reading cannot follow.
         # `name` is the exact constant when the argument is a literal (`"Foo".constantize`), in which case this
-        # is as good as a reference. `prefix` is the namespace a dynamic construction can reach into
-        # (`"Foo::#{k}".constantize` → `"Foo"`, and `nil` when even that is unknown), which taints every
-        # declaration at or below it rather than proving any single one used.
-        DynamicUse = Data.define(:name, :prefix, :reason, :site, :path, :line)
+        # is as good as a reference. `prefix` is what a dynamic construction can reach, and `scope` says how
+        # far — the two kinds of weak evidence are not the same shape:
+        #
+        # - `:namespace` — `"Foo::#{k}".constantize` can construct ANY name under `Foo`, so it taints `Foo`
+        #   and every declaration beneath it. This is the default and the original meaning of `prefix`.
+        # - `:exact` — a data-file or template match names ONE declaration and says nothing about its
+        #   children (#370). `config/recurring.yml` mentioning `Admin` is not evidence about
+        #   `Admin::CollectionPolicy`; treating it as such demoted 18 unrelated Mastodon rows off one
+        #   Afrikaans word ("Administrasie" contains "Admin").
+        DynamicUse = Data.define(:name, :prefix, :reason, :site, :path, :line, :scope) do
+          def initialize(scope: :namespace, **) = super
+
+          # Whether this site's evidence reaches `fqn`.
+          def taints?(fqn)
+            return false if prefix.nil?
+            return fqn == prefix if scope == :exact
+
+            fqn == prefix || fqn.start_with?("#{prefix}::")
+          end
+        end
 
         Result = Data.define(:declarations, :references, :dynamic_uses)
 
@@ -232,7 +251,8 @@ module Rigor
 
             @references << Reference.new(as_written: as_written, nesting: nesting.dup.freeze,
                                          from: nesting.empty? ? nil : nesting.join("::"),
-                                         role: @role, path: @path, line: node.location.start_line)
+                                         role: @role, path: @path, line: node.location.start_line,
+                                         rooted: Source::ConstantPath.rooted?(node))
           end
         end
       end

data/lib/rigor/analysis/reachability/scan_cache.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "zlib"
+
+require_relative "../../version"
+
+module Rigor
+  module Analysis
+    module Reachability
+      # ADR-102 — the warm cache for `rigor unused`'s two per-file passes: the Prism reachability
+      # scan over `.rb` / `.rake` files, and the capital-run extraction over template files. Both
+      # passes are pure functions of one file's bytes, and both were measured re-running in full on
+      # every invocation (2.0 s of a 2.6 s warm run on Mastodon; the Marshal restore is 25× cheaper
+      # than the rescan, `docs/notes/20260825-feature-warm-cold-corpus-perf.md`).
+      #
+      # One self-validating zlib-Marshal blob under the cache root, the ADR-46 IncrementalSnapshot
+      # shape rather than an ADR-54 `Cache::Store` producer: the sound unit of reuse is the FILE
+      # (any subset of files may change between runs), so the payload carries a stat signature per
+      # entry and validates each on read, where a store entry validates all-or-nothing and a miss
+      # would throw away every unchanged file's work. The whole-project answer stays complete —
+      # every file is still consulted every run; an unchanged one contributes its cached product.
+      #
+      # Fail-soft everywhere: a missing, torn, or stale-schema blob is an empty cache, and a file
+      # whose signature cannot be taken is computed and never recorded. Nothing here can change
+      # what the report says — only whether a per-file product was recomputed to say it.
+      class ScanCache
+        SCHEMA = 1
+        FILE_NAME = "reachability-scan.bundle"
+
+        # The sources whose behaviour the cached products embody. Digested into the header so a
+        # checkout that edits the scan invalidates its survey targets' bundles without anyone
+        # remembering to bump {SCHEMA} — the `Cache::EngineSource` idea, scoped to this feature.
+        SOURCE_FILES = [
+          File.expand_path("scan.rb", __dir__),
+          File.expand_path(__FILE__)
+        ].freeze
+
+        # A file modified within this window of the recording instant is computed but never
+        # recorded — the FileDigest racy-write guard, one tier simpler because a refused signature
+        # costs one rescan on the next run, never a wrong answer.
+        RACY_WINDOW_NS = 2_000_000_000
+        private_constant :RACY_WINDOW_NS
+
+        # @param cache_path [String, nil] the configuration's cache root; nil or empty is an inert
+        #   cache (every fetch computes, nothing persists).
+        # @param target_ruby [String, nil] parse-affecting configuration, part of the identity.
+        def self.open(cache_path, target_ruby: nil)
+          return new(path: nil, header: nil) if cache_path.nil? || cache_path.to_s.empty?
+
+          new(path: File.join(cache_path.to_s, FILE_NAME),
+              header: "#{SCHEMA}:#{Rigor::VERSION}:#{target_ruby}:#{source_digest}")
+        end
+
+        def self.source_digest
+          Digest::SHA256.hexdigest(SOURCE_FILES.map { |path| File.read(path) }.join)
+        rescue StandardError
+          "unreadable"
+        end
+
+        def initialize(path:, header:)
+          @path = path
+          @header = header
+          @entries = load_entries
+          @live = {}
+          @dirty = false
+        end
+
+        # Serves the cached product for `(kind, path)` while the file's stat signature holds;
+        # otherwise computes via the block and records the fresh product.
+        def serve(kind, path)
+          key = [kind, path]
+          sig = signature(path)
+          cached = @entries[key]
+          if cached && sig && cached[0] == sig
+            @live[key] = cached
+            return cached[1]
+          end
+
+          value = yield
+          @live[key] = [sig, value] if sig
+          @dirty = true
+          value
+        end
+
+        # Best-effort persist, only when something changed. Carries forward entries this run never
+        # consulted (a path-argument run must not shrink the full-project bundle) but drops the ones
+        # whose file no longer exists; tmp-then-rename so a torn write is never read back.
+        def save
+          return if @path.nil? || !@dirty
+
+          keep = @entries.merge(@live).select { |(_, path), _| File.exist?(path) }
+          FileUtils.mkdir_p(File.dirname(@path))
+          tmp = "#{@path}.#{Process.pid}.tmp"
+          File.binwrite(tmp, Zlib::Deflate.deflate(Marshal.dump([@header, keep])))
+          File.rename(tmp, @path)
+          nil
+        rescue StandardError
+          FileUtils.rm_f(tmp) if tmp
+          nil
+        end
+
+        private
+
+        def load_entries
+          return {} if @path.nil?
+
+          # Same trust model as the ADR-45 store and the ADR-46 snapshot: the blob lives in the
+          # project's own cache directory and a corrupt one degrades to an empty cache.
+          header, entries = Marshal.load(Zlib::Inflate.inflate(File.binread(@path))) # rubocop:disable Security/MarshalLoad
+          header == @header && entries.is_a?(Hash) ? entries : {}
+        rescue StandardError
+          {}
+        end
+
+        def signature(path)
+          st = File.stat(path)
+          mtime_ns = (st.mtime.to_i * 1_000_000_000) + st.mtime.nsec
+          now_ns = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+          return nil if mtime_ns >= now_ns - RACY_WINDOW_NS
+
+          [st.size, mtime_ns, (st.ctime.to_i * 1_000_000_000) + st.ctime.nsec, st.ino]
+        rescue SystemCallError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rigor/analysis/result.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "crash_signature"
+
 module Rigor
   module Analysis
     class Result
@@ -17,6 +19,36 @@ module Rigor
         diagnostics.none?(&:error?)
       end
 
+      # Issue #686 — true when a check rule (or a plugin's node-rule contribution) raised, so
+      # `Runner#analyze_file_body`'s rescue REPLACED the affected file's whole diagnostic list with one
+      # synthetic row. What comes back is then not a weaker account of the code; it is no account of it.
+      #
+      # Any consumer that compares two results, or reads an EMPTY result as "clean", has to ask this first.
+      # A crashed baseline and a crashed mutant carry the same synthetic row, so `==` reports agreement; an
+      # absence assertion holds on the one-diagnostic list the rescue leaves behind. That is how a kill
+      # oracle scored survivors it never measured (#686) and how 1,177 spec examples passed with every check
+      # rule crashing (#674).
+      #
+      # Narrower than "the run reported a failure", deliberately. A raising PLUGIN loses only that plugin's
+      # contribution and a failed RBS definition build loses only a type — in both cases every builtin rule
+      # still ran and its diagnostics are still here, so a consumer that refused those would be discarding a
+      # real measurement. {CrashSignature} carries the full table and the reasoning.
+      #
+      # `success?` is deliberately NOT this question: a crash makes `success?` false (the row is `:error`),
+      # which is why the CLI is loud and CI goes red. It is the callers that read the diagnostic LIST rather
+      # than the exit code which need the predicate.
+      def crashed?
+        diagnostics.any? { |diagnostic| CrashSignature.discards_file_analysis?(diagnostic) }
+      end
+
+      # The diagnostics {#crashed?} answers true for, so a caller can name what it saw rather than only that
+      # it saw something.
+      #
+      # @return [Array<Rigor::Analysis::Diagnostic>]
+      def crash_diagnostics
+        diagnostics.select { |diagnostic| CrashSignature.discards_file_analysis?(diagnostic) }
+      end
+
       def error_count
         diagnostics.count(&:error?)
       end

data/lib/rigor/analysis/run_cache_key.rb

@@ -14,8 +14,13 @@ end
 require_relative "../version"
 require_relative "../cache/descriptor"
 require_relative "../cache/engine_source"
+require_relative "../cache/file_digest"
 require_relative "../cache/rbs_descriptor"
 require_relative "../environment/default_libraries"
+# Both resolvers are leaf files (no requires beyond `yaml`), so the boot-slimming probe reaches the two
+# lockfile paths without loading `rigor/environment` or the RBS machinery.
+require_relative "../environment/lockfile_resolver"
+require_relative "../environment/rbs_collection_discovery"
 
 module Rigor
   module Analysis
@@ -48,6 +53,18 @@ module Rigor
       # collecting run wrote elsewhere.
       RUN_EFFECTS_PRODUCER_ID = "analysis.run-effects"
 
+      # #482 — the **serving** half of the sidecar, under the same effects identity: the propagated table,
+      # the unit sources and the merged as-written superclass table. Everything a warm run reads, and
+      # nothing else.
+      #
+      # It is a separate entry rather than a section of {RUN_EFFECTS_PRODUCER_ID} because the collections
+      # blob is large in exactly the projects where warm latency matters — 6.9 MB and 0.71 s of `Marshal`
+      # on gitlab `app lib`, against ~40 KB here — and a warm run consumes none of it. The collections
+      # entry stays, read lazily by the paths that genuinely need per-file form (an ADR-46 recheck, the
+      # fail-soft re-propagation), so a consumer this split did not anticipate loads the blob rather than
+      # seeing an empty table.
+      RUN_EFFECTS_TABLE_PRODUCER_ID = "analysis.run-effects-table"
+
       # The run-result producer's declared compaction budget (`Cache::Store#evict!` pass 2). Whole-project,
       # but unlike the `rbs.*` producers several generations can be live at once: the `paths` key slot means
       # one entry per analyzed-path SET, so `rigor check` over the whole project, over `lib`, and over a
@@ -68,7 +85,7 @@ module Rigor
       def descriptor(configuration:, files:, explain:, rbs_config_entries:)
         Cache::Descriptor.new(
           gems: [Cache::RbsDescriptor.rbs_gem_entry],
-          configs: rbs_config_entries + engine_source_entries + [
+          configs: rbs_config_entries + engine_source_entries + lockfile_entries(configuration) + [
             config_entry("configuration", Marshal.dump(configuration.to_h)),
             config_entry("engine",
                          "#{Rigor::VERSION}:#{Cache::Descriptor::SCHEMA_VERSION}:#{explain}"),
@@ -94,6 +111,41 @@ module Rigor
         [config_entry("engine-source", identity)]
       end
 
+      # Issue #564 — the two dependency lockfiles, BY CONTENT. Both are inputs to the run's diagnostics and
+      # neither was represented in the key: the locked gem set decides which bundle-shipped `sig/` dirs and
+      # which `rbs_collection` dirs load, which ADR-72 gem overlays apply, what the ADR-82 WD9 missing-gem
+      # constant index owns, and whether `rbs.coverage.missing-gem` fires at all. Editing a lockfile touches
+      # no analyzed source and no `.rbs` file, so the `paths` slot, the `configuration` slot (which carries
+      # the lockfile PATH, never its bytes) and the recorded dependency descriptor were all unchanged by a
+      # `bundle add` — and a warm run replayed the pre-edit diagnostics in BOTH directions: an
+      # `undefined-method` on `3.minutes` surviving the `bundle add activesupport` that licenses the overlay,
+      # and the same call staying silent after the `bundle remove` that revokes it.
+      #
+      # A KEY slot rather than a dependency entry, because a dependency descriptor can only say "a file I
+      # recorded changed": it cannot express a lockfile that did not exist when the entry was written and
+      # does now, which is the `bundle init` / first-`bundle install` case.
+      #
+      # Content-only — the resolved PATH is deliberately not in the payload, so a checkout that moves (a CI
+      # runner's workspace, a renamed directory) still hits with an identical lockfile.
+      def lockfile_entries(configuration)
+        bundler = Environment::LockfileResolver.resolve_lockfile_path(
+          lockfile_path: configuration.bundler_lockfile, auto_detect: configuration.bundler_auto_detect
+        )
+        collection = Environment::RbsCollectionDiscovery.resolve_lockfile_path(
+          lockfile_path: configuration.rbs_collection_lockfile,
+          auto_detect: configuration.rbs_collection_auto_detect
+        )
+        [lockfile_entry("bundler.lockfile", bundler), lockfile_entry("rbs_collection.lockfile", collection)]
+      end
+
+      # `nil` — no lockfile resolves — is itself part of the identity, so it carries its own sentinel rather
+      # than dropping the slot: "absent" and "present but empty" must not key the same.
+      ABSENT_LOCKFILE = "\0absent"
+
+      def lockfile_entry(key, path)
+        config_entry(key, path.nil? ? ABSENT_LOCKFILE : Cache::FileDigest.hexdigest(path.to_s))
+      end
+
       def config_entry(key, payload)
         Cache::Descriptor::ConfigEntry.new(key: key, value_hash: Digest::SHA256.hexdigest(payload))
       end

data/lib/rigor/analysis/runner/diagnostic_aggregator.rb

@@ -36,13 +36,16 @@ module Rigor
         #   because they do not parse (`[path, first_error_line]` pairs).
         # @param env_build_failure_snapshot [#call] reader returning the total RBS env-build failure tuple
         #   (`[error_class, first_error_line, conflicting_buffer_names]`) or nil when the env built.
+        # @param definition_build_failures_snapshot [#call] issue #696 — reader returning the per-class
+        #   `RBS::DefinitionBuilder` failures the run observed, as `[class_name, error_class, member,
+        #   conflicting_buffer_names]` tuples. Empty for a healthy sig set.
         # @param conformance_results_snapshot [#call] reader.
         def initialize(configuration:, rbs_extended_reporter:, boundary_cross_reporter:, # rubocop:disable Metrics/ParameterLists
                        source_rbs_synthesis_reporter:, plugin_registry:, dependency_source_index:,
                        pool_mode:, cached_plugin_prepare_diagnostics:,
                        pre_eval_diagnostics_from_scanner:, synthesized_namespaces_snapshot:,
                        quarantined_signatures_snapshot:, env_build_failure_snapshot:,
-                       conformance_results_snapshot:)
+                       definition_build_failures_snapshot:, conformance_results_snapshot:)
           @configuration = configuration
           @rbs_extended_reporter = rbs_extended_reporter
           @boundary_cross_reporter = boundary_cross_reporter
@@ -55,6 +58,7 @@ module Rigor
           @synthesized_namespaces_snapshot_reader = synthesized_namespaces_snapshot
           @quarantined_signatures_snapshot_reader = quarantined_signatures_snapshot
           @env_build_failure_snapshot_reader = env_build_failure_snapshot
+          @definition_build_failures_snapshot_reader = definition_build_failures_snapshot
           @conformance_results_snapshot_reader = conformance_results_snapshot
         end
 
@@ -351,6 +355,32 @@ module Rigor
           [build_rbs_environment_build_failed_diagnostic(failure)]
         end
 
+        # Issue #696 — the third rung of the same ladder, between its two neighbours by consequence: a
+        # QUARANTINED file removes what one FILE declared, this removes what one CLASS declared, an
+        # ENV-BUILD failure removes everything. `RBS::DefinitionBuilder` raising for a class (typically
+        # `DuplicatedMethodDefinitionError`: two signature sources declaring the same method, e.g. a project
+        # `sig/` carrying a vendored COPY of a bundled plugin's `.rbs`) leaves the class KNOWN but with no
+        # method surface, so every call on it — real methods and typos alike — reads `Dynamic[top]`. When
+        # the collision is on a class others inherit, the whole bundled type universe goes with it: the
+        # observed shape is thousands of stderr warnings, ZERO diagnostics, and exit 0.
+        #
+        # Not "drop the class to genuinely-unknown" instead. That also removes diagnostics, so it is not
+        # louder; it changes `Dynamic[top]` semantics for every rule that consults `class_known?`; and
+        # `class_known?` reads {Environment::RbsLoader#known_class_names_set}, a different table from the
+        # definition builder, so it would need a new "known but unbuildable" state regardless. The failure
+        # is made REPORTABLE; the class is not made invisible.
+        #
+        # Authored `:warning`, not `:error`, for the same reason as both neighbours: the collision is
+        # typically between the user's `sig/` and Rigor's OWN bundled RBS, so an `:error` default would let
+        # a Rigor release turn a green build red with no user change (ADR-5 / AGENTS.md § FP discipline).
+        # The `reject-unparseable-signatures` bleeding-edge feature promotes it to `:error`.
+        def rbs_definition_build_failed_diagnostics
+          failures = definition_build_failures_snapshot
+          return [] if failures.nil? || failures.empty?
+
+          [build_rbs_definition_build_failed_diagnostic(failures)]
+        end
+
         def rbs_synthesized_namespace_diagnostics
           synthesized = synthesized_namespaces_snapshot
           return [] if synthesized.nil? || synthesized.empty?
@@ -462,6 +492,64 @@ module Rigor
           )
         end
 
+        # Issue #696. One diagnostic per RUN, not per class: a collision on a widely-inherited class fails
+        # every descendant, and 2,709 rows saying the same thing about one `.rbs` line is noise, not
+        # visibility.
+        #
+        # The failed-class list alone is not actionable, and that is what the "First failure" clause is for.
+        # A duplicate on `::Object#blank?` fails `String`, `Integer`, `Array` and 1,333 more — every name in
+        # that list is a DESCENDANT, and none of them is where the fix goes. The member comes off the error
+        # object rather than out of its message ({RbsLoader#definition_build_member}), so it names the
+        # culprit and reads the same on a cache hit, where every `RBS::Location` has been dumped to a
+        # sentinel. The error class is attributed to that first failure explicitly rather than to all of
+        # them: the per-class memo keeps only the first reason, and one run can mix error classes.
+        def build_rbs_definition_build_failed_diagnostic(failures)
+          sample_size = 5
+          files = failures.flat_map { |failure| Array(failure[3]) }.uniq.map { |name| relative_signature_path(name) }
+          Diagnostic.new(
+            path: ".rigor.yml",
+            line: 1,
+            column: 1,
+            message: "#{failures.size} RBS class definition(s) failed to build: " \
+                     "#{sampled(failures.map(&:first), sample_size)}." \
+                     "#{first_failure_clause(failures.first)}#{conflicting_files_clause(files, sample_size)} " \
+                     "Rigor still treats each class as KNOWN, so calls into it — real methods and typos " \
+                     "alike — silently read `Dynamic[top]` instead of resolving, and this run is quieter " \
+                     "than it should be rather than cleaner. Two signature sources declare the same " \
+                     "member; remove the duplicate declaration (`rbs validate`) to restore type coverage.",
+            severity: :warning,
+            rule: "rbs.coverage.definition-build-failed",
+            source_family: :builtin
+          )
+        end
+
+        # `[class_name, error_class, member, buffers]`. The member is nil for the error classes that carry no
+        # name at all (`RecursiveAncestorError`), and the clause then names the error class alone rather than
+        # inventing a member.
+        def first_failure_clause(failure)
+          _, error_class, member, = failure
+          return " First failure: #{error_class}." if member.nil? || member.empty?
+
+          " First failure: #{error_class} on `#{member}`."
+        end
+
+        # Identical on a cache HIT: the ADR-54 env cache drops location POSITIONS but keeps each buffer's
+        # NAME, so a warm run names the same files a cold one does. Where a name is absent anyway, the
+        # reconstructed {RbsLoader::CACHED_LOCATION_BUFFER_NAME} sentinel is filtered out and the clause is
+        # omitted, rather than naming `<cached>` as if it were a path.
+        def conflicting_files_clause(files, sample_size)
+          return "" if files.empty?
+
+          " Conflicting signature file(s): #{sampled(files, sample_size)}."
+        end
+
+        # "a, b, c, and N more" — the sampling shape every `rbs.coverage.*` message above uses.
+        def sampled(names, sample_size)
+          sample = names.first(sample_size)
+          suffix = names.size > sample_size ? ", and #{names.size - sample_size} more" : ""
+          "#{sample.join(', ')}#{suffix}"
+        end
+
         # The absolute path is what the loader records; the user thinks in project-relative terms.
         def relative_signature_path(path)
           root = "#{Dir.pwd}#{File::SEPARATOR}"
@@ -684,6 +772,10 @@ module Rigor
           @env_build_failure_snapshot_reader.call
         end
 
+        def definition_build_failures_snapshot
+          @definition_build_failures_snapshot_reader.call
+        end
+
         def conformance_results_snapshot
           @conformance_results_snapshot_reader.call
         end

data/lib/rigor/analysis/runner/effect_envelope_pass.rb

@@ -30,11 +30,13 @@ module Rigor
       #
       # 1. **Read the envelopes** off the project's own RBS ({RbsExtended::EnvelopeScanner}). A project
       #    with `effects:` but no envelope pays this walk and stops here.
-      # 2. **Force cross-file discovery**, but only when step 1 found something — the diagnostic is
-      #    positioned at the Ruby `def`, and the discovery tables are what map a method key to one.
-      # 3. **Judge** ({Effects::EnvelopeCheck}) and render, then run the findings through the ordinary
-      #    suppression filter so `# rigor:disable effect.envelope-exceeded` on the `def` line and
-      #    `disable:` in `.rigor.yml` work exactly as they do for a per-file rule.
+      # 2. **Judge** ({Effects::EnvelopeCheck}). Cross-file discovery — the diagnostic is positioned
+      #    at the Ruby `def`, and the discovery tables are what map a method key to one — is forced
+      #    from inside the judgment, on the first finding built, so an envelope nothing exceeds costs
+      #    no discovery parse at all.
+      # 3. **Render**, then run the findings through the ordinary suppression filter so
+      #    `# rigor:disable effect.envelope-exceeded` on the `def` line and `disable:` in `.rigor.yml`
+      #    work exactly as they do for a per-file rule.
       #
       # **Why this is not part of the cached run assembly.** ADR-103 WD12 says envelope diagnostics are
       # recomputed every run from the (possibly cached) summaries and never stored. The `effects:` block
@@ -80,7 +82,8 @@ module Rigor
         # @param rbs_loader [Rigor::Environment::RbsLoader, nil] the run's loader; nil disables the pass.
         # @param effect_table [Rigor::Effects::EffectTable] the propagated graph.
         # @param discovery [#call] forces and returns the cross-file discovery tables as
-        #   `[def_sources, singleton_def_sources, class_sources]`. Called only when an envelope exists.
+        #   `[def_sources, singleton_def_sources, class_sources]`. Called only when a finding needs a
+        #   position — a judged-clean envelope never forces it.
         # @param sources [Hash{String => String}] in-memory sources, for the buffer-backed run path.
         # @param unit_sources [Hash{String => Array<String>}] `Runner#effect_sources` — where each effect
         #   unit is defined, which is what an `effects.envelopes[].match:` path glob selects on. Its paths
@@ -272,9 +275,12 @@ module Rigor
           )
         end
 
-        # The discovery tables both judgments position their findings from, forced once.
+        # The discovery tables both judgments position their findings from — behind a deferred value,
+        # forced at most once, on the first finding either judgment builds. A clean run (an envelope
+        # nothing exceeds — the common CI case) therefore never calls `@discovery` at all, which on a
+        # warm run is the difference between a no-op and a Prism parse of every project file.
         def positions
-          @positions ||= begin
+          @positions ||= Effects::EnvelopeCheck::DeferredPositions.new do
             def_sources, singleton_def_sources, class_sources = @discovery.call
             Effects::EnvelopeCheck::Positions.build(
               def_sources: def_sources, singleton_def_sources: singleton_def_sources,

data/lib/rigor/analysis/runner/pool_coordinator.rb

@@ -126,6 +126,10 @@ module Rigor
           snapshot_project_signature_state(environment)
           snapshot_effect_annotation_carrier(environment&.rbs_loader)
           result = files.flat_map { |path| @analyze_file.call(path, environment) }
+          # Issue #696 — AFTER the loop, deliberately. Definition builds are lazy (ADR-54 WD1: per class, on
+          # first demand), so a snapshot taken beside the ones above — which run BEFORE `files.flat_map` —
+          # would read an empty list on every run, including the ones this diagnostic exists for.
+          record_definition_build_failures(environment&.rbs_loader&.definition_build_failures)
           if @collect_stats
             loader = environment.rbs_loader
             @snapshots.class_decl_paths = loader&.class_decl_paths || {}.freeze
@@ -567,6 +571,11 @@ module Rigor
           snapshot_effect_annotation_carrier(environment.rbs_loader)
           diagnostics = files.flat_map { |path| @analyze_file.call(path, environment) }
           loader = environment.rbs_loader
+          # Issue #696 — this path analyses on the coordinator, so its loader IS the one that reached the
+          # failing build, and it must snapshot the same slot the two real paths do. Reached whenever
+          # `fork` is unavailable (Windows) and on `--incremental` / effects runs without it: a run that
+          # degraded to sequential must not also report less than a sequential run would.
+          record_definition_build_failures(loader&.definition_build_failures)
           @snapshots.class_decl_paths = loader&.class_decl_paths || {}.freeze
           @snapshots.signature_paths = loader&.signature_paths || [].freeze
           @snapshots.quarantined_signatures =
@@ -608,10 +617,35 @@ module Rigor
               plugin_id: entry.plugin_id, path: entry.path, message: entry.message
             )
           end
+          # Issue #696. Fetched with a default so an older drain stays compatible, exactly as the line above.
+          record_definition_build_failures(drained[:definition_build_failures])
         end
 
         private
 
+        # Issue #696 — accumulate the per-class `RBS::DefinitionBuilder` failures this run observed, deduped
+        # by class name and kept in first-seen order.
+        #
+        # Accumulating rather than assigning is what makes a pooled run say what a sequential one says: each
+        # worker holds its OWN loader and its own memo (the `@state` that also gates the stderr banner, which
+        # is why the banner repeats per worker — #295), so a class that fails in two workers arrives twice
+        # and a class only one worker touched arrives once. The union over the workers is the set the RUN
+        # hit; neither worker alone is.
+        #
+        # NOT gated on `project_signature_paths?`, unlike {#snapshot_project_signature_state}. That gate
+        # exists because each condition there forces the otherwise-lazy env build, which would warm the cache
+        # on a project with no sig set of its own. Nothing is forced here — this reads what the analysis
+        # already demanded — and the failure is not a project-sig-only condition anyway: two BUNDLED sources
+        # declaring the same method collapse a class with no `signature_paths:` in sight (the
+        # `bigdecimal` / `BigMath` shape, #299). Gating it would suppress exactly the variant the user cannot
+        # fix by editing their own `sig/`.
+        def record_definition_build_failures(failures)
+          return if failures.nil? || failures.empty?
+
+          @snapshots.definition_build_failures =
+            (@snapshots.definition_build_failures + failures).uniq(&:first).freeze
+        end
+
         # True when the project declares its own `signature_paths:` (the only place the
         # qualified-name-without-namespace mistake lives).
         def project_signature_paths?

data/lib/rigor/analysis/runner/project_pre_passes.rb

@@ -53,17 +53,11 @@ module Rigor
         # consumes them and so never pays the double parse (see {#discover} + `Runner#ensure_project_discovery`).
         # The slot names mirror the discovery half of {Result} exactly.
         Discovery = Data.define(
-          :discovered_classes,
-          :discovered_def_nodes,
-          :discovered_singleton_def_nodes,
-          :discovered_def_sources,
-          :discovered_singleton_def_sources,
-          :discovered_superclasses,
-          :discovered_includes,
-          :discovered_class_sources,
-          :discovered_method_visibilities,
-          :discovered_methods,
-          :data_member_layouts,
+          :discovered_classes, :discovered_def_nodes, :discovered_def_nestings,
+          :discovered_singleton_def_nodes, :discovered_def_sources, :discovered_singleton_def_sources,
+          :discovered_superclasses, :discovered_header_nestings, :discovered_includes,
+          :discovered_class_sources, :constant_values, :constant_sources, :constant_writes,
+          :discovered_method_visibilities, :discovered_methods, :data_member_layouts,
           :struct_member_layouts
         )
 
@@ -156,12 +150,22 @@ module Rigor
           Discovery.new(
             discovered_classes: index.fetch(:classes),
             discovered_def_nodes: def_index.fetch(:def_nodes),
+            # Issue #681 — the recorded `Module.nesting` per declared `def`, so a callee's body re-walk
+            # resolves its constants the way the declaration that owns it does.
+            discovered_def_nestings: def_index.fetch(:def_nestings),
             discovered_singleton_def_nodes: def_index.fetch(:singleton_def_nodes),
             discovered_def_sources: def_index.fetch(:def_sources),
             discovered_singleton_def_sources: def_index.fetch(:singleton_def_sources),
             discovered_superclasses: def_index.fetch(:superclasses),
+            # Issue #682 — the nesting each declaration header is written in, so an ancestor name resolves in
+            # the cref Ruby resolves it in rather than by peeling the subclass's own qualified name.
+            discovered_header_nestings: def_index.fetch(:header_nestings),
             discovered_includes: def_index.fetch(:includes),
             discovered_class_sources: def_index.fetch(:class_sources),
+            # Issue #644 — the cross-file value-constant publication table and its write attribution.
+            constant_values: def_index.fetch(:constant_values),
+            constant_sources: def_index.fetch(:constant_sources),
+            constant_writes: def_index.fetch(:constant_writes),
             discovered_method_visibilities: def_index.fetch(:method_visibilities),
             discovered_methods: def_index.fetch(:methods),
             data_member_layouts: def_index.fetch(:data_member_layouts),

data/lib/rigor/analysis/runner/run_snapshots.rb

@@ -17,12 +17,15 @@ module Rigor
       class RunSnapshots
         attr_accessor :class_decl_paths, :signature_paths,
                       :synthesized_namespaces, :quarantined_signatures, :conformance_results,
-                      :env_build_failure, :effect_annotation_carrier
+                      :env_build_failure, :definition_build_failures, :effect_annotation_carrier
 
         # Constructor defaults match the {Runner} constructor: the pre-seed values `build_run_stats` /
         # `pre_file_diagnostics` read before the first analysis path runs are frozen empties. The
         # `env_build_failure` slot is nil (no failure) rather than an empty collection — it holds a single
-        # `[error_class, first_line, buffer_names]` tuple or nothing.
+        # `[error_class, first_line, buffer_names]` tuple or nothing. Its per-class sibling
+        # `definition_build_failures` (#696) holds a LIST, because a collapsed universe fails many classes,
+        # and is accumulated ACROSS pool workers rather than assigned once — see
+        # {PoolCoordinator#merge_worker_reporters}.
         def initialize
           @class_decl_paths = {}.freeze
           @signature_paths = [].freeze
@@ -30,6 +33,7 @@ module Rigor
           @quarantined_signatures = [].freeze
           @conformance_results = [].freeze
           @env_build_failure = nil
+          @definition_build_failures = [].freeze
           @effect_annotation_carrier = [].freeze
         end
 
@@ -42,6 +46,7 @@ module Rigor
           @quarantined_signatures = []
           @conformance_results = []
           @env_build_failure = nil
+          @definition_build_failures = []
           @effect_annotation_carrier = [].freeze
         end
       end