rigortype 0.3.7 → 0.3.9

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,8 +16,9 @@ module Rigor
       # back-reference cycle.
       class RunSnapshots
         attr_accessor :class_decl_paths, :signature_paths,
-                      :synthesized_namespaces, :quarantined_signatures, :conformance_results,
-                      :env_build_failure, :definition_build_failures, :effect_annotation_carrier
+                      :synthesized_namespaces, :quarantined_signatures, :signature_standdowns, :conformance_results,
+                      :env_build_failure, :definition_build_failures, :hkt_scan_failure,
+                      :effect_annotation_carrier
 
         # Constructor defaults match the {Runner} constructor: the pre-seed values `build_run_stats` /
         # `pre_file_diagnostics` read before the first analysis path runs are frozen empties. The
@@ -25,15 +26,22 @@ module Rigor
         # `[error_class, first_line, buffer_names]` tuple or nothing. Its per-class sibling
         # `definition_build_failures` (#696) holds a LIST, because a collapsed universe fails many classes,
         # and is accumulated ACROSS pool workers rather than assigned once — see
-        # {PoolCoordinator#merge_worker_reporters}.
+        # {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
+          @hkt_scan_failure = nil
           @effect_annotation_carrier = [].freeze
         end
 
@@ -44,9 +52,11 @@ module Rigor
           @signature_paths = []
           @synthesized_namespaces = []
           @quarantined_signatures = []
+          @signature_standdowns = []
           @conformance_results = []
           @env_build_failure = nil
           @definition_build_failures = []
+          @hkt_scan_failure = nil
           @effect_annotation_carrier = [].freeze
         end
       end

data/lib/rigor/analysis/runner.rb

@@ -9,6 +9,7 @@ require_relative "../scope"
 require_relative "../cache/store"
 require_relative "../cache/rbs_descriptor"
 require_relative "../cache/file_digest"
+require_relative "../cache/incremental_snapshot"
 require_relative "run_cache_key"
 require_relative "path_expansion"
 require_relative "../plugin"
@@ -29,6 +30,7 @@ require_relative "../inference/scope_indexer"
 require_relative "../inference/synthetic_method_scanner"
 require_relative "../inference/project_patched_scanner"
 require_relative "../inference/method_dispatcher/file_folding"
+require_relative "crash_signature"
 require_relative "buffer_binding"
 require_relative "check_rules"
 require_relative "dependency_recorder"
@@ -64,7 +66,26 @@ module Rigor
 
       attr_reader :cache_store, :plugin_registry, :dependency_source_index,
                   :rbs_extended_reporter, :boundary_cross_reporter,
-                  :analyzed_files, :unresolved_self_calls, :seed_bundles
+                  :analyzed_files, :unresolved_self_calls, :seed_bundles,
+                  # #788 rounds 6–7 — the rows per-file analysis produced this run, severity-resolved exactly
+                  # as the run's stream is and sliced to this run's targets (a pool backend folds `.rigor.yml`
+                  # prepare / degraded rows into `analyze_files`'s return). `IncrementalSession` caches ONLY
+                  # this and serves reused files from it without re-stamping: a run-level row is regenerated
+                  # every run wherever it is positioned, and slicing the run's full stream by path cached the
+                  # file-positioned ones (`effect.annotations-unchecked`, `source-rbs-*`).
+                  :per_file_diagnostics
+
+      # Issues #796 / #794 — the two run-level rows a NARROWED run cannot re-derive from the files it
+      # analyses: the `definition-build-failed` set (whose producer is the analysis's own demand, and #696
+      # forbids Rigor demanding in its place) and the HKT-scan outcome (whose producer is an environment a
+      # nothing-changed recheck otherwise has no reason to build). {IncrementalSession} persists what a full
+      # run answers here and hands it back to the next narrowed run.
+      def run_level_rows
+        Cache::IncrementalSnapshot::RunLevelRows.new(
+          definition_build_failures: @snapshots.definition_build_failures,
+          hkt_scan_failure: @snapshots.hkt_scan_failure
+        )
+      end
 
       # ADR-46 — the per-file cross-file read records this run captured (empty unless
       # `record_dependencies: true`). Sequential analysis records into `@file_dependencies` via
