rigortype 0.3.8 → 0.3.9

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

@@ -3,6 +3,7 @@
 require "tmpdir"
 
 require_relative "../../environment"
+require_relative "../../project_environment"
 require_relative "../diagnostic"
 require_relative "../worker_session"
 require_relative "../run_stats"
@@ -29,30 +30,21 @@ module Rigor
       # delegated back through an injected `analyze_file` callable so the CheckRules / recorder /
       # plugin-emission machinery stays on the {Runner}.
       class PoolCoordinator # rubocop:disable Metrics/ClassLength
-        # @param configuration [Rigor::Configuration]
-        # @param cache_store [Rigor::Cache::Store, nil]
-        # @param explain [Boolean]
-        # @param workers [Integer]
-        # @param collect_stats [Boolean]
-        # @param buffer [BufferBinding, nil]
-        # @param environment_override [Rigor::Environment, nil]
-        # @param rbs_extended_reporter [RbsExtended::Reporter]
-        # @param boundary_cross_reporter [DependencySourceInference::BoundaryCrossReporter]
-        # @param source_rbs_synthesis_reporter [Plugin::SourceRbsSynthesisReporter]
-        # @param snapshots [RunSnapshots] shared end-of-pass snapshot sink.
-        # @param plugin_registry [#call] reader for the current registry.
-        # @param dependency_source_index [#call] reader.
-        # @param synthetic_method_index [#call] reader.
-        # @param project_patched_methods [#call] reader.
-        # @param project_scope_seed [#call] reader for the cross-file pre-pass seed tables
+        # @param snapshots — shared end-of-pass snapshot sink.
+        # @param plugin_registry — reader for the current registry.
+        # @param dependency_source_index — reader.
+        # @param synthetic_method_index — reader.
+        # @param project_patched_methods — reader.
+        # @param project_scope_seed — reader for the cross-file pre-pass seed tables
         #   (`Runner#project_scope_seed_tables`).
-        # @param analyze_file [#call] `(path, environment) -> diagnostics`.
+        # @param analyze_file — `(path, environment) -> diagnostics`.
         def initialize(configuration:, cache_store:, explain:, workers:, collect_stats:, # rubocop:disable Metrics/ParameterLists
                        buffer:, environment_override:, rbs_extended_reporter:,
                        boundary_cross_reporter:, source_rbs_synthesis_reporter:,
                        snapshots:, plugin_registry:, dependency_source_index:,
                        synthetic_method_index:, project_patched_methods:,
-                       analyze_file:, project_scope_seed: -> { {} }, record_dependencies: false)
+                       analyze_file:, project_scope_seed: -> { {} }, record_dependencies: false,
+                       restored_run_level_rows: nil)
           @configuration = configuration
           @cache_store = cache_store
           @explain = explain
@@ -80,6 +72,10 @@ module Rigor
           @project_patched_methods_reader = project_patched_methods
           @project_scope_seed_reader = project_scope_seed
           @analyze_file = analyze_file
+          # Issues #796 / #794 — the previous full run's run-level rows, handed down by
+          # {Analysis::IncrementalSession} on a NARROWED run only (a recheck's closure, a
+          # `--verify-incremental` partition). A full run leaves this nil and derives everything itself.
+          @restored_run_level_rows = restored_run_level_rows
         end
 
         # ADR-46 — the per-file cross-file read records the fork pool captured this run (empty unless
@@ -115,47 +111,12 @@ module Rigor
         # sources. The env stays a LOCAL variable (not an ivar) so it goes GC-eligible when the method
         # returns — holding it as long-lived state added memory pressure that surfaced as a Bus Error
         # during the spec suite under Ruby 4.0 + rbs 4.0.2.
-        # @param project_files [Array<String>, nil] issue #784 — the WHOLE project's analyzed file set
-        #   (`expansion.fetch(:files)`), independent of any `analyze_only` narrowing of `files`. Read only
-        #   when `files` is empty, to decide whether anyone could have demanded the HKT registry at all.
+        # @param project_files — issue #784 — the WHOLE project's analyzed file set
+        #   (`expansion.fetch(:files)`), independent of any `analyze_only` narrowing of `files`; see
+        #   {#serve_empty_closure} for what an empty `files` does with it.
         def analyze_files(files, environment: nil, project_files: nil)
           if files.empty?
