rigortype 0.4.6 → 0.4.7

data/lib/rigor/analysis/runner.rb

@@ -5,6 +5,7 @@ require "prism"
 require "tmpdir"
 
 require_relative "../environment"
+require_relative "../run_scoped_slots"
 require_relative "../scope"
 require_relative "../cache/store"
 require_relative "../cache/rbs_descriptor"
@@ -87,11 +88,10 @@ module Rigor
       # 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.
+      #
+      # Which rows those are is declared, not listed: every {RunLevelFacts} fact marked `replay`.
       def run_level_rows
-        Cache::IncrementalSnapshot::RunLevelRows.new(
-          definition_build_failures: @snapshots.definition_build_failures,
-          hkt_scan_failure: @snapshots.hkt_scan_failure
-        )
+        Cache::IncrementalSnapshot::RunLevelRows.new(**@snapshots.to_h.slice(*RunLevelFacts.replayable_names))
       end
 
       # ADR-46 — the per-file cross-file read records this run captured (empty unless
@@ -280,8 +280,7 @@ module Rigor
       # @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.
+      #   `--no-cache` flag wires `nil` through.
       # @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,
@@ -352,8 +351,8 @@ module Rigor
         @prebuilt = prebuilt
         @environment_override = environment
         # ADR-46 slice 1 — opt-in cross-file dependency recording. Off by default; when true,
-        # `analyze_file` records each file's cross-file reads into `file_dependencies` (the incremental
-        # cache, a later slice, consumes them).
+        # `analyze_file` records each file's cross-file reads into `file_dependencies`; the incremental
+        # cache consumes them.
         @record_dependencies = record_dependencies
         # ADR-24 slice 4a — opt-in unresolved-implicit-self-call recording. Off by default; when true,
         # `analyze_file` activates the engine choke-point recorder and collects each file's misses into
@@ -513,6 +512,9 @@ module Rigor
         # entry across a run boundary (LSP re-check, ADR-62 warm loop); nil until the first run so
         # runner-less probes keep the per-file fallback.
         @run_generation = nil
+        # The return memo bucket the last `run` filled, kept for {#return_summaries} once the run has released the
+        # thread's slot; nil before the first run.
+        @return_memo = nil
         build_collaborators
       end
 
@@ -535,6 +537,11 @@ module Rigor
         # freshness path for this run; the `auto` default resolves strict in CI (#190), stat-first elsewhere.
         Cache::FileDigest.with_run(strict: @configuration.cache_validation_strict?) do
           Inference::DefNodeResolver.with_run { run_analysis(paths) }
+        ensure
+          # ADR-89 WD2 — {#return_summaries} reads the return memo after the run, so the runner keeps the bucket the
+          # run filled before the thread's run-scoped slots are released (issues #2412, #2399).
+          @return_memo = Inference::ExpressionTyper.current_return_memo
+          RunScopedSlots.release
         end
       end
 
@@ -548,6 +555,21 @@ module Rigor
       end
       private :reset_analysis_attribution
 
+      # Issue #2392 — the sequential half of the per-run reset, beside {#reset_analysis_attribution}: the
+      # dependency graph and per-file effect collections a `--workers 0` run records, and the effect-slot state a
+      # served run leaves behind. The loader is the one that matters: a served run's collections loader would
+      # otherwise feed the next analysing run the previous run's collections. Runs before any `adopt_*`, which the
+      # served lanes call later in the same run, so an adopted slot is this run's own.
+      def reset_sequential_run_tables
+        @file_dependencies = {}
+        @file_effects = {}
+        @cached_effect_sources = nil
+        @cached_effect_ancestry = nil
+        @cached_collections_loader = nil
+        @effects_served_from_cache = false
+      end
+      private :reset_sequential_run_tables
+
       def run_analysis(paths)
         Inference::MethodDispatcher::FileFolding.fold_platform_specific_paths =
           @configuration.fold_platform_specific_paths
@@ -561,6 +583,10 @@ module Rigor
         @project_discovery_expansion = project_discovery_expansion(paths, expansion)
         @discovery_widened = widen_discovery_to_project?(paths)
         @snapshots.reset_for_run