@@ -206,41 +227,40 @@ module Rigor
         end
       end
 
-      # @param configuration [Rigor::Configuration]
-      # @param explain [Boolean] surface fail-soft fallback events as `:info` diagnostics.
-      # @param cache_store [Rigor::Cache::Store, nil] the persistent cache the runner exposes to producers
+      # @param explain — surface fail-soft fallback events as `:info` diagnostics.
+      # @param cache_store — the persistent cache the runner exposes to producers
       #   (`RbsConstantTable` and successors). Pass `nil` to disable caching for this run; the CLI's
       #   `--no-cache` flag wires `nil` through. v0.0.9 group A slice 1 introduces the surface; later
       #   slices route real producers through it.
-      # @param workers [Integer] ADR-15 Phase 4b — when greater than zero, per-file analysis dispatches
+      # @param workers — ADR-15 Phase 4b — when greater than zero, per-file analysis dispatches
       #   across a pool of N workers. Default `0` keeps the sequential code path bit-for-bit unchanged.
       #   Controlled via the `RIGOR_RACTOR_WORKERS` env var or `.rigor.yml` `parallel.workers:` (Phase 4c,
       #   fully wired).
-      # @param collect_stats [Boolean] when true (default), `#run` builds a {RunStats} summary exposed via
+      # @param collect_stats — when true (default), `#run` builds a {RunStats} summary exposed via
       #   `result.stats` — this forces the RBS env build at end-of-run so the `class_decl_paths` snapshot
       #   has real source attribution. Set to false to skip the stats summary entirely; the CLI's
       #   `--no-stats` threads `false` through to keep trivial-fixture runs from warming `.rigor/cache`.
-      # @param prebuilt [Rigor::Analysis::ProjectScan, nil] when supplied, the runner adopts the pre-built
+      # @param prebuilt — when supplied, the runner adopts the pre-built
       #   plugin registry / dependency-source index / scanner outputs from the snapshot and skips the
       #   per-call pre-passes that produce them. Used by long-lived integrations
       #   (`Rigor::LanguageServer::ProjectContext`) to keep per-buffer requests fast — scanners walk the
       #   project once per generation rather than once per request, and plugin `#prepare` runs once per
       #   generation rather than once per request. Watched-file invalidation is the owner's responsibility;
       #   the runner trusts the snapshot it was given.
-      # @param environment [Rigor::Environment, nil] opt-in Environment override. When supplied, sequential
+      # @param environment — opt-in Environment override. When supplied, sequential
       #   mode uses the provided env instance in `#analyze_files` instead of building a fresh one via
       #   `Environment.for_project`, and attaches the runner's per-run reporter pair onto the env's mutable
       #   `Reporters` slot via `Environment#attach_reporters!`. Long-lived consumers (LSP `ProjectContext`)
       #   pass a shared env so per-publish work doesn't repeat the `Environment.for_project` build (bundler
       #   / lockfile / collection discovery, RbsLoader construction). Pool mode ignores the override — each
       #   worker continues to build its own Environment.
-      # @param discovery_seed [Hash, nil] issue #260 — opt-in cross-file discovery tables, keyed by
+      # @param discovery_seed — issue #260 — opt-in cross-file discovery tables, keyed by
       #   {Scope::DiscoveryIndex} slot name, seeded onto every per-file scope through
       #   `project_scope_seed_tables`. The ONE deliberate exception to "a `prebuilt:` runner carries no
       #   discovery tables": {Protection::DiagnosticOracle} threads the table set Tier 2's site filter already
       #   judges anchors against, so a site admitted because a sibling-file class resolved is also a site the
       #   oracle can kill at. nil (the default) leaves the prebuilt/LSP contract byte-identical.