-            # Issue #784 — an EMPTY analyze set still owes the run its HKT-scan row: the per-file cache never
-            # holds it (`IncrementalSession` caches only `Runner#per_file_diagnostics`, so every run-level row
-            # is regenerated every run), so returning here without recording flips a red project green — and
-            # the shipping `--incremental` path reaches this branch with NO environment in hand on every
-            # warm recheck that changed nothing (`CheckCommand#run_incremental_check` builds its session
-            # without one). So: an environment already in hand is consulted; otherwise one is resolved over
-            # the project's OWN file list — not `[]`, which would drop every plugin-synthesized virtual RBS
-            # (`Environment.collect_virtual_rbs` short-circuits on an empty list) and scan a different type
-            # universe from the one a full run analyses — and only when the project HAS files: with none,
-            # nobody could have demanded a registry, and an empty project keeps paying no env build. Keyed
-            # on the project's files rather than on `analyze_only`, because a recheck over an EMPTY project
-            # narrows to `Set[]`, which is non-nil.
-            env = environment || @environment_override
-            if project_files && !project_files.empty?
-              env ||= resolve_sequential_environment(source_files: project_files)
-            end
-            # #788 rounds 6 and 9 — everything the run owes from its environment that no per-file analysis
-            # produces is taken here, the way `analyze_files_sequentially` takes it: the project-signature
-            # state (`synthesized-namespace`, `quarantined-signature`, `environment-build-failed`, the
-            # conformance results), the effect-annotation carrier the residual pass reads, and the HKT-scan
-            # outcome. Now that run-level rows are never served from the per-file cache, this branch is the
-            # only producer on a warm recheck that changed nothing — leaving any of them out turned a red
-            # project green on its second `--incremental` run (the inline-only `effect.annotations-unchecked`
-            # went 1 → 0; a quarantined `signature_paths:` file went 1 → 0; a `conforms-to` class whose
-            # definition build fails went 1 → 0). Same ORDER as the sequential path, because the order is
-            # the contract: the conformance scan inside the signature-state snapshot demands the definition
-            # of every `rigor:v1:conforms-to` class — a user-authored, invocation-independent demand that
-            # #696 counts — so the definition-build failures are read AFTER it and BEFORE the HKT demand,
-            # exactly where `analyze_files_sequentially` reads them relative to its own. What this branch
-            # cannot regenerate is the part of that set the per-file ANALYSIS demanded (#796). This also
-            # retires the #441 "`.rbs` lane only when the run analyses nothing" boundary: its cost premise
-            # (no environment on this path) stopped holding the moment the branch above resolved one.
-            snapshot_project_signature_state(env)
-            snapshot_effect_annotation_carrier(env&.rbs_loader)
-            record_definition_build_failures(env&.rbs_loader&.definition_build_failures)
-            record_hkt_scan_failure(hkt_scan_outcome(env))
+            serve_empty_closure(environment, project_files)
             return []
           end
           # Issue #784 / #793 — `files` is what this run ANALYSES; `source_files` is what its environment
@@ -166,11 +127,152 @@ module Rigor
           # whose trigger lived in an excluded file's synthesized RBS fired on the full run and vanished on
           # the subset. Every environment and worker this run builds now takes the whole project.
           source_files = project_files || files
-          return dispatch_pool(files, source_files: source_files) if pool_mode?
+          result =
+            if pool_mode?
+              dispatch_pool(files, source_files: source_files)
+            else
+              analyze_files_sequentially(
+                files, environment || resolve_sequential_environment(source_files: source_files)
+              )
+            end
+          # Issues #796 / #794 — a narrowed run's own demand set is a SUBSET of the full run's, so the two
+          # rows below are folded in after it, whichever backend produced the per-file stream.
+          replayed_restored_run_level_rows?(closure: files)
+          result
+        end
 