+        # Issue #2392 — the coordinator's run-accumulated tables (disclosures, trust refusals, the dependency and
+        # effect graphs) are per run too: a reused Runner must not re-emit or sum the previous run's rows.
+        @pool_coordinator.reset_for_run
+        reset_sequential_run_tables
         # Per-run reset of the deferred-discovery memo (see `#ensure_project_discovery`).
         @project_discovery_done = false
         # #392 — re-derive the template units each run: their source files can change between two runs of
@@ -768,9 +794,10 @@ 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 `{ [path, "Class#method" | "Class.method"] => { keys:, returns:, effects: } }`.
+      # @return the summaries keyed by `[path, "Class#method"]` (or `"Class.method"`), each holding `keys:`,
+      #   `returns:` and `effects:`.
       def return_summaries
-        memo = Inference::ExpressionTyper.harvest_return_memo
+        memo = Inference::ExpressionTyper.harvest_return_memo(@return_memo)
         return {} if memo.empty?
 
         result = {}
@@ -828,13 +855,15 @@ module Rigor
       #
       # @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, …] }`.
+      # @return the re-evaluated return descriptors, one per key, keyed by `[class_name, method_name, singleton]`.
       def evaluate_return_types(paths, specs)
         return {} if specs.empty?
 
         Cache::FileDigest.with_run(strict: @configuration.cache_validation_strict?) do
           Inference::DefNodeResolver.with_run { evaluate_return_types_setup(paths, specs) }
         end
+      ensure
+        RunScopedSlots.release
       end
 
       # Builds the discovery index + environment (a real run's prologue, minus per-file analysis) and
@@ -1021,17 +1050,12 @@ module Rigor
         nil
       end
 
-      # The write half, run only after a miss, so the block never recomputes anything: it hands over the
-      # collections the analysis just produced — and the table the analysis already closed over them, so
-      # a warm hit re-runs neither the merge nor the fixpoint — validated against the same post-run
-      # dependency descriptor the diagnostics slot records. Fail-soft — a collection that will not
-      # Marshal (which nothing in {Effects::FileCollection} should be, and the fork pool already proves
-      # per file) costs the next run its warm start and nothing else.
-      # The write half, run only after a miss, so neither block recomputes anything. Two entries under one
+      # The write half, run only after a miss, so nothing here recomputes anything. Two entries under one
       # key descriptor and one dependency descriptor (#482): the summary a warm run serves from, and the
       # collections the incremental and fail-soft paths read. The summary is written LAST, so a run
       # interrupted between the two leaves a collections entry that the next run's summary miss simply
-      # re-collects — never a summary whose collections are absent.
+      # re-collects — never a summary whose collections are absent. A collection that will not Marshal
+      # costs the next run its warm start and nothing else.
       def store_effect_collections(descriptor, expansion, rbs_descriptor)
         return if descriptor.nil?
 
@@ -1233,40 +1257,13 @@ module Rigor
       end
       private :template_unit_failure_diagnostics
 
-      # 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.
+      # Every remaining post-analysis stream `#assemble_run_diagnostics` appends — the `rbs.coverage.*`
+      # build-failure ladder (widest consequence first: quarantine, env build, definition build #696, HKT scan
+      # #784), its notices, the conformance rows, the reporter streams, the plugin run disclosures (#1051)
+      # and, last, the trust-refusal envelope (#959) — in the contract order ADR-116 WD3's
+      # {RunLevelFacts} declares. Read after `analyze_targets`, so every worker payload has been merged.
       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 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
-        # 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
-        # Issue #1051 — read after `analyze_targets` for the same reason the refusal stream below is: a
-        # plugin may register a disclosure from `#prepare` (the usual case) or while analysing a file, and
-        # both have to be in before the table is harvested. Ordered before the refusals so the run-level
-        # plugin rows read plugin-authored notice first, engine-authored envelope second.
-        diagnostics += @diagnostic_aggregator.plugin_run_disclosure_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
+        @diagnostic_aggregator.run_level_diagnostics
       end
       private :post_analysis_diagnostic_streams
 
