rigortype 0.3.7 → 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,11 +111,168 @@ 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.
-        def analyze_files(files, environment: nil)
-          return [] if files.empty?
-          return dispatch_pool(files) if pool_mode?
+        # @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?
+            serve_empty_closure(environment, project_files)
+            return []
+          end
+          # Issue #784 / #793 — `files` is what this run ANALYSES; `source_files` is what its environment
+          # is BUILT over, and the two are the same only on a full run. A narrowed run (`analyze_only`: an
+          # incremental closure, a `--verify-incremental` partition) used to build its environment over the
+          # subset, so plugin-synthesized virtual RBS from every excluded file was missing and the run
+          # scanned a different type universe than the full run it is compared against — a scan failure
+          # 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
+          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
+
+        # 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"
 
-          analyze_files_sequentially(files, environment || resolve_sequential_environment(source_files: files))
+          parts.last
         end
 
         def analyze_files_sequentially(files, environment)
@@ -130,6 +283,13 @@ module Rigor
           # 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)
+          # Issue #784 — same timing contract, same reason: the HKT scan is first demanded from inside a
+          # file's analysis (the dispatcher's Singleton-receiver tier), so a snapshot taken any earlier
+          # would read nil on every run. And demanded HERE once more by the run itself, because a subset
+          # run (`--verify-incremental`'s partition, an incremental recheck's closure) may contain no file
+          # that demands it — the row must not depend on which files were analysed. See {#hkt_scan_outcome}
+          # for why a Rigor-owned demand is sound here where #696 forbids it.
+          record_hkt_scan_failure(hkt_scan_outcome(environment))
           if @collect_stats
             loader = environment.rbs_loader
             @snapshots.class_decl_paths = loader&.class_decl_paths || {}.freeze
@@ -148,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 = []
@@ -156,7 +323,8 @@ module Rigor
             return
           end
 
-          loader = environment.rbs_loader
+          # nil-safe: the empty-closure path reaches here with no environment when the project has no files.
+          loader = environment&.rbs_loader
           @snapshots.synthesized_namespaces = loader&.synthesized_namespaces || []
           @snapshots.quarantined_signatures = loader&.quarantined_signatures || []
           @snapshots.env_build_failure = loader&.env_build_failure
@@ -220,20 +388,24 @@ 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.
-        def dispatch_pool(files)
+        # @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
-            return analyze_files_in_fork_pool(files) if Process.respond_to?(:fork)
+            return analyze_files_in_fork_pool(files, source_files: source_files) if Process.respond_to?(:fork)
 
             return analyze_files_sequentially_fallback(
-              files, reason: "incremental parallelism requires fork; recording sequentially"
+              files, reason: "incremental parallelism requires fork; recording sequentially",
+                     source_files: source_files
             )
           end
           case pool_backend
-          when :ractor then analyze_files_in_pool(files)
-          when :fork   then analyze_files_in_fork_pool(files)
+          when :ractor then analyze_files_in_pool(files, source_files: source_files)
+          when :fork   then analyze_files_in_fork_pool(files, source_files: source_files)
           else
             analyze_files_sequentially_fallback(
-              files, reason: "fork-based parallelism is unavailable on this platform"
+              files, reason: "fork-based parallelism is unavailable on this platform",
+                     source_files: source_files
             )
           end
         end
@@ -255,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
@@ -299,7 +467,7 @@ module Rigor
         # worker touches comes back as an internal analyzer error. What the code below fixes is the
         # failure MODE, not the backend: the run used to hang forever instead of saying anything. Reviving
         # the backend needs an upstream change, which is why `pool_backend` keeps `fork` as the default.
-        def analyze_files_in_pool(files) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def analyze_files_in_pool(files, source_files: files) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
           # Pre-warm class-level lazy memos on the MAIN Ractor. `Environment::ClassRegistry.default` is the
           # default kwarg threaded through `Environment.new` inside each worker session; lazy-initialising
           # it from a non-main Ractor would trip `Ractor::IsolationError`. Touching it here forces the
@@ -314,10 +482,35 @@ module Rigor
           # constants.
           if @cache_store.nil?
             return analyze_files_sequentially_fallback(
-              files, reason: "pool mode requires a cache_store (--no-cache disables pool)"
+              files, reason: "pool mode requires a cache_store (--no-cache disables pool)",
+                     source_files: source_files
             )
           end
-          prewarm_rbs_cache_for_pool
+          # Issue #798 — the SAME gap the fork pool had: this coordinator never analyses a file itself, so
+          # without an explicit read the project-signature state (`synthesized-namespace`,
+          # `quarantined-signature`, `environment-build-failed`, the conformance results) has no producer.
+          # Unlike the fork pool's copy-on-write children, a Ractor worker builds its OWN Environment
+          # inside its own isolated Ractor, so nothing here inherits what the coordinator's environment
+          # 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 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
           cache_root = @cache_store&.root