-      # @param no_tolerated_effects [Boolean] ADR-103 WD1 / #385 — `rigor check --no-tolerated-effects`.
+      # @param no_tolerated_effects — ADR-103 WD1 / #385 — `rigor check --no-tolerated-effects`.
       #   Judges effect envelopes as if `effects.tolerated:` were empty. A judgment-time switch only: the
       #   run, its collection and its cache identity are unchanged.
       def initialize(configuration:, explain: false, # rubocop:disable Metrics/ParameterLists,Metrics/AbcSize,Metrics/MethodLength
@@ -249,8 +269,12 @@ module Rigor
                      buffer: nil, prebuilt: nil, environment: nil,
                      record_dependencies: false, record_self_calls: false, analyze_only: nil,
                      seed_bundles: nil, collect_seed_bundles: false, param_inferred_types: nil,
-                     discovery_seed: nil, no_tolerated_effects: false)
+                     discovery_seed: nil, no_tolerated_effects: false,
+                     restored_run_level_rows: nil)
         @configuration = configuration
+        # Issues #796 / #794 — the previous full run's run-level rows, supplied only by
+        # {IncrementalSession} on a narrowed run; see {PoolCoordinator#replay_restored_run_level_rows}.
+        @restored_run_level_rows = restored_run_level_rows
         @explain = explain
         @cache_store = enforce_read_only_cache(cache_store, buffer)
         @plugin_requirer = plugin_requirer
@@ -302,6 +326,7 @@ module Rigor
         # See `self_undefined_rule_active?`.
         @self_undefined_rule_active = nil
         @analyzed_files = [].freeze
+        @per_file_diagnostics = [].freeze
         # In-memory source map for `#run_source` — `{ logical_path => source String }`. When set,
         # `parse_source` reads bytes from here instead of disk and `expand_paths` accepts the (possibly
         # non-existent) logical path. nil on a normal disk-backed run.
@@ -353,6 +378,8 @@ module Rigor
         # Issue #682 — the `Module.nesting` each class / module declaration HEADER is written in.
         @project_discovered_header_nestings = {}.freeze
         @project_discovered_includes = {}.freeze
+        # Issue #898 — the singleton-side twin of the include table (`extend M` / `extend self`).
+        @project_discovered_extends = {}.freeze
         @project_discovered_class_sources = {}.freeze
         # Issue #644 — the cross-file VALUE-constant publication table (`{qualified name => Type::Constant}`,
         # literal writes only) and its per-name write attribution. The first seeds `in_source_constants` on
@@ -379,6 +406,9 @@ module Rigor
         # (sequential + fork-worker) through `project_scope_seed_tables`. Empty unless the project lists
         # `pre_eval:` files that declare publishable constants, so a project without one is byte-identical.
         @project_pre_eval_constants = {}.freeze
+        # Issue #663 — the listed set {#publishable_pre_eval_constants} asks "is this writer one of ours?"
+        # against; a function of the configuration alone, so it outlives every discovery rebuild.
+        @pre_eval_path_set = nil
         # ADR-84 WD2 — per-run identity token for the user-method return memo's bucket (see
         # Scope::DiscoveryIndex#run_generation). Minted fresh in `run_analysis` so the memo never serves an
         # entry across a run boundary (LSP re-check, ADR-62 warm loop); nil until the first run so
@@ -426,6 +456,9 @@ module Rigor
         # Per-run reset of the environment the cacheable path resolves, reused by the envelope pass so a
         # run never builds two.
         @run_environment = nil
+        # #788 — the per-file reader is assigned only on the analysis (miss) path; reset it here so a run the
+        # ADR-45 result cache serves does not answer with the previous run's rows.
+        @per_file_diagnostics = [].freeze
         # ADR-84 WD2 — roll the return-memo bucket: a fresh frozen token per run makes every per-file scope
         # of THIS run share one memo bucket while entries from any earlier run in this process (stale after
         # an edit) become unreachable.
@@ -467,9 +500,8 @@ module Rigor
       # so the result matches a one-file disk run; only the cross-file project pre-pass is empty (there is
       # one file, and the per-file indexer self-discovers its own classes / defs).
       #
-      # @param source [String] Ruby source to analyze.
-      # @param path [String] logical path for diagnostic locations.
-      # @return [Result]
+      # @param source — Ruby source to analyze.
+      # @param path — logical path for diagnostic locations.
       def run_source(source:, path: "(source).rb")
         @in_memory_sources = { path => source }
         run([path])