@@ -1583,7 +1580,9 @@ module Rigor
       # change time it cannot read, and passes over a `pinned` one.
       BaselineRows = Data.define(:owned, :pinned)
 
-      SignatureRoots = Struct.new(:signature_paths)
+      # A loader's two readers {Cache::RbsDescriptor} takes signature roots from. `core_root` (issue #2517) is the
+      # selected core, which the slot key names by path only, so its files are `owned` rows like the project's own.
+      SignatureRoots = Struct.new(:signature_paths, :core_root)
       private_constant :SignatureRoots
 
       # @param files — the run's analysed-path set.
@@ -1604,8 +1603,9 @@ module Rigor
 
       # The signature tree's rows, the project's own and the rest.
       def signature_rows
-        roots = SignatureRoots.new(@snapshots.signature_paths)
-        own = signature_root_candidates.map { |root| File.join(File.absolute_path(root.to_s), "") }
+        roots = SignatureRoots.new(@snapshots.signature_paths, @configuration.core_root)
+        own = (signature_root_candidates + [@configuration.core_root].compact)
+              .map { |root| File.join(File.absolute_path(root.to_s), "") }
         own_files, other_files = Cache::RbsDescriptor.file_entries(roots, comparator: :stat)
                                                      .partition { |row| within?(row.path, own) }
         own_globs, other_globs = Cache::RbsDescriptor.glob_entries(roots).partition { |row| within?(row.root, own) }
@@ -2056,8 +2056,7 @@ module Rigor
       # Editor mode § "Scope choice — option A". Under `buffer:` non-nil the per-file analysis emits
       # diagnostics ONLY for the buffer's logical path; the rest of `paths:` is consumed by the
       # project-wide pre-passes (synthetic methods, project-patched methods, plugin facts) but contributes
-      # no per-file diagnostics. This is the v1 cut before a per-file diagnostic cache exists; option B
-      # (full project + incremental cache) is queued.
+      # no per-file diagnostics. Option B (#146) narrows to the closure instead; see {#target_files}.
       #
       # The buffer's logical path is added to the file list even if it's not under `paths:` — per design §
       # "Failure envelope": "--instead-of=Y with Y not under any paths: directory → treated as a valid
@@ -2090,7 +2089,13 @@ module Rigor
           # The logical path joins even when it is not on disk under `paths:` (design § "Failure envelope"),
           # the same allowance option A makes below.
           files = files.select { |path| @analyze_only.include?(path) }
-          files |= [@buffer.logical_path] if @buffer && @analyze_only.include?(@buffer.logical_path)
+          # Issue #2233 — a buffer that is a claimed template joins as its unit, appended by
+          # {#template_unit_targets}, never as a `.rb` file: the logical path in its absolute spelling would
+          # otherwise analyse the same template twice. The registry is loaded by now, which is why the test is here
+          # and not in the incremental session, where it is not.
+          if @buffer && @analyze_only.include?(@buffer.logical_path) && !template_path?(@buffer.logical_path)
+            files |= [@buffer.logical_path]
+          end
           return template_unit_targets(files)
         end
         return template_unit_targets(files) if @buffer.nil?
@@ -2126,6 +2131,14 @@ module Rigor
       end
       public :template_unit_paths
 
+      # Issue #2233 — whether `path` is a template of this run: a claimed glob matches it, or it names a unit. The
+      # runner keeps the buffer's logical path out of the targets when this is true, so a template buffer is
+      # analysed once, as a unit ({#template_unit_targets} appends it), and never also as a plain `.rb` file.
+      def template_path?(path)
+        template_units.claims?(path) ||
+          template_unit_paths.include?(Analysis::TemplateUnitPaths.relative(path, Dir.pwd))
+      end
+
       # Editor mode (`buffer:` non-nil) auto-flips the cache store to `read_only: true` so multiple
       # debounced editor invocations against the same project don't churn the on-disk cache or race on
       # schema-version writes. Cache reads continue unchanged; misses still run the producer block but the