@@ -325,8 +518,9 @@ module Rigor
           explain = @explain
           # ADR-32 WD4 — the full project file list travels into every Ractor worker so each worker's
           # WorkerSession can invoke loaded plugins' source_rbs_synthesizers at env-build time. The list is
-          # a frozen Array<String>; cheaply shareable.
-          shareable_source_files = files.map { |path| path.to_s.dup.freeze }.freeze
+          # a frozen Array<String>; cheaply shareable. Issue #793 — it IS the full project now
+          # (`source_files`), not the analyzed subset this comment always described.
+          shareable_source_files = source_files.map { |path| path.to_s.dup.freeze }.freeze
 
           pool = Array.new(@workers) do
             Ractor.new(configuration, cache_root, blueprints, explain, shareable_source_files) do |configuration, cache_root, blueprints, explain, shareable_source_files| # rubocop:disable Layout/LineLength
@@ -397,15 +591,28 @@ module Rigor
           # The files no worker reported — every file of a worker that died, and any file in flight when
           # it did. Re-analysed in process, exactly as the fork backend re-analyses a dead child's slice.
           degraded = files.reject { |path| results_by_path.key?(path) }
-          unless degraded.empty?
-            environment = build_runner_environment(source_files: files)
-            degraded.each { |path| results_by_path[path] = @analyze_file.call(path, environment) }
-          end
+          reanalyze_degraded_in_process(degraded, results_by_path, source_files: source_files)
 
           diagnostics = Array(prepare_diagnostics) + files.flat_map { |path| results_by_path.fetch(path, []) }
           degraded.empty? ? diagnostics : diagnostics.unshift(pool_degraded_diagnostic(degraded.size, "ractor"))
         end
 
+        # The Ractor backend's degrade: the files of a worker that died are re-analysed on a LOCAL
+        # environment built over the whole project. That worker never sent `:done`, so nothing drains its
+        # reporters — and the local environment has no session to drain either — so the run-level state
+        # this analysis produced is taken here, exactly as the sequential fallback takes it: the
+        # definition-build failures the re-analysis demanded (#696) and the HKT-scan outcome, demanded
+        # once more by the run itself (#784 — a rescued scan failure otherwise vanished with the worker).
+        # The fork backend needs none of this: it re-analyses on the parent {WorkerSession} and drains it.
+        def reanalyze_degraded_in_process(degraded, results_by_path, source_files:)
+          return if degraded.empty?
+
+          environment = build_runner_environment(source_files: source_files)
+          degraded.each { |path| results_by_path[path] = @analyze_file.call(path, environment) }
+          record_definition_build_failures(environment.rbs_loader&.definition_build_failures)
+          record_hkt_scan_failure(hkt_scan_outcome(environment))
+        end
+
         # ADR-15 Amendment (2026-05-20) — fork-based worker pool, the active backend for `workers > 0`.
         # Builds ONE {WorkerSession} on the parent, then `fork`s N children that copy-on-write inherit it.
         # Each child analyses a contiguous slice of `files` and writes a Marshal'd `{results:, reporters:}`
@@ -418,7 +625,11 @@ module Rigor
         #
         # A child that exits non-zero (crash / unmarshalable payload) is degraded: the parent re-analyses
         # that slice in-process and prepends a `pool-degraded` warning.
-        def analyze_files_in_fork_pool(files) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        #
+        # Also snapshots the project-signature state and the effect-annotation carrier off the pre-fork
+        # `session.environment` before any child spawns (#798) — the only environment this backend's
+        # coordinator ever holds, and so the only place those diagnostic rows can be read from.
+        def analyze_files_in_fork_pool(files, source_files: files) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
           Environment::ClassRegistry.default
 
           session = WorkerSession.new(
@@ -429,12 +640,27 @@ module Rigor
             synthetic_method_index: synthetic_method_index,
             project_patched_methods: project_patched_methods,
             project_scope_seed: project_scope_seed,
-            source_files: files,
+            source_files: source_files,
             record_dependencies: @record_dependencies
           )
           # Force the full RBS load on the parent so children copy-on-write inherit a warm Environment
           # rather than each rebuilding it after the fork.
           session.environment.rbs_loader&.prewarm