@@ -595,7 +627,7 @@ module Rigor
       # arg-flooring surface). Only meaningful right after a run populated the memo (baseline / recheck),
       # before the bucket rolls. Keys are held live here; the session Marshals them for the snapshot.
       #
-      # @return [Hash] `{ [path, "Class#method" | "Class.method"] => { keys:, returns:, effects: } }`.
+      # @return `{ [path, "Class#method" | "Class.method"] => { keys:, returns:, effects: } }`.
       def return_summaries
         memo = Inference::ExpressionTyper.harvest_return_memo
         return {} if memo.empty?
@@ -653,9 +685,9 @@ module Rigor
       # store) exactly as a real run's setup does, then re-drives each spec's def through the ADR-84 return
       # memo. Off any hot path — invoked only when declaration-stable changed pairs carry a persisted summary.
       #
-      # @param paths [Array<String>, nil] analysis roots (nil → the configuration's `paths:`).
-      # @param specs [Array<Hash>] each `{ class_name:, method_name:, singleton:, keys: [[receiver, args], …] }`.
-      # @return [Hash] `{ [class_name, method_name, singleton] => [return_descriptor_or_nil, …] }`.
+      # @param paths — analysis roots (nil → the configuration's `paths:`).
+      # @param specs — each `{ class_name:, method_name:, singleton:, keys: [[receiver, args], …] }`.
+      # @return `{ [class_name, method_name, singleton] => [return_descriptor_or_nil, …] }`.
       def evaluate_return_types(paths, specs)
         return {} if specs.empty?
 
@@ -674,7 +706,14 @@ module Rigor
         @run_generation = Object.new.freeze
         run_project_pre_passes(expansion: expansion)
         ensure_project_discovery(expansion)
-        environment = @pool_coordinator.resolve_sequential_environment(source_files: target_files(expansion))
+        # Issue #795 — `source_files:` is the WHOLE project's file list, never `target_files(expansion)`.
+        # `IncrementalSession#build_runner` threads its own `@buffer` into this Runner, so in editor-buffer
+        # mode `target_files` narrows to the buffer's single logical path; an environment built over just
+        # that path drops every OTHER file's plugin-synthesized virtual RBS, which can flip a re-evaluated
+        # return descriptor and wrongly declare a caller's return type unstable (or stable) relative to the
+        # full-project answer. This probe never analyzes a file, so it carries none of #788's per-file-cache
+        # duplication concern either.
+        environment = @pool_coordinator.resolve_sequential_environment(source_files: expansion.fetch(:files))
         specs.to_h do |spec|
           [[spec[:class_name], spec[:method_name], spec[:singleton]], evaluate_spec_returns(spec, environment)]
         end
@@ -776,7 +815,7 @@ module Rigor
       # fixpoint over them, which is the pre-split behaviour and the retry the fail-soft posture wants.
       # Only when neither entry answers does the run re-analyse.
       #
-      # @return [Boolean] whether this run was served.
+      # @return whether this run was served.
       def served_from_effect_entries?(descriptor)
         summary = peek_effect_summary(descriptor)
         if summary
@@ -927,9 +966,19 @@ module Rigor
         ).diagnostics
       end
 
+      # Issue #795 — `source_files:` is the WHOLE project's file list (`expansion.fetch(:files)`), never
+      # `target_files(expansion)`. A subset or editor-buffer run's `target_files` narrows to the
+      # `analyze_only` closure or the buffer's single logical path; building the envelope walk's
+      # environment over that subset drops every plugin-synthesized virtual RBS from an excluded file, so
+      # an envelope declared only in that file's inline annotation is invisible to the walk — the same #793
+      # gap #788 closed for per-file analysis, left open here because #788's binding sentences scoped
+      # themselves to "the environments the per-file analysis builds". This path is exempt from #788's
+      # per-file-cache duplication concern: `effect.unknown-label` (and its envelope-pass siblings) are
+      # produced by this pass, never by `Runner#per_file_diagnostics`, so `IncrementalSession` never caches
+      # them and widening this source list cannot duplicate a row on recheck.
       def envelope_rbs_loader(expansion)
         environment = @run_environment ||