@@ -2179,14 +2192,7 @@ module Rigor
           pool_mode: -> { pool_mode? },
           cached_plugin_prepare_diagnostics: -> { @cached_plugin_prepare_diagnostics },
           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 },
-          vendored_standdowns_snapshot: -> { @snapshots.vendored_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 },
+          snapshots: @snapshots,
           pooled_run_disclosures: -> { @pool_coordinator.collected_run_disclosures },
           served_run_disclosures: -> { @served_run_disclosures },
           pooled_trust_refusals: -> { @pool_coordinator.collected_trust_refusals }
@@ -2520,14 +2526,14 @@ module Rigor
         @discovery_seed ? @discovery_seed.dup : {}
       end
 
-      # Seeds the two OPT-IN pre-pass tables — the ones an ordinary run leaves empty, so they are absent from
-      # the seed entirely unless the project asked for them. Both ride this seed so a pooled `WorkerSession`
-      # scope resolves identically to the sequential path (ADR-15 sequential equivalence).
+      # Seeds the parameter-inference and constant-publication tables, so a pooled `WorkerSession` scope resolves
+      # identically to the sequential path (ADR-15 sequential equivalence). The parameter-inference table is absent
+      # unless its opt-in ran; the constant tables are seeded whenever the run has project constants.
       #
       # - ADR-67 WD6a `param_inferred_types`: the call-site parameter-inference table, populated only when the
       #   `parameter_inference:` gate ran the pre-pass.
-      # - Issue #352 `in_source_constants`: the `pre_eval:` constant publication, populated only when the
-      #   project lists `pre_eval:` files that declare publishable constants.
+      # - Issue #352 `in_source_constants`: the `pre_eval:` constant publication, merged with the project's
+      #   literal constant table (#644, see {#merged_seed_constants}).
       #
       # Extracted to keep {#project_scope_seed_tables} under the complexity budget.
       def seed_opt_in_pre_pass_tables(tables)

data/lib/rigor/analysis/self_call_resolution_recorder.rb

@@ -18,7 +18,7 @@ module Rigor
     # recompute" lesson applied to self-calls.
     #
     # ADR-24 slice 4 (`call.self-undefined-method`) consumes the recorded misses behind a confidently-closed-class
-    # gate (see `CheckRules` L775). The rule ships `:off` by default — {active?} is false on a normal run, so
+    # gate (see `CheckRules`). The rule ships `:off` by default — {active?} is false on a normal run, so
     # the instrumented choke-point pays a single integer read and records nothing. Recording is purely
     # observational; it never changes a diagnostic.
     #

data/lib/rigor/analysis/template_unit_positions.rb

@@ -173,9 +173,8 @@ module Rigor
       # copies one tag body once, and the second `@author` is the same copy seen from the other end, not a
       # second reading. Only a node OUTSIDE the winning run's own compiled span counts, which is what keeps
       # the busy lines of a real view answerable while the cross-tag repeat (`<%= v %> <%= v.to_s %>`, or
-      # `<%= v %><%= "v" %>` probed at the STRING's `v`) still declines — the family a plugin-exported tag
-      # span would answer instead
-      # (see the PR), and the follow-up this rule is deliberately conservative ahead of.
+      # `<%= v %><%= "v" %>` probed at the STRING's `v`) still declines. That family is what a plugin-exported
+      # tag span would answer instead, and it is the follow-up this rule is deliberately conservative ahead of.
       #
       # `spill` is the nearest NON-BLANK compiled line above this template line's own, where a hoisted
       # leading-text literal lives. Only a string literal the run does NOT contain counts there. A code

data/lib/rigor/analysis/template_units.rb

@@ -189,6 +189,15 @@ module Rigor
         @entries.keys.sort
       end
 
+      # Issue #2233 — whether a plugin claims `path` by one of its `template_globs:`, in any spelling a caller holds it
+      # (absolute, `./`-prefixed, relative). A claimed template is analysed as a unit, never as a plain `.rb` file, so
+      # the runner keeps the buffer's logical path out of the `.rb` targets, so it is not analysed twice.
+      def claims?(path)
+        return false if @claimed_globs.empty?
+
+        TemplateUnitPaths.claims?(@claimed_globs, TemplateUnitPaths.relative(path, @root))
+      end
+
       def [](path)
         entry_for(path)
       end
