rigortype 0.4.5 → 0.4.7

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

@@ -29,36 +29,25 @@ module Rigor
         # @param pool_mode — reader returning the pool-mode flag.
         # @param cached_plugin_prepare_diagnostics — reader returning the prepare-diagnostic snapshot.
         # @param pre_eval_diagnostics_from_scanner — reader returning the pre-eval scanner diagnostics.
-        # @param synthesized_namespaces_snapshot — reader.
-        # @param quarantined_signatures_snapshot — reader returning the `signature_paths:` files skipped
-        #   because they do not parse (`[path, first_error_line]` pairs).
-        # @param signature_standdowns_snapshot — reader returning the plugin-contributed signature files
-        #   that stood down against a colliding generic arity (#610), as
-        #   `[path, class_name, existing_arity, incoming_arity, existing_file]` tuples. Defaults to none so
-        #   a caller that snapshots nothing of the kind need not say so.
-        # @param vendored_standdowns_snapshot — issue #1713 — reader returning what each required-feature-gated
-        #   vendored directory left out (`Environment::RbsLoader#vendored_standdowns`). Defaults to none.
-        # @param env_build_failure_snapshot — 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 — issue #696 — reader returning the per-class
-        #   `RBS::DefinitionBuilder` failures the run observed, as `[class_name, error_class, member,
-        #   conflicting_buffer_names, unresolved_type_name_detail]` tuples (issue #997 added the fifth
-        #   element — `[token, location, refinement_hint]`, `nil` unless `error_class` is
-        #   `RBS::NoTypeFoundError`). Empty for a healthy sig set.
-        # @param hkt_scan_failure_snapshot — issue #784 — reader returning the `[error_class_name,
-        #   first_message_line, raw_frame_or_nil, stage]` tuple whichever stage of the HKT-registry build
-        #   raised, or nil when both built (or were never demanded). `stage` is `:scan` (the RBS `type`-alias
-        #   scan) or `:overlay` (the plugin-manifest aggregation, #791), and picks the row's wording.
-        # @param conformance_results_snapshot — reader.
+        # @param snapshots — the run's {RunSnapshots} store (ADR-116 WD3), read at row-build time. Its slots'
+        #   shapes, as the rows below read them:
+        #   - `quarantined_signatures` — the `signature_paths:` files skipped because they do not parse
+        #     (`[path, first_error_line]` pairs);
+        #   - `signature_standdowns` (#610) — `[path, class_name, existing_arity, incoming_arity,
+        #     existing_file]` tuples, then (#2422) `[path, declaration, nil, nil, cause_file, :member]` ones;
+        #   - `vendored_standdowns` (#1713) — `Environment::RbsLoader#vendored_standdowns`;
+        #   - `env_build_failure` — `[error_class, first_error_line, conflicting_buffer_names]`, or nil;
+        #   - `definition_build_failures` (#696) — `[class_name, error_class, member,
+        #     conflicting_buffer_names, unresolved_type_name_detail, mixin_count]` tuples (#997 added the fifth
+        #     element — `[token, location, refinement_hint]`, `nil` unless `error_class` is
+        #     `RBS::NoTypeFoundError`; #2440 the sixth, {Environment::RbsLoader#variable_mixin_count});
+        #   - `hkt_scan_failure` (#784) — `[error_class_name, first_message_line, raw_frame_or_nil, stage]`,
+        #     or nil; `stage` is `:scan` or `:overlay` (#791) and picks the row's wording.
         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:,
-                       definition_build_failures_snapshot:, hkt_scan_failure_snapshot:,
-                       conformance_results_snapshot:, signature_standdowns_snapshot: -> { [] },
-                       vendored_standdowns_snapshot: -> { [] }, pooled_run_disclosures: -> { [] },
-                       pooled_trust_refusals: -> { [] })
+                       pre_eval_diagnostics_from_scanner:, snapshots:, pooled_run_disclosures: -> { [] },
+                       served_run_disclosures: -> { [] }, pooled_trust_refusals: -> { [] })
           @configuration = configuration
           @rbs_extended_reporter = rbs_extended_reporter
           @boundary_cross_reporter = boundary_cross_reporter