-                      @pool_coordinator.resolve_sequential_environment(source_files: target_files(expansion))
+                      @pool_coordinator.resolve_sequential_environment(source_files: expansion.fetch(:files))
         environment&.rbs_loader
       rescue StandardError
         nil
@@ -985,24 +1034,71 @@ module Rigor
         # per-file cache, so it needs the full analyzed set to subtract the affected closure from.
         targets = target_files(expansion)
         @analyzed_files = targets
-        diagnostics += @pool_coordinator.analyze_files(targets, environment: environment)
+        # Issue #784 — the whole project's file list rides along so an EMPTY `targets` (a narrowed run whose
+        # closure is empty) can still resolve the environment a full run would — same files, same
+        # synthesized RBS — to demand the HKT registry once, while a project with no files resolves nothing.
+        # #788 rounds 6–7 — the per-file stream is kept apart from the run-level streams appended below,
+        # because `IncrementalSession` must cache ONLY what per-file analysis produced (#per_file_diagnostics),
+        # and the reader is exposed SEVERITY-RESOLVED and sliced to this run's targets. The cache serves a
+        # reused file without re-stamping, so a raw row would resurrect a rule the profile resolves to `:off`
+        # (`static.value-use.void` ships off on the default profile) and serve the authored severity where an
+        # override re-stamps it; and a pool backend folds `.rigor.yml`-positioned prepare / pool-degraded rows
+        # into the same return, which the slice drops. The run's own stream is stamped once, at the end.
+        diagnostics += analyze_targets(targets, environment: environment, project_files: expansion.fetch(:files))
         # ADR-103 WD12 — the effect fixpoint, in the post-pool aggregation slot beside the conformance
         # results. Graph-only over a finite lattice, so it is a plain worklist to a true fixpoint; it
         # contributes NO diagnostics and its result leaves through `#effect_table`, never through the
         # stream. Skipped entirely when collection did not run.
         close_effect_graph
-        diagnostics += @diagnostic_aggregator.rbs_quarantined_signature_diagnostics
+        diagnostics + post_analysis_diagnostic_streams
+      end
+
+      # The rbs-coverage build-failure ladder plus every remaining post-analysis stream
+      # `#assemble_run_diagnostics` appends, in their fixed contract order (see the comments at each call
+      # below and at the streams' own definitions). Split out of `#assemble_run_diagnostics` so that
+      # method's `Metrics/AbcSize` stays under budget — every stream here is a plain `DiagnosticAggregator`
+      # reader with no branching of its own, so the split changes nothing about WHEN or in WHAT order they
+      # run.
+      def post_analysis_diagnostic_streams
+        diagnostics = @diagnostic_aggregator.rbs_quarantined_signature_diagnostics
         diagnostics += @diagnostic_aggregator.rbs_environment_build_failed_diagnostics
-        # Issue #696 — after its env-wide twin and before the synthesized-namespace notice: the three
+        # Issue #696 — after its env-wide twin and before the synthesized-namespace notice: the four
         # `rbs.coverage.*` build conditions surface widest-consequence first, and their relative order is
         # the diagnostic output contract.
         diagnostics += @diagnostic_aggregator.rbs_definition_build_failed_diagnostics
-        diagnostics += @diagnostic_aggregator.rbs_synthesized_namespace_diagnostics
+        # Issue #784 — last of the four, deliberately: it loses only the IMPLICIT HKT registrations a
+        # `type` alias would have contributed, never a class's own declared method surface, so it is the
+        # narrowest-consequence rung on the same ladder.
+        diagnostics += @diagnostic_aggregator.rbs_hkt_scan_failed_diagnostics
+        # The synthesized-namespace notice, then (#610) the plugin-signature stand-down: the outcome that
+        # AVOIDED a definition-build failure, so the quietest row on that ladder.
+        diagnostics += @diagnostic_aggregator.rbs_coverage_notice_diagnostics
         diagnostics += @diagnostic_aggregator.conforms_to_diagnostics
         diagnostics += @diagnostic_aggregator.rbs_extended_reporter_diagnostics
         diagnostics += @diagnostic_aggregator.boundary_cross_diagnostics