@@ -293,7 +302,6 @@ module Rigor
         [entry.locals.keys.map(&:to_sym)]
       end
 
-      # The `view:<logical_name>` effect-unit key for a path, or nil.
       # The file whose bytes a unit's path was READ from: the editor's buffer when one is bound to it, the
       # project file otherwise. Read by the run's dependency descriptor, so it digests what the run read.
       def physical_path(path, buffer)

data/lib/rigor/analysis/worker_session.rb

@@ -25,6 +25,7 @@ require_relative "dependency_source_inference"
 require_relative "diagnostic"
 require_relative "erb_template_detector"
 require_relative "template_units"
+require_relative "runner/run_level_facts"
 
 module Rigor
   module Analysis
@@ -39,8 +40,8 @@ module Rigor
     # - `configuration` — Phase 2a ({Rigor::Configuration} is `Ractor.shareable?`).
     # - `cache_store` — the fork backend passes the parent runner's pre-built Store (`cache_store:
     #   @cache_store` in PoolCoordinator); workers share it rather than building their own at `cache_root`.
-    # - `plugin_blueprints` — Phase 3a (`Array<Plugin::Blueprint>` is `Ractor.shareable?`).
-    # - `explain` — Boolean.
+    # - `plugin_blueprints` — Phase 3a (a list of `Plugin::Blueprint` is `Ractor.shareable?`).
+    # - `explain` — a flag.
     # - `synthetic_method_index` / `project_patched_methods` / `project_scope_seed` — optional (default `nil`
     #   / `{}`). NOT `Ractor.shareable?` (the seed tables carry Prism def nodes), so the Ractor pool path
     #   leaves them unset; the fork backend (ADR-15 Amendment), which builds the session pre-fork on the
@@ -109,7 +110,7 @@ module Rigor
         # above: a worker and the parent agree without a flag to keep in sync.
         @effect_attribution = Effects::Attribution.build(configuration.effects_attribution)
         @file_effects = {}
-        # ADR-32 WD4 — full project file list (frozen Array<String>) for env-build-time invocation of any
+        # ADR-32 WD4 — full project file list (frozen) for env-build-time invocation of any
         # loaded plugin's `source_rbs_synthesizer` callable.
         @source_files = source_files
         # #392 — the run's template units, synthesised on the PARENT before the fork and inherited here as
@@ -162,7 +163,7 @@ module Rigor
       end
 
       # Equivalent of {Rigor::Analysis::Runner#analyze_file} + `plugin_emitted_diagnostics` +
-      # `explain_diagnostics`. Returns a flat `Array<Diagnostic>` for the file. Severity profile re-stamping
+      # `explain_diagnostics`. Returns a flat list of diagnostics for the file. Severity profile re-stamping
       # is intentionally NOT applied — that is a per-run aggregate concern handled by the caller. When
       # `record_dependencies:` was set, wraps the analysis in a {DependencyRecorder} window (ADR-46) so the
       # worker captures the file's cross-file reads for {#drain_dependencies}; the recorder's own disabled
@@ -271,7 +272,7 @@ module Rigor
       # definition and never enters the failing build; a diagnostic wired off the parent's loader would
       # appear at `--workers=0` and vanish at `--workers=N`, which is the same "reports less depending on
       # how you ran it" defect the diagnostic exists to end. Draining it out of the workers is what makes
-      # the two paths say the same thing. The payload is `[String, String, String, Array<String>]` tuples —
+      # the two paths say the same thing. The payload is a list of plain tuples —
       # Marshal-clean for the fork backend and shareable for the Ractor one.
       #
       # Issue #784 — `hkt_scan_failure` rides the same channel for the same reason: the PARENT's own
@@ -284,33 +285,25 @@ module Rigor
       # project whose `sig/` produced a single such event killed each worker HERE — after its files were
       # analysed — and the run degraded to in-process re-analysis with a `pool-degraded` row. All three
       # streams now carry `(path, line, column)` primitives.