-          analyze_files_sequentially(
-            files, environment || resolve_sequential_environment(source_files: source_files)
+        # Issue #784 — an EMPTY analyze set still owes the run its run-level rows: the per-file cache never
+        # holds them (`IncrementalSession` caches only `Runner#per_file_diagnostics`), so returning here
+        # without recording flips a red project green — and the shipping `--incremental` path reaches this
+        # branch with NO environment in hand on every warm recheck that changed nothing
+        # (`CheckCommand#run_incremental_check` builds its session without one).
+        #
+        # #788 rounds 6 and 9 — everything the run owes from its environment that no per-file analysis
+        # produces is taken here, the way `analyze_files_sequentially` takes it: the project-signature state
+        # (`synthesized-namespace`, `quarantined-signature`, `environment-build-failed`, the conformance
+        # results), the effect-annotation carrier the residual pass reads, and the HKT-scan outcome. Leaving
+        # any of them out turned a red project green on its second `--incremental` run. Same ORDER as the
+        # sequential path, because the order is the contract: the conformance scan inside the
+        # signature-state snapshot demands the definition of every `rigor:v1:conforms-to` class — a
+        # user-authored, invocation-independent demand that #696 counts — so the definition-build failures
+        # are read AFTER it and BEFORE the HKT outcome.
+        #
+        # Issue #794 — the environment is resolved LAZILY, by the two snapshots that need one and only when
+        # their own gates say so: a project with no `signature_paths:`, no plugin-deferred signatures and no
+        # source-RBS synthesizer now reaches the end of this branch without building an environment at all,
+        # where #788 built one unconditionally to make the HKT demand. Issue #796 — what this branch cannot
+        # derive is the part of the definition-build set the per-file ANALYSIS demanded, and #696 forbids a
+        # Rigor-owned demand from standing in for it; the previous full run's set is replayed instead.
+        # @param project_files — issue #784 — the WHOLE project's analyzed file set
+        #   (`expansion.fetch(:files)`), independent of any `analyze_only` narrowing. Read here to decide
+        #   whether anyone could have demanded anything at all: with no files, nobody could have, and an
+        #   empty project keeps paying no env build. Keyed on the project's files rather than on
+        #   `analyze_only`, because a recheck over an EMPTY project narrows to `Set[]`, which is non-nil.
+        def serve_empty_closure(environment, project_files)
+          env = environment || @environment_override
+          # Resolved over the project's OWN file list — not `[]`, which would drop every plugin-synthesized
+          # virtual RBS (`Environment.collect_virtual_rbs` short-circuits on an empty list) and scan a
+          # different type universe from the one a full run analyses.
+          resolve = lambda do
+            next env if env
+            next nil if project_files.nil? || project_files.empty?
+
+            env = resolve_sequential_environment(source_files: project_files)
+          end
+          snapshot_project_signature_state(signature_state_environment(resolve))
+          snapshot_effect_annotation_carrier(
+            annotation_carrier_environment(resolve, in_hand: !env.nil?)&.rbs_loader
           )
+          # `env` rather than `resolve.call`: read the demand the snapshots above just made when they built
+          # an environment, and force nothing when they did not.
+          record_definition_build_failures(env&.rbs_loader&.definition_build_failures)
+          return if replayed_restored_run_level_rows?
+
+          record_hkt_scan_failure(hkt_scan_outcome(resolve.call))
+        end
+
+        # Issue #794 — the signature-state snapshot's own gates, asked BEFORE an environment exists. Both
+        # answers are loader-free (the configuration and the plugin registry), and with neither gate open
+        # {#snapshot_project_signature_state} writes the same empty state a nil environment gives it.
+        def signature_state_environment(resolve)
+          plugin_signature_paths? || project_signature_paths? ? resolve.call : nil
+        end
+
+        # Issue #794 — the same, for the #441 carrier. The carrier is a filter over the loader's
+        # `virtual_rbs`, and an environment whose loader can hold none of it answers the same empty carrier
+        # a nil environment does. Two ways it can hold some: a plugin registry that declares a synthesizer
+        # (`Environment.collect_virtual_rbs` short-circuits to `[]` without one — and ADR-93 auto-wires
+        # `rigor-rbs-inline`, so this is the shape almost every project is in), or an environment ALREADY in
+        # hand, whose loader is free to read and may carry virtual buffers from a route this coordinator
+        # never saw (a restored env cache, a caller-supplied override). Only the third shape — no
+        # synthesizer AND no environment yet — declines, which is the #794 saving: nothing is built to
+        # discover an emptiness the registry already proves.
+        def annotation_carrier_environment(resolve, in_hand: false)
+          return nil if @record_effects
+          return resolve.call if in_hand
+
+          registry = plugin_registry
+          return nil unless registry.respond_to?(:source_rbs_synthesizers)
+          return nil if registry.source_rbs_synthesizers.empty?
+
+          resolve.call
+        end
+
+        # Issues #796 / #794 — fold the previous full run's run-level rows into this narrowed run's
+        # snapshots. The definition-build set is UNIONed (`#record_definition_build_failures` dedupes by
+        # class), so a class this run demanded for itself and the replayed set agree; the HKT outcome is a
+        # single tuple whoever demanded it, so `||=` keeps this run's own answer when it has one. Returns
+        # true when a replay was available, which is what tells {#serve_empty_closure} it owes no HKT demand
+        # of its own — and so no environment.
+        #
+        # @param closure — the files this run analyses; see {#stale_replayed_failure?}.
+        def replayed_restored_run_level_rows?(closure: nil)
+          rows = @restored_run_level_rows
+          return false if rows.nil?
+
+          replayable = Array(rows.definition_build_failures).reject do |failure|
+            stale_replayed_failure?(failure, closure)
+          end
+          record_definition_build_failures(replayable)
+          record_hkt_scan_failure(rows.hkt_scan_failure)
+          true
+        end
+
+        # A replayed definition-build failure the snapshot's own fingerprint cannot vouch for. The
+        # fingerprint digests the three signature sources it can read WITHOUT an environment — `sig:`,
+        # `Gemfile.lock` / `rbs_collection.lock.yaml`, and the configuration — but NOT the virtual RBS a
+        # source-RBS synthesizer derives from `.rb` files (under ADR-93's auto-wired `rigor-rbs-inline`,
+        # every `#:` annotation). So a duplicate declaration can be REMOVED from a `.rb` file without moving
+        # the fingerprint, and the replayed row would outlive its own cause: the edited file enters the
+        # closure, its analysis demands nothing that would re-derive the row, and the run reports a
+        # collision between files that no longer collide.
+        #
+        # The narrowed run cannot re-derive the row either (#696 forbids Rigor demanding a definition the
+        # analysis did not), so the honest answer is to DROP it and under-report rather than assert a
+        # diagnostic on a program that may now be correct — false positives outrank worst-case reading. The
+        # cost is bounded to the row's own conflicting buffers: a collision between two files neither of
+        # which this run touches still replays.
+        def stale_replayed_failure?(failure, closure)
+          return false if closure.nil?
+
+          buffers = failure.is_a?(Array) ? failure[3] : nil
+          return false if buffers.nil?
+
+          closure_paths = closure.to_set { |path| File.expand_path(path.to_s) }
+          Array(buffers).any? do |name|
+            path = virtual_buffer_path(name)
+            !path.nil? && closure_paths.include?(File.expand_path(path))
+          end
+        end
+
+        # The source file behind a `virtual:<plugin id>:<path>` buffer name
+        # (`Environment.collect_virtual_rbs`), or nil for any other buffer — a `sig:` file, a bundled `.rbs`
+        # — which the fingerprint does cover and which therefore never goes stale under a replay.
+        def virtual_buffer_path(name)
+          parts = name.to_s.split(":", 3)
+          return nil unless parts.length == 3 && parts.first == "virtual"
+
+          parts.last
         end
 
         def analyze_files_sequentially(files, environment)
@@ -206,6 +308,13 @@ module Rigor
         # `.rigor/cache` on a bare `--no-stats` run. The loader has already memoised each answer, so reading
         # them here is free.
         def snapshot_project_signature_state(environment)
+          # Issue #610 — NOT behind the `signature_paths:` gate below: the source a bundled plugin's `sig/`
+          # stands down against is typically an `rbs collection install` the configuration never lists
+          # there. Gated instead on a loaded plugin contributing signatures at all — the registry answers
+          # that without touching the env, and it is exactly the set the loader defers — so a project with
+          # no such plugin reads nothing off its loader here, as before.
+          @snapshots.signature_standdowns =
+            plugin_signature_paths? ? signature_standdowns_for(environment&.rbs_loader) : []
           unless project_signature_paths?
             @snapshots.synthesized_namespaces = []
             @snapshots.quarantined_signatures = []
@@ -279,7 +388,7 @@ module Rigor
         # An effects run (ADR-103 WD13) is pinned for exactly the same reason — the Ractor messages carry
         # no side-table channel — and degrades the same way. The degrade is sound rather than merely safe:
         # the sequential fallback still collects, so the effect graph is complete either way.
-        # @param source_files [Array<String>] the file list every worker's / the fallback's environment is
+        # @param source_files — the file list every worker's / the fallback's environment is
         #   built over — the whole project (issue #793), defaulting to `files` for direct callers.
         def dispatch_pool(files, source_files: files)
           if @record_dependencies || @record_effects
@@ -318,11 +427,7 @@ module Rigor
             rbs_extended_reporter: @rbs_extended_reporter,
             boundary_cross_reporter: @boundary_cross_reporter,
             source_rbs_synthesis_reporter: @source_rbs_synthesis_reporter,
-            bundler_bundle_path: @configuration.bundler_bundle_path,
-            bundler_auto_detect: @configuration.bundler_auto_detect,
-            bundler_lockfile: @configuration.bundler_lockfile,
-            rbs_collection_lockfile: @configuration.rbs_collection_lockfile,
-            rbs_collection_auto_detect: @configuration.rbs_collection_auto_detect,
+            **ProjectEnvironment.dependency_discovery_options(@configuration),
             synthetic_method_index: synthetic_method_index,
             project_patched_methods: project_patched_methods,
             source_files: source_files
@@ -389,15 +494,22 @@ module Rigor
           # finds. `#prewarm_rbs_cache_for_pool` already builds and fully loads exactly this
           # coordinator-side environment (to warm the cache before any worker spawns); it now hands it
           # back so its RBS state can be read the same way the fork pool reads its pre-fork session
-          # environment. The conformance scan inside the snapshot demands the definition of every
-          # `rigor:v1:conforms-to` class — a demand no Ractor worker shares memory with — so a resulting
-          # definition-build failure is recorded explicitly right after, exactly as the empty-closure
-          # branch reads its own environment's demand (#788). No matching explicit call for the HKT-scan
-          # outcome: every worker already demands it from its OWN environment in `#drain_reporters`, and
-          # the scan has one outcome whoever demands it, so a worker's report already says what the
-          # coordinator's own demand would.
-          warm_env = prewarm_rbs_cache_for_pool
+          # environment. The effect-annotation carrier (#441 — the inline stratum of
+          # `effect.annotations-unchecked`, read by the residual pass after this environment is gone) is
+          # taken off the same environment, in the same ORDER as the fork pool and the sequential path
+          # take theirs: it had no producer here either, so an annotation living only in an rbs-inline
+          # comment lost its row under this backend alone. That read is only as good as the environment's
+          # virtual RBS, which is why the prewarm is built the way the workers build theirs (see
+          # {#prewarm_rbs_cache_for_pool}). The conformance scan inside the signature-state snapshot
+          # demands the definition of every `rigor:v1:conforms-to` class — a demand no Ractor worker
+          # shares memory with — so a resulting definition-build failure is recorded explicitly right
+          # after, exactly as the empty-closure branch reads its own environment's demand (#788). No
+          # matching explicit call for the HKT-scan outcome: every worker already demands it from its OWN
+          # environment in `#drain_reporters`, and the scan has one outcome whoever demands it, so a
+          # worker's report already says what the coordinator's own demand would.
+          warm_env = prewarm_rbs_cache_for_pool(source_files: source_files)
           snapshot_project_signature_state(warm_env)
+          snapshot_effect_annotation_carrier(warm_env&.rbs_loader)
           record_definition_build_failures(warm_env&.rbs_loader&.definition_build_failures)
 
           configuration = @configuration
@@ -633,7 +745,7 @@ module Rigor
           degraded
         end
 
-        # @return [Hash, nil] the child's `{results:, reporters:}` payload, or nil when the child exited
+        # @return the child's `{results:, reporters:}` payload, or nil when the child exited
         #   abnormally or wrote no readable payload. `Marshal.load` is safe here: the blob was written by
         #   our own forked child to a temp file we created.
         def fork_worker_payload(status, out_path)
@@ -658,19 +770,42 @@ module Rigor
         # ADR-15 Phase 4b.x — drives every cached RBS producer on the main Ractor so each worker can serve
         # all reflection queries from disk (Marshal-load only). Builds a single coordinator-side
         # {Environment} for this purpose and returns it fully loaded — issue #798: the caller also reads
-        # the project-signature state off it, since it is the only environment this backend's coordinator
-        # ever holds. Workers still build their OWN `Environment.for_project` inside the Ractor body, which
-        # then routes through `cached_env` instead of `RBS::EnvironmentLoader.new`.
-        def prewarm_rbs_cache_for_pool
+        # the project-signature state and the effect-annotation carrier off it, since it is the only
+        # environment this backend's coordinator ever holds. Workers still build their OWN
+        # `Environment.for_project` inside the Ractor body, which then routes through `cached_env` instead
+        # of `RBS::EnvironmentLoader.new`.
+        #
+        # Built with the loaded plugin registry over the project's WHOLE file list (#793's rule), exactly
+        # as each worker builds its own. `Environment.for_project` collects plugin-synthesized virtual RBS
+        # only when handed BOTH (`collect_virtual_rbs` short-circuits on a nil registry and on an empty
+        # list), and this used to pass neither: its loader's `virtual_rbs` read empty on every project, so
+        # a carrier snapshotted off it would have been `[]` whatever the rbs-inline comments said — the
+        # method called, the row still missing. Two more things follow from building the environment the
+        # workers build: the env-cache descriptor digests the same signature roots (a plugin's
+        # `signature_paths:`) and the same virtual set, so the slot this warms is the slot the workers
+        # read; and each synthesizer runs once here and is memoised through the cache store (ADR-32 WD5)
+        # instead of once per worker.
+        #
+        # Deliberately NOT {#build_runner_environment}: that hands the environment the run's own reporter
+        # accumulators, and an environment BUILD writes to one of them — `collect_virtual_rbs` records a
+        # synthesizer's parse failures and unhonoured annotations on the `source_rbs_synthesis` reporter.
+        # Every Ractor worker builds this same environment with reporters of its own and drains them back
+        # through {#merge_worker_reporters}, whose replay of that stream appends without dedup, so a
+        # coordinator-side reporter here would count each entry once more than the drains already do. The
+        # other two are written only by demands this environment never receives (the HKT scan, per-file
+        # dispatch); all three are withheld together so the no-double-count holds by construction rather
+        # than by which reads happen to be made. The dispatch-only per-run state (the dependency-source
+        # index, the synthetic-method / project-patched indexes) is withheld for the same reason: nothing
+        # here dispatches.
+        # @param source_files — the WHOLE project's file list, never the analyzed subset.
+        def prewarm_rbs_cache_for_pool(source_files:)
           warm_env = Environment.for_project(
             libraries: @configuration.libraries,
             signature_paths: @configuration.signature_paths,
             cache_store: @cache_store,
-            bundler_bundle_path: @configuration.bundler_bundle_path,
-            bundler_auto_detect: @configuration.bundler_auto_detect,
-            bundler_lockfile: @configuration.bundler_lockfile,
-            rbs_collection_lockfile: @configuration.rbs_collection_lockfile,
-            rbs_collection_auto_detect: @configuration.rbs_collection_auto_detect
+            plugin_registry: plugin_registry,
+            source_files: source_files,
+            **ProjectEnvironment.dependency_discovery_options(@configuration)
           )
           warm_env.rbs_loader&.prewarm
           warm_env
@@ -680,7 +815,7 @@ module Rigor
         # (currently: `--no-cache` would force workers through `EnvironmentLoader.new`), degrade to
         # sequential analysis with a `:warning` `pool-degraded` diagnostic at run start. The actual
         # per-file analysis runs on the coordinator, identical to the default sequential path.
-        # @param source_files [Array<String>] issue #793 — the whole project, so this path's environment
+        # @param source_files — issue #793 — the whole project, so this path's environment
         #   carries the same plugin-synthesized RBS the pool workers' would. It used to build over `[]`,
         #   i.e. with no synthesized RBS at all, even on a full run.
         def analyze_files_sequentially_fallback(files, reason:, source_files: files)
@@ -699,6 +834,7 @@ module Rigor
           record_hkt_scan_failure(hkt_scan_outcome(environment))
           @snapshots.class_decl_paths = loader&.class_decl_paths || {}.freeze
           @snapshots.signature_paths = loader&.signature_paths || [].freeze
+          @snapshots.signature_standdowns = plugin_signature_paths? ? signature_standdowns_for(loader) : []
           @snapshots.quarantined_signatures =
             project_signature_paths? ? (loader&.quarantined_signatures || []) : []
           @snapshots.env_build_failure = project_signature_paths? ? loader&.env_build_failure : nil
@@ -723,9 +859,15 @@ module Rigor
           end
           # ADR-32 WD6 — merge per-worker synthesizer failures back into the coordinator's reporter. Fetched
           # with a default empty array so older drains (pre-slice-2) remain compatible.
+          #
+          # `kind:` rides along (issue #824): without it every drained entry replayed as WD6's default
+          # `:failed`, so under `--workers N` a WD12 "parsed but not honoured" row came back as
+          # `source-rbs-synthesis-failed` — a different id, and a message telling the user the file
+          # contributed nothing when all but one of its annotations bound. Every worker reads the same
+          # sources and so hands over the same entries; the reporter's own dedup collapses them.
           Array(drained[:source_rbs_synthesis]).each do |entry|
             @source_rbs_synthesis_reporter.record(
-              plugin_id: entry.plugin_id, path: entry.path, message: entry.message
+              plugin_id: entry.plugin_id, path: entry.path, message: entry.message, kind: entry.kind
             )
           end
           # Issue #696. Fetched with a default so an older drain stays compatible, exactly as the line above.
@@ -764,6 +906,18 @@ module Rigor
               message: entry.message, path: entry.path, line: entry.line, column: entry.column
             )
           end