-        diagnostics + @diagnostic_aggregator.source_rbs_synthesis_diagnostics
-      end
+        diagnostics += @diagnostic_aggregator.source_rbs_synthesis_diagnostics
+        # Issue #959 — read LAST (after `analyze_targets`, which already ran before this method is called),
+        # so every per-file plugin call has had its chance to record a refusal on its (per-plugin-instance
+        # memoised) `IoBoundary`, alongside the prepare-time refusals the same boundary instance may
+        # already carry.
+        diagnostics + @diagnostic_aggregator.plugin_trust_refusal_diagnostics
+      end
+      private :post_analysis_diagnostic_streams
+
+      # #788 round 7 — runs per-file analysis over `targets` and exposes what it produced as
+      # `#per_file_diagnostics`: the `analyze_files` return, stamped with the same severity profile the run's
+      # own stream gets (`SeverityStamp` drops `:off` rows and re-stamps overrides, and the per-file cache never
+      # re-stamps), sliced to the rows positioned at the targets. Returns the RAW return for the run's stream,
+      # which is stamped once, at the end of `#run_analysis`.
+      def analyze_targets(targets, environment:, project_files:)
+        raw = @pool_coordinator.analyze_files(targets, environment: environment, project_files: project_files)
+        analysed = targets.to_set
+        @per_file_diagnostics = @diagnostic_aggregator.apply_severity_profile(raw)
+                                                      .select { |diagnostic| analysed.include?(diagnostic.path) }
+                                                      .freeze
+        raw
+      end
+      private :analyze_targets
 
       # ADR-67 WD6a — the check-walk parameter-inference pre-pass. Populates `@project_param_inferred_types`
       # (read by `project_scope_seed_tables`) with the call-site union of every undeclared parameter, running
@@ -1121,13 +1217,22 @@ module Rigor
       def build_run_dependency_descriptor(expansion, rbs_descriptor)
         entries = analyzed_file_entries(expansion) + discovery_file_entries(expansion) +
                   pre_eval_file_entries + rbs_descriptor.files
-        globs = []
+        # #979 — the signature ROOTS' listings, one glob row each. `rbs_descriptor.files` covers only the
+        # `.rbs` files that existed while the run read them, so without these a signature file written after
+        # the run left the slot validating fresh and the warm run answered without it.
+        globs = rbs_descriptor.globs.dup
         @plugin_registry.plugins.each do |plugin|
           # Read the boundary WITHOUT triggering its lazy `@io_boundary ||=` initializer: plugin instances
           # are frozen after the run, and a plugin that never built a boundary read no files through it,
           # so it contributes no dependencies.
           boundary = plugin.instance_variable_get(:@io_boundary)
-          entries.concat(boundary.cache_descriptor.files) if boundary
+          if boundary
+            # #629 — a boundary carries GlobEntry listing rows too (`IoBoundary#list_directory`), and they
+            # are the only edge back to a file the run decided was ABSENT from a directory it consulted.
+            boundary_descriptor = boundary.cache_descriptor
+            entries.concat(boundary_descriptor.files)
+            globs.concat(boundary_descriptor.globs)
+          end
           plugin.class.producers.each_value do |prod|
             globs.concat(plugin.send(:watch_glob_entries, prod[:watch])) if prod[:watch]
           end
@@ -1248,6 +1353,7 @@ module Rigor
         @project_discovered_superclasses = discovery.discovered_superclasses
         @project_discovered_header_nestings = discovery.discovered_header_nestings
         @project_discovered_includes = discovery.discovered_includes
+        @project_discovered_extends = discovery.discovered_extends
         @project_discovered_class_sources = discovery.discovered_class_sources
         @project_constant_values = discovery.constant_values
         @published_constant_name_set = nil
@@ -1341,7 +1447,7 @@ module Rigor
         3.0.0 3.1.0 3.2.0 3.3.0 3.4.0 3.5.0 4.0.0 4.1.0 4.2.0
       ].freeze
 
-      # @return [String, nil] the lowest `target_ruby` this Prism build accepts, or nil if none of the
+      # @return the lowest `target_ruby` this Prism build accepts, or nil if none of the
       #   ladder parses. Memoised per process (the value is constant for a given Prism).
       def self.prism_supported_floor
         @prism_supported_floor ||= PRISM_VERSION_LADDER.find do |candidate|