+      #
+      # ADR-116 WD3 (#1195) — both halves are declared rather than listed here: each reporter snapshots its
+      # own streams ({Runner::RunLevelFacts::REPORTERS}), and the `:analysis` facts come from
+      # {Runner::RunLevelFacts.drain}, the same read the coordinator makes of an environment it analysed on.
+      # The facts are read first: their HKT demand (#784, made once per worker so a worker whose share of
+      # files demanded nothing still reports the run's outcome) is what fills the hkt-directive stream (#785).
+      # On a worker that analysed a file the demand is a memoised read; the fork backend never hands a worker
+      # an empty slice, so no idle worker pays the env load.
       def drain_reporters
-        # Issue #784 — demand the registry once per worker before reading the slot, so a worker whose share
-        # of files happened to contain no `Klass.method` call still reports the run's outcome (the same
-        # reason `PoolCoordinator#hkt_scan_outcome` demands it on the sequential path). The Environment
-        # object is built in the constructor, but its RBS env is lazy: on a worker that analysed a file this
-        # is a memoised read; on one that demanded nothing it is the same cache-served env load that file
-        # would have paid. The fork backend never hands a worker an empty slice, so no idle worker pays it.
-        @environment&.hkt_registry
-        {
-          rbs_extended: {
-            unresolved_payloads: @rbs_extended_reporter.unresolved_payloads,
-            lossy_projections: @rbs_extended_reporter.lossy_projections,
-            # Issue #785 — the HKT directive stream rides the same channel for the same reason
-            # `hkt_scan_failure` does: the directives are read by the registry scan, and under the pool the
-            # PARENT never demands that scan, so a diagnostic wired off the parent's reporter would appear
-            # at `--workers=0` and vanish at `--workers=N`. The demand above is what fills this.
-            hkt_directive_errors: @rbs_extended_reporter.hkt_directive_errors,
-            # ADR-109 WD3 — the deprecated-form stream rides the same channel: the payload is read where
-            # the annotated method is dispatched, which under the pool is only ever inside a worker.
-            deprecated_forms: @rbs_extended_reporter.deprecated_forms
-          },
-          boundary_cross: @boundary_cross_reporter.entries,
-          source_rbs_synthesis: @source_rbs_synthesis_reporter.entries,
-          definition_build_failures: @environment&.rbs_loader&.definition_build_failures || [],
-          hkt_scan_failure: @environment&.hkt_scan_failure
-        }
+        facts = Runner::RunLevelFacts.drain(@environment)
+        Runner::RunLevelFacts.snapshot_reporters(reporters).merge(facts)
+      end
+
+      # The per-worker reporter accumulators, by {Runner::RunLevelFacts::REPORTERS} key.
+      def reporters
+        { rbs_extended: @rbs_extended_reporter, boundary_cross: @boundary_cross_reporter,
+          source_rbs_synthesis: @source_rbs_synthesis_reporter }
       end
+      private :reporters
 
       # ADR-46 — the per-file {DependencyRecorder::Record}s captured by this session's `#analyze` calls (empty
       # unless `record_dependencies:` was set). Marshal-clean (Data of frozen Sets / String Hashes), so the
@@ -457,7 +450,7 @@ module Rigor
         return nil if gem_name.nil? || gem_name.empty?
 
         spec = Gem.loaded_specs[gem_name]
-        spec&.full_gem_path # rigor:disable undefined-method
+        spec&.full_gem_path
       rescue StandardError
         nil
       end

data/lib/rigor/bleeding_edge.rb

@@ -9,11 +9,9 @@ module Rigor
   # *today's* rules are) and is versioned with the gem, NOT a user-supplied file: the
   # inspectable counterpart to PHPStan's `bleedingEdge` include.
   #