@@ -68,22 +57,25 @@ module Rigor
           @pool_mode_reader = pool_mode
           @cached_plugin_prepare_diagnostics_reader = cached_plugin_prepare_diagnostics
           @pre_eval_diagnostics_from_scanner_reader = pre_eval_diagnostics_from_scanner
-          @synthesized_namespaces_snapshot_reader = synthesized_namespaces_snapshot
-          @quarantined_signatures_snapshot_reader = quarantined_signatures_snapshot
-          @signature_standdowns_snapshot_reader = signature_standdowns_snapshot
-          @vendored_standdowns_snapshot_reader = vendored_standdowns_snapshot
-          @env_build_failure_snapshot_reader = env_build_failure_snapshot
-          @definition_build_failures_snapshot_reader = definition_build_failures_snapshot
-          @hkt_scan_failure_snapshot_reader = hkt_scan_failure_snapshot
-          @conformance_results_snapshot_reader = conformance_results_snapshot
+          @snapshots = snapshots
           # Issue #1051 — reader for the pool coordinator's de-duplicated run-scoped disclosure table.
           # Empty on a sequential run, where `plugin_registry`'s own instances are the ones that registered.
           @pooled_run_disclosures_reader = pooled_run_disclosures
+          # Issue #2020 — reader for the rows an incremental recheck replays for the files it served unanalysed.
+          @served_run_disclosures_reader = served_run_disclosures
           # Issue #1900 — reader for the pool coordinator's summed trust-refusal table. Empty on a
           # sequential run, where `plugin_registry`'s own boundaries made every read.
           @pooled_trust_refusals_reader = pooled_trust_refusals
         end
 
+        # ADR-116 WD3 — every post-analysis run-level row, in the contract order {RunLevelFacts.row_builders}
+        # declares: the `rbs.coverage.*` build-failure ladder widest consequence first, its `:info` notices,
+        # the conformance rows, the reporter streams, then the plugin run disclosures and the trust-refusal
+        # envelope, read last so every per-file plugin call has recorded its refusals.
+        def run_level_diagnostics
+          RunLevelFacts.row_builders.flat_map { |builder| public_send(builder) }
+        end
+
         # Pre-file diagnostic streams that fire once per run rather than per analyzed file: plugin load /
         # prepare envelopes, the ADR-10 dependency-source resolution surface, and the `expand_paths` errors
         # for `paths:` entries that don't exist or aren't `.rb`. Aggregated here so `#run` stays under the
@@ -92,9 +84,9 @@ module Rigor
         # ADR-15 Phase 4b — `plugin_prepare_diagnostics` runs on the coordinator's plugin registry under
         # sequential mode; under pool mode each worker re-runs `prepare` against its own plugin instances,
         # so the pool path drains the first worker's prepare-diagnostic snapshot into the aggregated
-        # diagnostic stream instead (see {#analyze_files_in_pool}). Skipping the coordinator prepare in pool
-        # mode avoids double-running `#prepare` against the coordinator-side plugin instances (which the
-        # pool path never consults for per-file analysis).
+        # diagnostic stream instead (see {PoolCoordinator#analyze_files_in_pool}). Skipping the coordinator
+        # prepare in pool mode avoids double-running `#prepare` against the coordinator-side plugin instances
+        # (which the pool path never consults for per-file analysis).
         def pre_file_diagnostics(expansion)
           # ADR-18 slice 3 — prepare diagnostics are captured earlier in #run (before the synthetic-method
           # scanner) so cross-plugin facts are available to the scanner. We re-surface the captured
@@ -269,6 +261,9 @@ module Rigor
             project_root: Dir.pwd,
             auto_detect: @configuration.bundler_auto_detect
           )