+          replay_deprecated_forms(rbs)
+        end
+
+        # ADR-109 WD3 — the fourth stream, read with the nil default like the hkt one so an older drain
+        # shape records nothing.
+        def replay_deprecated_forms(rbs)
+          Array(rbs[:deprecated_forms]).each do |entry|
+            @rbs_extended_reporter.record_deprecated_form(
+              payload: entry.payload, replacement: entry.replacement,
+              path: entry.path, line: entry.line, column: entry.column
+            )
+          end
         end
 
         # Issue #696 — accumulate the per-class `RBS::DefinitionBuilder` failures this run observed, deduped
@@ -822,8 +976,7 @@ module Rigor
         # build on a project with no files (see {#analyze_files}). Memoised, so on a reused Environment
         # this is a hash read.
         #
-        # @param environment [Rigor::Environment, nil]
-        # @return [Array, nil] the recorded tuple, or nil (no environment, or the scan built)
+        # @return the recorded tuple, or nil (no environment, or the scan built)
         def hkt_scan_outcome(environment)
           return nil if environment.nil?
 
@@ -838,6 +991,21 @@ module Rigor
           !(paths.nil? || paths.empty?)
         end
 
+        # Issue #610 — see {#snapshot_project_signature_state}. The registry's `signature_paths` is what
+        # `Environment.for_project` defers, so this is the loader-free form of "is anything deferred?".
+        def plugin_signature_paths?
+          registry = plugin_registry
+          registry.respond_to?(:signature_paths) && !registry.signature_paths.empty?
+        end
+
+        # Empty for a loader with nothing deferred, without touching its env.
+        def signature_standdowns_for(loader)
+          return [] if loader.nil? || !loader.respond_to?(:deferred_signature_paths)
+          return [] if loader.deferred_signature_paths.empty?
+
+          loader.signature_standdowns
+        end
+
         def plugin_registry
           @plugin_registry_reader.call
         end

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