-  # The WD2 foundation slice wired the surface end-to-end (`bleeding_edge:` config, the
-  # `rigor show-bleedingedge` command, the severity-composition hook in
-  # {Configuration::SeverityProfile.resolve}), so a *severity* discipline lands as a single
-  # {FEATURES} entry with no engine plumbing — as the first one,
-  # `reject-unparseable-signatures`, does.
+  # The surface is wired end-to-end (`bleeding_edge:` config, `rigor show-bleedingedge`, the
+  # severity-composition hook in {Configuration::SeverityProfile.resolve}), so a *severity*
+  # discipline is a single {FEATURES} entry with no engine plumbing.
   #
   # A queued change whose effect is not a severity move — a measurement, an algorithm, or a
   # default that changes while every rule keeps its severity — is a `:behaviour` feature
@@ -40,7 +38,6 @@ module Rigor
     # {Configuration#bleeding_edge_active?}.
     KINDS = %i[severity behaviour].freeze
 
-    # The severity map a `:behaviour` feature carries: none.
     NO_SEVERITY_OVERRIDES = {}.freeze
 
     # One queued change.

data/lib/rigor/builtins/imported_refinements.rb

@@ -113,9 +113,8 @@ module Rigor
         },
         # ADR-13 § "Canonical type-function additions" — five shape-projection type functions
         # that the `rigor-typescript-utility-types` plugin (and any other plugin that ships a