@@ -1427,7 +1533,7 @@ module Rigor
       # indexes, prepare-diagnostic snapshot, and the four end-of-pass snapshots) is reached through reader
       # procs so each collaborator observes the live ivar value at call time without a back-reference
       # cycle. The reporter accumulators and the {RunSnapshots} sink are shared mutable instances.
-      def build_collaborators # rubocop:disable Metrics/MethodLength
+      def build_collaborators # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         @pre_passes = ProjectPrePasses.new(
           configuration: @configuration, cache_store: @cache_store, buffer: @buffer,
           plugin_requirer: @plugin_requirer, pool_mode: -> { pool_mode? }
@@ -1446,7 +1552,8 @@ module Rigor
           synthetic_method_index: -> { @synthetic_method_index },
           project_patched_methods: -> { @project_patched_methods },
           project_scope_seed: -> { project_scope_seed_tables },
-          analyze_file: ->(path, environment) { analyze_file(path, environment) }
+          analyze_file: ->(path, environment) { analyze_file(path, environment) },
+          restored_run_level_rows: @restored_run_level_rows
         )
         @diagnostic_aggregator = DiagnosticAggregator.new(
           configuration: @configuration,
@@ -1460,8 +1567,10 @@ module Rigor
           pre_eval_diagnostics_from_scanner: -> { @pre_eval_diagnostics_from_scanner },
           synthesized_namespaces_snapshot: -> { @snapshots.synthesized_namespaces },
           quarantined_signatures_snapshot: -> { @snapshots.quarantined_signatures },
+          signature_standdowns_snapshot: -> { @snapshots.signature_standdowns },
           env_build_failure_snapshot: -> { @snapshots.env_build_failure },
           definition_build_failures_snapshot: -> { @snapshots.definition_build_failures },
+          hkt_scan_failure_snapshot: -> { @snapshots.hkt_scan_failure },
           conformance_results_snapshot: -> { @snapshots.conformance_results }
         )
       end
@@ -1693,7 +1802,7 @@ module Rigor
         unless @project_discovered_header_nestings.empty?
           tables[:discovered_header_nestings] = @project_discovered_header_nestings
         end
-        tables[:discovered_includes] = @project_discovered_includes unless @project_discovered_includes.empty?
+        seed_mixin_tables(tables)
         unless @project_discovered_method_visibilities.empty?
           tables[:discovered_method_visibilities] = @project_discovered_method_visibilities
         end
@@ -1704,6 +1813,14 @@ module Rigor
         tables
       end
 
+      # The two mixin tables: the ADR-24 instance-side `include` / `prepend` map and its #898 singleton-side
+      # `extend` twin. Paired here because they are read as one picture of a class's ancestry, and split out
+      # of {#project_scope_seed_tables} to keep it under the complexity budget.
+      def seed_mixin_tables(tables)
+        tables[:discovered_includes] = @project_discovered_includes unless @project_discovered_includes.empty?
+        tables[:discovered_extends] = @project_discovered_extends unless @project_discovered_extends.empty?
+      end
+
       # ADR-46 slice 1 / issue #644 — the two SOURCE-ATTRIBUTION tables, read only by the recording accessors
       # (`Scope#record_class_dependency` for the class-declaration map, `Scope#record_constant_dependency`
       # for the constant-write map). A normal run carries neither. Extracted to keep
@@ -1743,12 +1860,6 @@ module Rigor
         tables[:published_constant_names] = names unless names.empty?
       end
 
-      # Issue #644 — the seeded `in_source_constants` table, joining the two cross-file constant producers.
-      # The whole-project literal table wins over a `pre_eval:` publication of the same name: both describe
-      # the same assignment, the literal table pins the value the write actually carries while ADR-17's
-      # widener erases it to the class, and listing a file under `pre_eval:` must never LOSE precision. The
-      # per-file table still wins over both (`ScopeIndexer.index`'s merge) — same-file stays the most
-      # specific authority.
       # Issue #644 — the LAST SEGMENTS of the published table, the run-wide half of
       # `Scope#published_constant?`. Seeded on EVERY run (unlike `constant_sources`, which only a recording
       # run needs) because {CheckRules::PublishedConstantGuard} asks the question on every `if` / `unless`.