+          # Issue #798 — same set, same ORDER as the sequential path (docs/type-specification/
+          # diagnostic-policy.md § `rbs.coverage.*`): the project-signature state
+          # (`synthesized-namespace`, `quarantined-signature`, `environment-build-failed`, the
+          # conformance results) has no per-file producer, so this coordinator-side environment is the
+          # only place a pooled run can take it from — exactly as the empty-closure branch above is the
+          # only place an empty run can (#788). Taken BEFORE the fork below: the conformance scan this
+          # runs demands the definition of every `rigor:v1:conforms-to` class, and doing that HERE means
+          # a resulting definition-build failure is already sitting in the parent's loader at the moment
+          # each child copy-on-write-inherits it — every child's own `#drain_reporters` then reports it
+          # right alongside whatever its own slice demanded, with no separate plumbing needed. Left
+          # unconditional, unlike `#snapshot_fork_pool_stats` below: these are diagnostic rows, not
+          # `RunStats` telemetry, and the stats gate must not decide which diagnostics a run reports (a
+          # `--workers N --no-stats` run used to say strictly LESS than the sequential path over the
+          # same project).
+          snapshot_project_signature_state(session.environment)
           snapshot_effect_annotation_carrier(session.environment.rbs_loader)
           snapshot_fork_pool_stats(session) if @collect_stats
 
@@ -488,18 +714,16 @@ module Rigor
           exit!(1)
         end
 
-        # Snapshots `class_decl_paths` from the parent session's loader so end-of-run {RunStats} can
-        # attribute the RBS class universe.
+        # Issue #798 — `RunStats` telemetry ONLY, now that `#snapshot_project_signature_state` (called
+        # unconditionally above) owns every diagnostic-bearing slot this method used to ALSO write
+        # (`quarantined_signatures`, `env_build_failure`): those must not be gated on `@collect_stats`, and
+        # this method's own name says what is left — `class_decl_paths` / `signature_paths`, read off the
+        # parent session's loader so end-of-run {RunStats} can attribute the RBS class universe, which a
+        # `--no-stats` run legitimately skips.
         def snapshot_fork_pool_stats(session)
           loader = session.environment.rbs_loader
           @snapshots.class_decl_paths = loader&.class_decl_paths || {}.freeze
           @snapshots.signature_paths = loader&.signature_paths || [].freeze
-          # The workers each quarantine the same broken file, but they report no diagnostics for it — the row is
-          # a whole-run one. Read it off the parent session's loader so a pooled run says exactly what a
-          # sequential one says. The same reasoning holds for a total env-build failure.
-          @snapshots.quarantined_signatures =
-            project_signature_paths? ? (loader&.quarantined_signatures || []) : []
-          @snapshots.env_build_failure = project_signature_paths? ? loader&.env_build_failure : nil
         end
 
         # Waits for every forked child, merges each successful payload into `results_by_path`, and returns
@@ -521,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)
@@ -545,29 +769,57 @@ 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; the env object is discarded immediately after the cache is warm
-        # — workers 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
+        # {Environment} for this purpose and returns it fully loaded — issue #798: the caller also reads
+        # 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
         end
 
         # ADR-15 Phase 4b.x — pool-mode safety net. When pool mode is configured but a precondition fails
         # (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.
-        def analyze_files_sequentially_fallback(files, reason:)
-          environment = build_runner_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)
+          environment = build_runner_environment(source_files: source_files)
           snapshot_effect_annotation_carrier(environment.rbs_loader)
           diagnostics = files.flat_map { |path| @analyze_file.call(path, environment) }
           loader = environment.rbs_loader
@@ -576,8 +828,13 @@ module Rigor
           # `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)
+          # Issue #784 — same reasoning: this path's Environment IS the one that reached the scan, so it
+          # must snapshot the slot too, or a run that degraded to sequential would report less than a
+          # sequential run would. Demanded once by the run as well, for the reason at the sequential site.
+          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
@@ -591,17 +848,7 @@ module Rigor
         end
 
         def merge_worker_reporters(drained)