-        # shape-projection vocabulary) maps onto. Phase A handles `HashShape` carriers;
-        # non-shape inputs return the input unchanged (the lossy-projection diagnostic lands
-        # in slice 5).
+        # shape-projection vocabulary) maps onto. Non-shape inputs return the input unchanged;
+        # the Resolver records `dynamic.shape.lossy-projection` for them.
         "pick_of" => lambda { |args|
           return nil unless args.size == 2
 
@@ -148,7 +147,7 @@ module Rigor
       # `Class[range]` — a numeric class head bounded by a Ruby range literal (ADR-109). The
       # builder receives the `Range` value and returns the carrier, or `nil` when the range is
       # empty or its endpoints are not literals of the head class; `nil` surfaces as the ordinary
-      # unresolved-payload diagnostic. `Float` joins this table with the `FloatRange` carrier.
+      # unresolved-payload diagnostic. `Float` builds a `FloatRange` carrier.
       RANGE_HEAD_BUILDERS = {
         "Integer" => lambda { |range|
           lo = range.begin
@@ -186,8 +185,7 @@ module Rigor
       # `Array<Integer>` and returns a `Rigor::Type` (or `nil`). Bounds are signed integer
       # literals. A reversed pair (`min` > `max`) is declined as `nil` like every other shape
       # mismatch, so the caller surfaces `dynamic.rbs-extended.unresolved` at the annotation;
-      # `Type::IntegerRange` raises on it instead, and that `ArgumentError` used to escape as an
-      # `internal analyzer error` that abandoned the whole Ruby file.
+      # `Type::IntegerRange` would raise on it instead, which must not escape the analyzer.
       PARAMETERISED_INT_BUILDERS = {
         "int" => lambda { |bounds|
           return nil unless bounds.size == 2
@@ -276,14 +274,14 @@ module Rigor
       # grammar:
       #
       #   type        := simple_name | parametric
-      #   simple_name := /[a-z][a-z0-9-]*/
+      #   simple_name := /[a-z][a-z0-9_-]*/
       #   parametric  := simple_name '[' type_arg_list ']'
       #                | simple_name '<' int_bound_list '>'
       #   type_arg_list := type_arg (',' type_arg)*
       #   type_arg    := range_literal | type | class_name
       #   class_name  := /[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*/
       #   range_literal := endpoint? ('..' | '...') endpoint?     (at least one side written)
-      #   endpoint    := signed_int | 'nil'
+      #   endpoint    := signed_int | float_literal | 'nil' | 'Float::INFINITY' | 'Float::MAX'
       #   int_bound_list := signed_int (',' signed_int)*
       #   signed_int  := /-?\d+/
       #

data/lib/rigor/builtins/predefined_constant_refinements.rb

@@ -62,7 +62,7 @@ module Rigor
     # `RBS::VERSION` while Rigor checks itself, rubygems and Bundler internals while it checks
     # CRuby's `lib/` — and that is worse than no answer: identical source would type differently
     # depending on how the analyzer was installed. Removing an ad hoc `Object.const_get` from an
-    # analysis path is the same move ADR-4 § 330 already made for predicate narrowing.
+    # analysis path is the same move ADR-4 already made for predicate narrowing.
     #
     # This module is consulted by `Environment#constant_for_name` BEFORE the RBS
     # constant-type table (widest types) but AFTER in-source constant writes (the user's own

data/lib/rigor/builtins/regex_refinement.rb

@@ -8,13 +8,11 @@ module Rigor
     # carriers Rigor already ships (`decimal-int-string`, `hex-int-string`,
     # `octal-int-string`, `lowercase-string`, `uppercase-string`, `numeric-string`). See
     # `docs/type-specification/imported-built-in-types.md` for the registry the refinements
-    # come from and `docs/ROADMAP.md` § "v0.1.1 — Planned" Track 1 slice 1 for the binding
-    # scope of this recogniser.
+    # come from.
     #
-    # The intended consumer is `Inference::Narrowing.analyse_match_write`: given `if
-    # /(?<year>\d+)/ =~ str; year; end`, the v0.1.0 baseline narrows `year` to plain `String`;
-    # v0.1.1 introspects the regex source and narrows further to `decimal-int-string`
-    # whenever the named-capture body matches one of the rows in {RULES}.
+    # The consumer is `Inference::Narrowing.analyse_match_write`: given `if /(?<year>\d+)/ =~ str;
+    # year; end`, `year` narrows to `decimal-int-string` when the named-capture body matches a row
+    # in {RULES}, and stays plain `String` otherwise.
     #
     # Recognised body shapes (each row admits the `+` quantifier and the bounded `{n}` /
     # `{n,m}` forms with `n >= 1`):

data/lib/rigor/cache/descriptor.rb

@@ -10,7 +10,8 @@ module Rigor
   module Cache
     # Cache invalidation descriptor — the typed-slot schema fixed by
     # [`docs/design/20260505-cache-slice-taxonomy.md`](../../../docs/design/20260505-cache-slice-taxonomy.md).
-    # Pure value object: no I/O, no global state, fully immutable after construction. The storage layer
+    # Value object, fully immutable after construction. Filesystem reads happen only in the `FileEntry.stat`,
+    # `FileEntry.kind` and `GlobEntry.compute` builders and in {#fresh?}. The storage layer
     # ([`Rigor::Cache::Store`](store.rb), v0.0.8 slice 2) consumes descriptors but does not extend them.
     #
     # The descriptor has six slots (`files`, `gems`, `plugins`, `configs`, `dependencies`, `globs`); every slot is
@@ -462,10 +463,10 @@ module Rigor
 
       # ADR-45 — re-validates this descriptor's recorded {FileEntry}s against the current filesystem. Used by
       # the record-and-validate run-result cache: a value cached alongside its dependency descriptor is fresh
-      # iff every recorded file still matches. Only `files` are checked — non-file inputs (config / gems /
+      # iff every recorded file still matches. Only `files` and `globs` are checked — non-file inputs (config / gems /
       # version) belong in the cache *key*, not the validated dependency set — so a descriptor carrying any
       # non-file slot is never considered fresh (it was built wrong for this use). ADR-60 WD3 adds `globs`
-      # alongside `files` as a re-validatable slot: a {GlobEntry} is fresh when re-globbing + re-digesting
+      # alongside `files` as a re-validatable slot: a {GlobEntry} is fresh when re-globbing
       # reproduces its recorded value. ADR-45 WD1 (#577): an absence row ({FileEntry.absent}) is fresh
       # while its path is still missing — the negative half of the dependency set.
       def fresh?
@@ -581,8 +582,8 @@ module Rigor
         false
       end
 
-      # ADR-60 WD3 / ADR-87 WD2 — stat-validates the entry's per-file table against the live tree, re-hashing
-      # only stat-moved files. Any failure reads as stale (recompute), never a crash.
+      # ADR-60 WD3 / ADR-87 WD2 — recomputes the entry's signature over the live tree and compares it. Any
+      # failure reads as stale (recompute), never a crash.
       def glob_entry_fresh?(entry)
         GlobEntry.fresh?(entry)
       end