@@ -1757,11 +1868,57 @@ module Rigor
           @project_constant_values.keys.to_set { |name| name.split("::").last }.freeze
       end
 
+      # Issue #644 — the seeded `in_source_constants` table, joining the two cross-file constant producers.
+      # The whole-project literal table wins over a `pre_eval:` publication of the same name: both describe
+      # the same assignment, the literal table pins the value the write actually carries while ADR-17's
+      # widener erases it to the class, and listing a file under `pre_eval:` must never LOSE precision. The
+      # per-file table still wins over both (`ScopeIndexer.index`'s merge) — same-file stays the most
+      # specific authority.
       def merged_seed_constants
-        return @project_constant_values if @project_pre_eval_constants.empty?
-        return @project_pre_eval_constants if @project_constant_values.empty?
+        pre_eval = publishable_pre_eval_constants
+        return @project_constant_values if pre_eval.empty?
+        return pre_eval if @project_constant_values.empty?
+
+        pre_eval.merge(@project_constant_values).freeze
+      end
+
+      # Issue #663 — the `pre_eval:` publication with every name an UNLISTED file also assigns retracted.
+      # Without this a listed `X = :a` answered `Symbol` at every reader while a sibling `X = "str"` decided
+      # the runtime value half the time: a confident wrong type, not lost precision, and the one asymmetry
+      # #644's precedence work left standing. The retraction costs the opt-in nothing where it earns its
+      # keep — a name only listed files write is untouched, and where the literal table also publishes it
+      # already won (above).
+      #
+      # Conflict is read off #644's write attribution, which censuses every assigning form, so a name the
+      # listed file's own typed walk widened is retracted by an unlisted `X += 1` or `A, X = 1, 2` as
+      # readily as by a plain reassignment. Among LISTED files the rule is unchanged: `PreEvalConstants`
+      # widens first and drops only on disagreement, so two listed files writing `1` and `2` still publish
+      # `Integer` rather than being retracted for being two.
+      def publishable_pre_eval_constants
+        return @project_pre_eval_constants if @project_pre_eval_constants.empty?
+
+        listed = pre_eval_path_set
+        kept = @project_pre_eval_constants.reject { |name, _| unlisted_constant_writer?(name, listed) }
+        kept.size == @project_pre_eval_constants.size ? @project_pre_eval_constants : kept.freeze
+      end
+
+      # True when some file outside `listed` assigns `name`. The wildcard key is consulted alongside the
+      # name's own attribution ([#668](https://github.com/rigortype/rigor/issues/668)): a `k::X = 7` names
+      # no target, and a listed file kept out of `paths:` (ADR-17 WD5 permits it) contributes no censused
+      # name of its own for the wildcard's paths to have been folded into.
+      def unlisted_constant_writer?(name, listed)
+        segment = name.split("::").last
+        writers = @project_constant_sources[name]
+        wildcard = @project_constant_sources["#{Inference::ScopeIndexer::DYNAMIC_TARGET_PREFIX}#{segment}"]
+        [writers, wildcard].any? do |paths|
+          paths&.any? { |path| !listed.include?(File.expand_path(path)) }
+        end
+      end
 
-        @project_pre_eval_constants.merge(@project_constant_values).freeze
+      # The listed `pre_eval:` files, expanded so a census path and a configured one compare as the same
+      # file whichever spelling each arrived in.
+      def pre_eval_path_set
+        @pre_eval_path_set ||= @configuration.pre_eval.to_set { |path| File.expand_path(path) }
       end
 
       # ADR-46 — seed the instance + singleton `"path:line"` def-source tables (each only when non-empty).
@@ -1876,7 +2033,7 @@ module Rigor
             path: path,
             line: 1,
             column: 1,
-            message: "internal analyzer error: #{e.class}: #{e.message}",
+            message: CrashSignature.check_rule_message(e),
             severity: :error
           )
         ]