@@ -35,11 +35,9 @@ module Rigor
           :pre_eval_diagnostics_from_scanner
         )
 
-        # @param configuration [Rigor::Configuration]
-        # @param cache_store [Rigor::Cache::Store, nil]
-        # @param buffer [BufferBinding, nil]
-        # @param plugin_requirer [#call, nil]
-        # @param pool_mode [#call] reader returning the pool-mode flag.
+        # @param plugin_requirer — how a plugin gem is brought into the process, called with the gem name; nil
+        #   lets `Plugin::Loader` apply its own default.
+        # @param pool_mode — reader returning the pool-mode flag.
         def initialize(configuration:, cache_store:, buffer:, plugin_requirer:, pool_mode:)
           @configuration = configuration
           @cache_store = cache_store
@@ -56,7 +54,7 @@ module Rigor
           :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_extends, :discovered_class_sources, :constant_values, :constant_sources, :constant_writes,
           :discovered_method_visibilities, :discovered_methods, :data_member_layouts,
           :struct_member_layouts
         )
@@ -77,6 +75,11 @@ module Rigor
             bundle_path: @configuration.bundler_bundle_path,
             auto_detect: @configuration.bundler_auto_detect
           )&.to_s
+          # ADR-39 slice 5 / #911 — hand the project's `plugins_isolation:` to the invocation layer before
+          # any plugin `#prepare` runs, for the same reason the bundle root is resolved above: `#prepare`
+          # already calls through {Plugin::Isolation}, so a later assignment would leave prepare-time
+          # calls on a different strategy than the rest of the run.
+          Plugin::Isolation.configured_strategy = @configuration.plugins_isolation
           plugin_registry = load_plugins
           dependency_source_index = DependencySourceInference::Builder.build(@configuration.dependencies)
           # ADR-18 slice 3 — plugin prepare MUST run before the synthetic-method scanner so cross-plugin