-          rbs = drained.fetch(:rbs_extended)
-          rbs.fetch(:unresolved_payloads).each do |entry|
-            @rbs_extended_reporter.record_unresolved(
-              payload: entry.payload, source_location: entry.source_location
-            )
-          end
-          rbs.fetch(:lossy_projections).each do |entry|
-            @rbs_extended_reporter.record_lossy_projection(
-              head: entry.head, source_location: entry.source_location
-            )
-          end
+          merge_rbs_extended_reporter(drained.fetch(:rbs_extended))
           drained.fetch(:boundary_cross).each do |entry|
             @boundary_cross_reporter.record(
               class_name: entry.class_name,
@@ -612,17 +859,67 @@ 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.
           record_definition_build_failures(drained[:definition_build_failures])
+          # Issue #784. `Hash#[]` is already a nil default, exactly as `env_build_failure` is snapshotted
+          # elsewhere — an older drain shape simply has no key and records nothing.
+          record_hkt_scan_failure(drained[:hkt_scan_failure])
         end
 
         private
 
+        # Replays one worker's three {RbsExtended::Reporter} streams into the run's own reporter.
+        #
+        # `hkt_directive_errors` (issue #785) is read with `Hash#[]`'s nil default rather than `fetch`,
+        # exactly as `source_rbs_synthesis` is, so an older drain shape simply records nothing.
+        #
+        # All three streams replay by their `(path, line, column)` primitives (#785 for the hkt stream, #805
+        # for its two elders). Every worker reads the same `.rbs`, so each hands over the same entries, and
+        # only a primitive-keyed dedup collapses them back to the single row a `--workers=0` run prints — an
+        # `RBS::Location` compares equal only against a location over the same `RBS::Buffer` object, so a
+        # location-keyed one would print N copies at `--workers=N`. The entries could not reach here carrying
+        # a location anyway: the drain Marshals its payload and an `RBS::Location` has no `_dump`.
+        def merge_rbs_extended_reporter(rbs)
+          rbs.fetch(:unresolved_payloads).each do |entry|
+            @rbs_extended_reporter.record_unresolved(
+              payload: entry.payload, path: entry.path, line: entry.line, column: entry.column
+            )
+          end
+          rbs.fetch(:lossy_projections).each do |entry|
+            @rbs_extended_reporter.record_lossy_projection(
+              head: entry.head, path: entry.path, line: entry.line, column: entry.column
+            )
+          end
+          Array(rbs[:hkt_directive_errors]).each do |entry|
+            @rbs_extended_reporter.record_hkt_error(
+              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
         # by class name and kept in first-seen order.
         #
@@ -646,6 +943,47 @@ module Rigor
             (@snapshots.definition_build_failures + failures).uniq(&:first).freeze
         end
 
+        # Issue #784 — first-wins, unlike {#record_definition_build_failures}'s accumulate-and-dedup. That
+        # method accumulates because each pool WORKER owns its own loader and its own per-class memo, so a
+        # collapsed class can genuinely be observed by only some workers and the run's set is the union.
+        # The HKT scan has no such per-worker variation: `Environment#hkt_registry` builds from the SAME
+        # `signature_paths:` overlay every worker was handed, so every worker that demands it either all
+        # raise identically or all succeed — there is only ever one tuple to record, and `||=` is correct
+        # (and cheap) rather than an accumulate-and-dedup this slot never needs.
+        def record_hkt_scan_failure(tuple)
+          @snapshots.hkt_scan_failure ||= tuple
+        end
+
+        # Issue #784 — demand the registry once on behalf of the run, then read the slot. The seam in
+        # {Environment#hkt_registry} is demand-driven, and nothing guarantees any analysed file demands it:
+        # a `--verify-incremental` partition or an incremental closure can miss every `Klass.method` call,
+        # and then the slot is nil after the loop and the run says nothing — while `--incremental` has also
+        # dropped the row from its per-file cache. Demanding here makes the outcome a property of the RUN,
+        # not of which files happened to be in it.
+        #
+        # This is sound where #696's "a demand that is Rigor's own MUST NOT contribute" is not, and the
+        # difference is the shape of what is recorded. #696 reports a per-class LIST whose membership is
+        # "the classes the analysis demanded"; a Rigor-internal demand adds classes the user never asked
+        # about and makes that list vary with configuration. The HKT scan is ONE build with ONE outcome —
+        # the same tuple whoever demands it — so an extra demand cannot change what is reported, only
+        # guarantee it is observed.
+        #
+        # What it costs, stated plainly because {#record_definition_build_failures}'s comment promises
+        # "nothing is forced here": the demand DOES force the RBS env build when the environment has not
+        # built it yet (the scan reads the loader). On every path that reaches this method that build is
+        # either already done (the loop demanded it) or the same load one analysed file would have paid:
+        # a Marshal load when a cache store exists, the parse a full run pays under `--no-cache`. Never a
+        # build on a project with no files (see {#analyze_files}). Memoised, so on a reused Environment
+        # this is a hash read.
+        #
+        # @return the recorded tuple, or nil (no environment, or the scan built)
+        def hkt_scan_outcome(environment)
+          return nil if environment.nil?
+
+          environment.hkt_registry
+          environment.hkt_scan_failure
+        end
+
         # True when the project declares its own `signature_paths:` (the only place the
         # qualified-name-without-namespace mistake lives).
         def project_signature_paths?
@@ -653,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