+          # Issue #2441 — the project's own path gems are not dependencies missing RBS; the environment skips
+          # their collection copy, so the same set leaves the report here.
+          locked = locked.except(*project_own_gem_names(locked))
           return [] if locked.empty?
 
           bundle_sig_paths = Environment::BundleSigDiscovery.discover(
@@ -294,6 +289,16 @@ module Rigor
           [build_rbs_coverage_missing_diagnostic(missing)]
         end
 
+        # Issue #2441 — the same project-own set `Environment.for_project` skips the collection copy of.
+        def project_own_gem_names(locked)
+          Environment::ProjectPathGems.names(
+            locked,
+            paths: @configuration.paths, root: Dir.pwd,
+            exclude_patterns: @configuration.exclude_patterns, exclude_base: @configuration.exclude_base
+          )
+        end
+        private :project_own_gem_names
+
         # ADR-93 WD3 — the standalone residual. A bare `gem install rigortype` has no `rbs-inline` library,
         # so the spec's "annotations are official type sources whenever present" cannot be satisfied: the
         # annotated code reads `Dynamic[top]`. When the library is absent AND the project actually carries
@@ -377,7 +382,7 @@ module Rigor
         # the `reject-unparseable-signatures` feature promotes this rule to `:error` for anyone who opts in
         # (and by default at the next major).
         def rbs_quarantined_signature_diagnostics
-          quarantined = quarantined_signatures_snapshot
+          quarantined = @snapshots[:quarantined_signatures]
           return [] if quarantined.empty?
 
           [build_rbs_quarantined_signature_diagnostic(quarantined)]
@@ -398,7 +403,7 @@ module Rigor
         # `reject-unparseable-signatures` bleeding-edge feature promotes it to `:error` for anyone who opts in
         # (and by default at the next major).
         def rbs_environment_build_failed_diagnostics
-          failure = env_build_failure_snapshot
+          failure = @snapshots[:env_build_failure]
           return [] if failure.nil?
 
           [build_rbs_environment_build_failed_diagnostic(failure)]
@@ -424,7 +429,7 @@ module Rigor
         # 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
+          failures = @snapshots[:definition_build_failures]
           return [] if failures.nil? || failures.empty?
 
           [build_rbs_definition_build_failed_diagnostic(failures)]
@@ -443,14 +448,14 @@ module Rigor
         # surface, no signature file is skipped, the environment builds. That is why this sits LAST on the
         # ladder, after its two `rbs.coverage.*` siblings above.
         def rbs_hkt_scan_failed_diagnostics
-          failure = hkt_scan_failure_snapshot
+          failure = @snapshots[:hkt_scan_failure]
           return [] if failure.nil?
 
           [build_rbs_hkt_scan_failed_diagnostic(failure)]
         end
 
         def rbs_synthesized_namespace_diagnostics
-          synthesized = synthesized_namespaces_snapshot
+          synthesized = @snapshots[:synthesized_namespaces]
           return [] if synthesized.nil? || synthesized.empty?
 
           [build_rbs_synthesized_namespace_diagnostic(synthesized)]
@@ -463,10 +468,12 @@ module Rigor
         # typing they are not getting and why, and — unlike the quarantine row this file used to be
         # misreported as — is not sent to remove a declaration the plugin owns.
         def rbs_plugin_signature_stood_down_diagnostics
-          standdowns = signature_standdowns_snapshot
+          standdowns = @snapshots[:signature_standdowns]
           return [] if standdowns.nil? || standdowns.empty?
 
-          standdowns.map { |entry| build_rbs_plugin_signature_stood_down_diagnostic(entry) }
+          members, files = standdowns.partition { |entry| entry[5] == :member }
+          files.map { |entry| build_rbs_plugin_signature_stood_down_diagnostic(entry) } +
+            members.group_by(&:first).map { |path, rows| build_rbs_plugin_member_stood_down_diagnostic(path, rows) }
         end
 
         # Issue #1713 — the other outcome that avoided a definition-build failure: a required-feature-gated
@@ -474,7 +481,7 @@ module Rigor
         # declares — a member, a whole type, or, when nothing narrower built, the directory. One `:info` per
         # directory, naming the declarations that stood down and the files that displaced them.
         def rbs_vendored_signature_stood_down_diagnostics
-          standdowns = vendored_standdowns_snapshot
+          standdowns = @snapshots[:vendored_standdowns]
           return [] if standdowns.nil? || standdowns.empty?
 
           standdowns.map { |entry| build_rbs_vendored_signature_stood_down_diagnostic(entry) }
@@ -496,7 +503,7 @@ module Rigor
         # conformance; every analysis path, pooled or degraded, takes the snapshot `synthesized_namespaces`
         # comes from.
         def conforms_to_diagnostics
-          results = conformance_results_snapshot
+          results = @snapshots[:conformance_results]
           return [] if results.nil? || results.empty?
 
           results.map { |record| build_conformance_diagnostic(record) }
@@ -628,7 +635,7 @@ module Rigor
           failures = failures.sort_by { |failure| failure.first.to_s }
           sample_size = 5
           files = failures.flat_map { |failure| Array(failure[3]) }
-                          .map { |name| relative_signature_path(name) }.uniq.sort
+                          .map { |name| signature_source_label(name.to_s) }.uniq.sort
           Diagnostic.new(
             path: ".rigor.yml",
             line: 1,
@@ -639,32 +646,120 @@ module Rigor
                      "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. #{definition_build_advice(failures.first)}",
-            severity: :warning,
+            severity: selected_core_failure?(failures) ? :error : :warning,
             rule: "rbs.coverage.definition-build-failed",
             source_family: :builtin
           )
         end
 
+        # Issue #2517 — a class that does not build from the selected `core_root:` alone is that explicit choice
+        # failing, not a Rigor release disagreeing with the user's `sig/`, so it is an error. A failure that also
+        # names a file outside the core (a project `sig/` collision) keeps the warning it has without one.
+        def selected_core_failure?(failures)
+          core_root = @configuration.core_root
+          return false if core_root.nil?
+
+          prefix = File.join(core_root, "")
+          failures.any? do |failure|
+            buffers = Array(failure[3]).map(&:to_s)
+            !buffers.empty? && buffers.all? { |name| name.start_with?(prefix) }
+          end
+        end
+
         # The closing advice follows the FIRST failure's error class: `GenericParameterMismatchError` is two
         # declarations of one CLASS at different generic arity (#610); `NoTypeFoundError` (issue #997) is
         # ONE declaration naming a type that does not exist, which "remove the duplicate declaration" sends
         # its reader after a duplicate that is not there — the fifth tuple element
-        # ({RbsLoader#unresolved_type_name_detail}) is non-nil for exactly that case. Every other error class
-        # (the two duplicated-definition errors, `RecursiveAncestorError`, …) keeps the duplicate-declaration
-        # wording, which is accurate for them.
+        # ({RbsLoader#unresolved_type_name_detail}) is non-nil for exactly that case. Issue #2440 — a
+        # duplicated instance variable, a superclass mismatch, a missing superclass and a type applied to
+        # the wrong arguments each get their own sentence, and when a `virtual:` (inline RBS) buffer is
+        # among the colliding sources the advice never tells the reader to remove it as if it were a file.
+        # Every other error class (the two duplicated-definition errors, `RecursiveAncestorError`, …) keeps
+        # the duplicate-declaration wording, which is accurate for them.
         def definition_build_advice(failure)
-          _, error_class, _member, _buffers, unresolved = failure
-          if error_class.to_s.end_with?("GenericParameterMismatchError")
+          _, error_class, member, buffers, unresolved = failure
+          inline = Array(buffers).any? { |name| name.to_s.start_with?("virtual:") }
+          case error_class.to_s.split("::").last
+          when "GenericParameterMismatchError"
             "Two signature sources declare the class with a different number of type parameters; make " \
-              "the declarations agree (`rbs validate`) to restore type coverage."
-          elsif unresolved
-            unresolved_type_name_advice(unresolved)
+            "the declarations agree (`rbs validate`) to restore type coverage."
+          when "InstanceVariableDuplicationError" then variable_duplication_advice("instance variable", failure)
+          when "ClassInstanceVariableDuplicationError"
+            variable_duplication_advice("class instance variable", failure)
+          when "SuperclassMismatchError" then superclass_mismatch_advice(inline)
+          when "NoSuperclassFoundError" then no_superclass_advice(member)
+          when "InvalidTypeApplicationError" then invalid_type_application_advice(member)
           else
+            return unresolved_type_name_advice(unresolved) if unresolved
+
             "Two signature sources declare the same member; remove the duplicate declaration " \
               "(`rbs validate`) to restore type coverage."
           end
         end
 
+        # The sixth tuple slot ({RbsLoader#variable_mixin_count}) is set only when the failing class mixes in
+        # the variable's owner at least twice and the owner declares it once: rbs counts the variable once per
+        # mixin. Otherwise — a variable duplicated in the owner itself, inherited or not — the wording follows
+        # which sources collide: inline only, inline and a file, two files, or one file declaring it twice.
+        def variable_duplication_advice(noun, failure)
+          class_name, _, member, buffers, _, mixins = failure
+          if mixins.is_a?(Integer) && mixins >= 2
+            return mixin_variable_duplication_advice(noun, class_name.to_s.delete_prefix("::"),
+                                                     member.to_s.delete_prefix("::"))
+          end
+
+          names = Array(buffers).map(&:to_s)
+          inline = names.count { |name| name.start_with?("virtual:") }
+          if inline >= 2 && inline == names.size
+            "Two inline `# @rbs` annotations declare the same #{noun} in one class, and RBS rejects the " \
+              "pair even when the types agree; keep one of them to restore type coverage."
+          elsif inline.positive?
+            "The same #{noun} is declared twice in one class, at least once by an inline `# @rbs` " \
+              "annotation, and RBS rejects the pair even when the types agree. Keep one declaration: " \
+              "regenerate the committed `.rbs` (`rbs-inline --output`) or remove its copy of the " \
+              "variable, or drop the annotation from the `.rb` file, to restore type coverage."
+          elsif names.size >= 2
+            "Two signature files declare the same #{noun} in one class, and RBS rejects the pair even " \
+              "when the types agree; keep one declaration (`rbs validate`) to restore type coverage."
+          else
+            "The same #{noun} is declared twice in one class, and RBS rejects the pair even when the " \
+              "types agree; keep one declaration (`rbs validate`) to restore type coverage."
+          end
+        end
+
+        def mixin_variable_duplication_advice(noun, klass, owner)
+          "`#{klass}` mixes in `#{owner}` (`include`, `extend` or `prepend`) more than once, in one " \
+            "declaration or across several, and RBS counts each #{noun} `#{owner}` declares once per mixin. " \
+            "Keep a single mixin of `#{owner}` in `#{klass}` (a committed `rbs-inline --output` file and the " \
+            "`.rb` file it came from count as two declarations) to restore type coverage."
+        end
+
+        def superclass_mismatch_advice(inline)
+          advice = "Two declarations of the class name different superclasses; make them name the same " \
+                   "one, or leave the superclass off every declaration but one (a reopening needs none), " \
+                   "to restore type coverage."
+          return advice unless inline
+
+          "#{advice} Where one side is an inline annotation, fix the annotation and regenerate the " \
+            "committed `.rbs` (`rbs-inline --output`), or remove the committed copy."
+        end
+
+        def no_superclass_advice(member)
+          name = member.to_s.delete_prefix("::")
+          subject = name.empty? ? "A superclass" : "`#{name}`"
+          "#{subject} is named as a superclass, but no loaded signature declares it; declare it in your " \
+            "`sig/` (or load the library that does through `libraries:`), or re-run `rigor sig-gen` if " \
+            "the signature was generated, to restore type coverage."
+        end
+
+        def invalid_type_application_advice(member)
+          name = member.to_s.delete_prefix("::")
+          subject = name.empty? ? "a type" : "`#{name}`"
+          "A signature applies #{subject} with the wrong number of type arguments, or applies them to the " \
+            "wrong class; match the arguments to the type parameters the class declares (`rbs validate`) " \
+            "to restore type coverage."
+        end
+
         # Issue #997 — `unresolved` is {RbsLoader#unresolved_type_name_detail}'s `[token, location,
         # refinement_hint]`. `refinement_hint` turns the message into a fix: the token is not a typo to
         # chase down but the start of a Rigor refinement name that is not valid in an RBS type position, and
@@ -775,6 +870,15 @@ module Rigor
         end
 
         # The absolute path is what the loader records; the user thinks in project-relative terms.
+        # Issue #2440 — a `virtual:<plugin>:<path>` buffer is named by the `.rb` file it was synthesized
+        # from, which is the file the user can open; the plugin id says how it became RBS.
+        def signature_source_label(name)
+          prefix, plugin_id, path = name.split(":", 3)
+          return relative_signature_path(name) unless prefix == "virtual" && plugin_id && path && !path.empty?
+
+          "#{relative_signature_path(path)} (inline RBS via #{plugin_id})"
+        end
+
         def relative_signature_path(path)
           root = "#{Dir.pwd}#{File::SEPARATOR}"
           path.start_with?(root) ? path.delete_prefix(root) : path
@@ -822,6 +926,33 @@ module Rigor
           )
         end
 