@@ -161,6 +164,9 @@ module Rigor
             # 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),
+            # Issue #898 — the singleton-side mixin table, kept beside the instance-side one so a class
+            # object's `extend`s reach `Narrowing` from a sibling file the way its `include`s already do.
+            discovered_extends: def_index.fetch(:extends),
             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),

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

@@ -16,7 +16,7 @@ module Rigor
       # back-reference cycle.
       class RunSnapshots
         attr_accessor :class_decl_paths, :signature_paths,
-                      :synthesized_namespaces, :quarantined_signatures, :conformance_results,
+                      :synthesized_namespaces, :quarantined_signatures, :signature_standdowns, :conformance_results,
                       :env_build_failure, :definition_build_failures, :hkt_scan_failure,
                       :effect_annotation_carrier
 
@@ -29,11 +29,15 @@ module Rigor
         # {PoolCoordinator#merge_worker_reporters}. `hkt_scan_failure` (#784) is nil-or-tuple like
         # `env_build_failure`, not a list like `definition_build_failures`: the scan is ONE build over the
         # whole `signature_paths:` overlay, not a per-class one, so it has exactly one outcome per run.
+        # `signature_standdowns` (#610) is the quarantine slot's twin for the plugin-contributed files that
+        # stood down against a colliding generic arity: a list, assigned once from the loader as
+        # `quarantined_signatures` is, and derived from the final env so a cache HIT carries it too.
         def initialize
           @class_decl_paths = {}.freeze
           @signature_paths = [].freeze
           @synthesized_namespaces = [].freeze
           @quarantined_signatures = [].freeze
+          @signature_standdowns = [].freeze
           @conformance_results = [].freeze
           @env_build_failure = nil
           @definition_build_failures = [].freeze
@@ -48,6 +52,7 @@ module Rigor
           @signature_paths = []
           @synthesized_namespaces = []
           @quarantined_signatures = []
+          @signature_standdowns = []
           @conformance_results = []
           @env_build_failure = nil
           @definition_build_failures = []