+        # Issue #2422 — one plugin signature file that loaded without the declarations another source also makes,
+        # naming each (sampled) with the file whose declaration was used instead. One row per file, not per
+        # declaration: an `rbs collection install` of a gem can overlap the plugin for it on hundreds. A method
+        # that composed with the other source's as an overload is not here; the plugin's overloads still bind.
+        # The wording covers a superclass a plugin's class header gave up (#2439) as well as a member.
+        def build_rbs_plugin_member_stood_down_diagnostic(path, rows)
+          labels = rows.map do |_path, declaration, _, _, cause_file|
+            cause = cause_file.nil? || cause_file.empty? ? "" : " (#{relative_signature_path(cause_file.to_s)})"
+            "`#{declaration}`#{cause}"
+          end
+          Diagnostic.new(
+            path: ".rigor.yml",
+            line: 1,
+            column: 1,
+            message: "`#{relative_signature_path(path.to_s)}` (a signature file a plugin contributes) loaded without " \
+                     "#{rows.size} declaration(s) another signature source already makes: #{sampled(labels, 10)}. " \
+                     "Conflicting declarations (two of one method or constant, or two different superclasses " \
+                     "of one class) fail the build, so the plugin's stood down and the other source's, named in " \
+                     "parentheses, is used; the rest of the plugin's file still " \
+                     "loads. Nothing to fix unless you want the plugin's typing back, which needs that source to " \
+                     "stop declaring it.",
+            severity: :info,
+            rule: "rbs.coverage.plugin-signature-stood-down",
+            source_family: :builtin
+          )
+        end
+
         def build_rbs_vendored_signature_stood_down_diagnostic(entry)
           dir, declarations, whole = entry
           Diagnostic.new(
@@ -934,9 +1065,12 @@ module Rigor
         # all three cross the pool drain channel (see {RbsExtended::Reporter}); an entry with no position
         # falls back to `.rigor.yml`-style file-level attribution.
         def rbs_extended_reporter_diagnostics
-          return [] if @rbs_extended_reporter.empty?
+          unresolved_payload_diagnostics + lossy_projection_diagnostics + hkt_directive_diagnostics +
+            deprecated_form_diagnostics
+        end
 
-          unresolved = @rbs_extended_reporter.unresolved_payloads.map do |entry|
+        def unresolved_payload_diagnostics
+          @rbs_extended_reporter.unresolved_payloads.map do |entry|
             build_positioned_reporter_diagnostic(
               entry,
               rule: "dynamic.rbs-extended.unresolved",
@@ -945,8 +1079,10 @@ module Rigor
                        "that contributes the referenced type vocabulary."
             )
           end
+        end
 
-          lossy = @rbs_extended_reporter.lossy_projections.map do |entry|
+        def lossy_projection_diagnostics
+          @rbs_extended_reporter.lossy_projections.map do |entry|
             build_positioned_reporter_diagnostic(
               entry,
               rule: "dynamic.shape.lossy-projection",
@@ -955,8 +1091,6 @@ module Rigor
                        "a `HashShape` / `Tuple` carrier or accept the unchanged result."
             )
           end
-
-          unresolved + lossy + hkt_directive_diagnostics + deprecated_form_diagnostics
         end
 
         # ADR-109 WD3 — one row per annotation still written in a spelling the grammar accepts but no
@@ -1116,12 +1250,14 @@ module Rigor
         end
 
         # Issue #1051 — the run-scoped plugin disclosures ({Plugin::Base#disclose_once}), the run's
-        # project-global notices about its own inputs. Two sources feed one table:
+        # project-global notices about its own inputs. Three sources feed one table:
         #
         # - the coordinator-side registry, which is where a SEQUENTIAL run's `#prepare` and per-file hooks
         #   ran; and
         # - `pooled_run_disclosures`, the pool coordinator's already-de-duplicated collection from the
-        #   pre-fork parent session and every worker payload.
+        #   pre-fork parent session and every worker payload; and
+        # - `served_run_disclosures` (#2020), the rows an incremental recheck replays for the files it served
+        #   from cache, since their per-file hooks did not run.
         #
         # Both are keyed `[plugin id, key]` and the first registration of a pair wins, so a run emits one
         # row per pair no matter how many plugin instances (workers) reached it — the #1051 bug, where a
@@ -1183,6 +1319,10 @@ module Rigor
           rescue StandardError
             next
           end
+          # Issue #2020 — last, so a row this run registered afresh wins over the replay of the same key.
+          Array(@served_run_disclosures_reader.call).each do |record|
+            records[[record[:plugin_id], record[:key]]] ||= record
+          end
           records.values
         end
 
@@ -1322,38 +1462,6 @@ module Rigor
         def pre_eval_diagnostics_from_scanner
           @pre_eval_diagnostics_from_scanner_reader.call
         end
-
-        def synthesized_namespaces_snapshot
-          @synthesized_namespaces_snapshot_reader.call
-        end
-
-        def quarantined_signatures_snapshot
-          @quarantined_signatures_snapshot_reader.call
-        end
-
-        def signature_standdowns_snapshot
-          @signature_standdowns_snapshot_reader.call
-        end
-
-        def vendored_standdowns_snapshot
-          @vendored_standdowns_snapshot_reader.call
-        end
-
-        def env_build_failure_snapshot
-          @env_build_failure_snapshot_reader.call
-        end
-
-        def definition_build_failures_snapshot
-          @definition_build_failures_snapshot_reader.call
-        end
-
-        def hkt_scan_failure_snapshot
-          @hkt_scan_failure_snapshot_reader.call
-        end
-
-        def conformance_results_snapshot
-          @conformance_results_snapshot_reader.call
-        end
       end
     end
   end

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

@@ -78,7 +78,7 @@ module Rigor
         LABELS_CONSEQUENCE = "the label is not registered"
         private_constant :LABELS_CONSEQUENCE
 
-        # @param rbs_loader — the run's loader; nil disables the pass.
+        # @param rbs_loader — the run's loader; nil skips the RBS walk, not the configured envelopes.
         # @param effect_table — the propagated graph.
         # @param discovery — forces and returns the cross-file discovery tables as
         #   `[def_sources, singleton_def_sources, class_sources]`. Called only when a finding needs a