rigortype 0.4.5 → 0.4.6

data/lib/rigor/inference/synthetic_method_index.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "digest"
+
 require_relative "synthetic_method"
 
 module Rigor
@@ -65,8 +67,29 @@ module Rigor
         { "entries" => entries.map(&:to_h), "class_names" => class_names }
       end
 
+      # What a dispatch can read from the index, digested (nil for the empty index): each key's rows in their
+      # first-wins order, with the return type and the Tier B `origin_module` the dispatcher promotes through,
+      # and the synthesised class names. The rest of the provenance (the call site's path and line) is left
+      # out, so an edit that only moves the `devise` line keeps the digest. `IncrementalSession` compares it
+      # across runs (PR #2286 review M1): the index is built from class-body calls that no declaration
+      # signature records, so a recheck that sees it move cannot trust its served files.
+      def surface_digest
+        return nil if empty?
+
+        rows = entries.each_with_index
+                      .sort_by { |entry, index| [entry.kind.to_s, entry.class_name, entry.method_name.to_s, index] }
+                      .map { |entry, _| surface_row(entry) }
+        Digest::SHA256.hexdigest((rows + class_names.sort.map { |name| "class\x1f#{name}" }).join("\x00"))
+      end
+
       EMPTY_ROW = [].freeze
 
+      def surface_row(entry)
+        [entry.kind, entry.class_name, entry.method_name, entry.return_type,
+         entry.provenance[:origin_module], entry.provenance[:plugin_id]].join("\x1f")
+      end
+      private :surface_row
+
       def bucket(entries, kind)
         h = {}
         entries.each do |entry|

data/lib/rigor/inference/synthetic_method_scanner/project_members.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../../source/literals"
+
+module Rigor
+  module Inference
+    module SyntheticMethodScanner
+      # The instance-method names a project class answers ahead of a module a trait registry includes into it
+      # (PR #2286 review S1). Ruby looks a method up on the class itself before any module it includes, and a
+      # module the class itself includes or prepends sits ahead of one `devise` included earlier — so where
+      # the project names a member, the Tier B entry for it would answer the call from the wrong rung:
+      #
+      #   class User < ApplicationRecord
+      #     devise :confirmable
+      #     include PasswordPolicy   # defines password_required?
+      #     def confirmed? = :yes
+      #   end
+      #
+      # `User.new.confirmed?` is `:yes` and `password_required?` is the policy's, not `bool` from the Devise
+      # module's RBS. {SyntheticMethodScanner} therefore drops a trait entry whose name this index reports.
+      #
+      # A name counts as the class's when any reopening of the class body (in any project file) writes `def`,
+      # `alias` / `alias_method`, `attr_*`, `define_method` or `delegate` for it, or when a project module the
+      # class includes or prepends (followed through that module's own `include` / `prepend`) does. The MRO
+      # order of an `include` relative to the `devise` call is NOT consulted: a module included before the
+      # call sits behind the Devise module at runtime, but the name is declined anyway. Declining is the
+      # conservative direction — the call then reaches the tiers below the synthetic one (the discovered
+      # method, the project mixin), which answer it as they did before Tier B was reachable. A mixin constant
+      # is matched to a project module by name or by `::`-suffix, again widening only what is declined.
+      class ProjectMembers
+        # The calls that name members through their literal arguments, and the suffixes each name takes.
+        SUFFIXES_BY_CALL = Ractor.make_shareable(
+          {
+            attr_reader: [""], attr: [""], attr_writer: ["="], attr_accessor: ["", "="], delegate: [""]
+          }
+        )
+        NAME_ARG_CALLS = %i[define_method alias_method].freeze
+        MIXIN_CALLS = %i[include prepend].freeze
+
+        Entry = Struct.new(:names, :mixins)
+        private_constant :Entry
+
+        def initialize(asts)
+          @classes = Hash.new { |hash, key| hash[key] = Entry.new(Set.new, []) }
+          @modules = Hash.new { |hash, key| hash[key] = Entry.new(Set.new, []) }
+          asts.each_value { |ast| walk_namespaces(ast, []) unless ast.nil? }
+          @declared = {}
+        end
+
+        # True when `class_name`'s own body, or a project module it includes or prepends, names `method_name`.
+        def declares?(class_name, method_name)
+          (@declared[class_name] ||= declared_names(class_name)).include?(method_name.to_sym)
+        end
+
+        private
+
+        def declared_names(class_name)
+          entry = @classes.fetch(class_name, nil)
+          return Set.new.freeze if entry.nil?
+
+          names = entry.names.dup
+          visited = Set.new
+          queue = entry.mixins.dup
+          until queue.empty?
+            module_keys_for(queue.shift).each do |key|
+              next unless visited.add?(key)
+
+              names.merge(@modules[key].names)
+              queue.concat(@modules[key].mixins)
+            end
+          end
+          names.freeze
+        end
+
+        def module_keys_for(name)
+          @modules.keys.select { |key| key == name || key.end_with?("::#{name}") }
+        end
+
+        def walk_namespaces(node, scope_stack)
+          case node
+          when Prism::ClassNode, Prism::ModuleNode
+            name = SyntheticMethodScanner.class_name_from(node, scope_stack)
+            if name
+              table = node.is_a?(Prism::ClassNode) ? @classes : @modules
+              collect_members(node.body, table[name])
+            end
+            inner = scope_stack + [node]
+            node.body&.rigor_each_child { |child| walk_namespaces(child, inner) }
+          else
+            node.rigor_each_child { |child| walk_namespaces(child, scope_stack) }
+          end
+        end
+
+        # Every member-naming form under the namespace body, at any depth short of a nested namespace (a
+        # `private def`, a `def` under a conditional and an `included do ... def` all count). A nested `class`,
+        # `module` or `class << self` is another namespace's body.
+        def collect_members(node, entry)
+          return if node.nil?
+
+          case node
+          when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode then return
+          when Prism::DefNode then entry.names << node.name if node.receiver.nil?
+          when Prism::AliasMethodNode then add_symbol(entry, node.new_name)
+          when Prism::CallNode then collect_call(node, entry)
+          end
+          node.rigor_each_child { |child| collect_members(child, entry) }
+        end
+
+        def collect_call(call, entry)
+          return unless call.receiver.nil? || call.receiver.is_a?(Prism::SelfNode)
+
+          args = call.arguments&.arguments || []
+          if MIXIN_CALLS.include?(call.name)
+            entry.mixins.concat(args.filter_map { |arg| SyntheticMethodScanner.const_name_string(arg) })
+          elsif NAME_ARG_CALLS.include?(call.name)
+            add_symbol(entry, args.first)
+          elsif (suffixes = SUFFIXES_BY_CALL[call.name])
+            args.each { |arg| suffixes.each { |suffix| add_symbol(entry, arg, suffix: suffix) } }
+          end
+        end
+
+        def add_symbol(entry, node, suffix: "")
+          value = Source::Literals.symbol_or_string_name(node)
+          entry.names << :"#{value}#{suffix}" unless value.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/synthetic_method_scanner.rb

@@ -8,6 +8,7 @@ require_relative "../source/literals"
 require_relative "../source/node_children"
 require_relative "synthetic_method"
 require_relative "synthetic_method_index"
+require_relative "synthetic_method_scanner/project_members"
 
 module Rigor
   module Inference
@@ -64,17 +65,30 @@ module Rigor
         nested_templates = collect_nested_class_templates(plugin_registry)
         return SyntheticMethodIndex::EMPTY if templates.empty? && registries.empty? && nested_templates.empty?
         # Tier B alone cannot emit without an environment: every trait entry — the direct route and the
-        # concern-re-targeted one — funnels through `module_instance_method_names`, whose first line
-        # answers `[]` for a nil environment. The production pre-pass passes `environment: nil` (#476),
-        # so a project whose only contributing plugin registers trait registries (rigor-devise on a
-        # Rails app) would otherwise pay a whole-project parse to build a provably empty index. This
-        # gate mirrors that nil guard and MUST be removed in the change that threads a real environment.
+        # concern-re-targeted one — funnels through `module_instance_method_names`, whose first line answers `[]`
+        # for a nil environment. The production pre-pass hands Tier B a (lazy) environment since #476, so this
+        # gate now guards the direct callers that pass none (a spec, a probe): a registry-only scan with
+        # no environment would otherwise pay a whole-project parse to build a provably empty index. It mirrors
+        # that nil guard and goes with it.
         return SyntheticMethodIndex::EMPTY if environment.nil? && templates.empty? && nested_templates.empty?
 
-        asts = parse_paths(paths, buffer: buffer)
+        sources = read_sources(paths, buffer: buffer)
+        # With only trait registries contributing, a project that never writes a registry's method name (no
+        # `devise` anywhere) cannot produce an entry: a call node named `devise` needs the text `devise` in its
+        # file. Skip the parse (the dominant cost) then, and the environment build it would have asked for.
+        return SyntheticMethodIndex::EMPTY if templates.empty? && nested_templates.empty? &&
+                                              none_mention_registry_method?(sources, registries)
+
+        asts = parse_sources(sources)
+        entries, class_names = collect_all_entries(asts, templates, registries, nested_templates, environment,
+                                                   fact_store)
+        SyntheticMethodIndex.new(entries: decline_project_declared(entries, asts), class_names: class_names)
+      end
+
+      # The match + emit walk over every parsed file: `[entries, class_names]`.
+      def collect_all_entries(asts, templates, registries, nested_templates, environment, fact_store)
         hierarchy = build_hierarchy(asts)
         concern_index = build_concern_index(asts)
-
         entries = []
         class_names = []
         asts.each do |path, ast|
@@ -88,8 +102,19 @@ module Rigor
           end
           collect_nested_class_entries(entries, class_names, nested_templates, ast, path) unless nested_templates.empty?
         end
+        [entries, class_names]
+      end
 
-        SyntheticMethodIndex.new(entries: entries, class_names: class_names)
+      # PR #2286 review S1 — a Tier B entry whose name the class itself declares, or a project module it includes
+      # or prepends declares, is dropped: Ruby answers that call from the project's member, ahead of the module
+      # the registry included ({ProjectMembers}). Tier C entries (no `origin_module`) are left as they were.
+      def decline_project_declared(entries, asts)
+        return entries unless entries.any? { |entry| entry.provenance[:origin_module] }
+
+        members = ProjectMembers.new(asts)
+        entries.reject do |entry|
+          entry.provenance[:origin_module] && members.declares?(entry.class_name, entry.method_name)
+        end
       end
 
       # Aggregates `(plugin_id, template)` pairs across every plugin's `manifest.heredoc_templates` in registration
@@ -249,16 +274,32 @@ module Rigor
         call_node.arguments&.arguments&.first
       end
 
-      def parse_paths(paths, buffer: nil)
+      # `path => source text` (nil when the file cannot be read), reading an editor buffer's in-flight bytes
+      # for the logical path it is bound to.
+      def read_sources(paths, buffer: nil)
         paths.to_h do |path|
           physical = buffer ? buffer.resolve(path) : path
-          source = File.read(physical)
-          [path, Prism.parse(source, filepath: path).value]
+          [path, File.read(physical)]
         rescue StandardError
           [path, nil]
         end
       end
 
+      def parse_sources(sources)
+        sources.to_h do |path, source|
+          [path, source.nil? ? nil : Prism.parse(source, filepath: path).value]
+        rescue StandardError
+          [path, nil]
+        end
+      end
+
+      def none_mention_registry_method?(sources, registries)
+        names = registries.map { |(_plugin_id, registry)| registry.method_name.to_s }
+        sources.each_value.none? do |source|
+          !source.nil? && names.any? { |name| source.include?(name) }
+        end
+      end
+
       # ADR-16 slice 4 — Concern re-targeting index.
       #
       # Walks every top-level / nested `module M` decl looking for the ActiveSupport::Concern shape:
@@ -534,6 +575,18 @@ module Rigor
       # Returns the Symbol method-name list defined on `module_name`'s RBS instance definition. Empty Array when the
       # module is not in the RBS env (silent skip — the synthetic emit produces nothing rather than fabricating method
       # names).
+      #
+      # RBS builds a module's instance definition over its self types, or over `Object` when it declares none:
+      # `Kernel#puts`, `Object#hash`, the pretty-printer's mixin — and, for `module Devise::Models::X :
+      # ActiveRecord::Base`, every `ActiveRecord::Base` method (`save`, `update`) — appear in its method table
+      # beside its own members. They are not what including the module adds, and synthesising them would answer
+      # the class's own or inherited methods from the module's view of them. A method is kept only when its
+      # defining owner is the module itself or one of the module's own ancestors (its `include` / `prepend`
+      # chain, which `definition.ancestors` lists without the self types or `Object`).
+      #
+      # A non-public method is skipped: the tier answers a call by name, and a private module method answered
+      # for `user.secret` would silence the call Ruby rejects. A definition that carries no owner (the specs'
+      # stubs) keeps every name.
       def module_instance_method_names(module_name, environment)
         return [] if environment.nil?
 
@@ -543,7 +596,14 @@ module Rigor
         definition = loader.instance_definition(module_name)
         return [] if definition.nil?
 
-        definition.methods.keys
+        own_ancestors = nil
+        definition.methods.filter_map do |name, method|
+          next name unless method.respond_to?(:defined_in)
+          next unless method.public?
+
+          own_ancestors ||= definition.ancestors.ancestors.to_set { |ancestor| ancestor.name.to_s }
+          name if own_ancestors.include?(method.defined_in.to_s)
+        end
       rescue StandardError
         []
       end

data/lib/rigor/language_server/buffer_table.rb

@@ -98,6 +98,12 @@ module Rigor
         @dirty.key?(uri)
       end
 
+      # @return true when `uri` is open, its bytes are the ones on disk, and the table holds them faithfully: the
+      #   buffers a whole-project round analysed as they are.
+      def on_disk?(uri)
+        open?(uri) && !dirty?(uri) && !desynchronized?(uri)
+      end
+
       def [](uri)
         @entries[uri]
       end

data/lib/rigor/language_server/diagnostic_publisher.rb

@@ -100,7 +100,8 @@ module Rigor
         publish_batch(eligible)
       end
 
-      # Runs one whole-project save round and publishes to the publish set (#246). Called from `didSave`.
+      # Runs one whole-project save round and publishes to the publish set (#246), then re-publishes each dirty buffer
+      # from its own bytes (ADR-124). Called from `didSave`.
       #
       # Analysis scope is the whole project; the PUBLISH SET is the open buffers that are not dirty, plus the
       # buffer that was just saved. A dirty buffer is excluded because only its own `didChange` analysis has
@@ -117,6 +118,12 @@ module Rigor
         end
       end
 
+      # Re-publishes every open buffer from its own bytes, each through {#publish_for}. Called after the project
+      # context is invalidated (a watched file or the configuration changed): every marker on screen was computed
+      # against the world that is gone, and since ADR-124 a buffer's markers read other files' declarations, so
+      # they can move without the buffer itself changing.
+      def republish_open = @buffer_table.uris.each { |uri| publish_for(uri) }
+
       # Publishes an EMPTY diagnostic array for `uri`. The LSP-spec idiom for "clear inline markers" — called
       # from `didClose` so clients drop stale highlights when the user closes a buffer.
       def publish_empty(uri)
@@ -187,16 +194,20 @@ module Rigor
 
           notify(uri, (by_path[path] || []).filter_map { |diagnostic| to_lsp_diagnostic(diagnostic, path) })
         end
+        republish_dirty
       end
 
+      # The dirty buffers the round may not speak for, re-published from their own bytes (ADR-124). The save that
+      # started the round may have moved a declaration a dirty buffer's markers read across files, and nothing
+      # else re-analyses that buffer until its next change or save. Each goes through {#publish_for}, so the
+      # debouncer and `PublishBatcher` order it against the buffer's own `didChange` publishes: a re-publish run
+      # here, beside them, could land its older bytes' markers after a newer edit's.
+      def republish_dirty = @buffer_table.uris.each { |uri| publish_for(uri) if @buffer_table.dirty?(uri) }
+
       # The URIs this round may speak for: every open buffer whose bytes are the ones on disk. The just-saved
       # URI qualifies by definition (the client wrote it), and is named explicitly so a client that sends
       # `didSave` without a preceding applied `didChange` still refreshes it.
-      def publish_set(saved_uri)
-        ([saved_uri] + @buffer_table.uris).uniq.select do |uri|
-          @buffer_table.open?(uri) && !@buffer_table.dirty?(uri) && !@buffer_table.desynchronized?(uri)
-        end
-      end
+      def publish_set(saved_uri) = ([saved_uri] + @buffer_table.uris).uniq.select { |uri| @buffer_table.on_disk?(uri) }
 
       def run_and_notify(uri, path)
         entry = @buffer_table[uri]
@@ -239,11 +250,13 @@ module Rigor
       def publish_batch(jobs)
         with_tempfiles(jobs) do |bound_jobs|
           bindings = bound_jobs.map { |job| job.fetch(:binding) }
+          @project_context.prepare_discovery_seed
           dispatcher = Analysis::Runner::BufferPoolDispatcher.new(
             configuration: @project_context.configuration,
             cache_store: @project_context.cache_store,
             environment: @project_context.environment,
             prebuilt: @project_context.project_scan,
+            discovery_seed_for: @project_context.method(:discovery_seed_for),
             workers: worker_count
           )
           diagnostics_per_binding = dispatcher.analyze(bindings)
@@ -282,6 +295,7 @@ module Rigor
             collect_stats: false,
             buffer: binding,
             prebuilt: @project_context.project_scan,
+            discovery_seed: @project_context.discovery_seed_for(binding),
             environment: @project_context.environment
           )
           result = runner.run([path])

data/lib/rigor/language_server/project_context.rb

@@ -7,6 +7,8 @@ require_relative "../analysis/runner"
 require_relative "../analysis/incremental_session"
 require_relative "../cache/incremental_snapshot"
 require_relative "../effects/identity"
+require_relative "../analysis/path_expansion"
+require_relative "../protection/discovery_seed"
 
 module Rigor
   module LanguageServer
@@ -58,6 +60,7 @@ module Rigor
         @primed_key = nil
         @buffer_sources = {}
         @disk_feature_files = nil
+        @disk_sig_names = nil
         @environment_features = nil
         @generation = 0
         @environment = nil
@@ -112,6 +115,31 @@ module Rigor
         @project_scan ||= build_project_scan
       end
 
+      # Issue #2147 — the cross-file discovery tables a per-buffer publish seeds its `Runner` with
+      # (`discovery_seed:`, #260). A `prebuilt:` runner runs no discovery pass of its own, so without them every
+      # class another file declares reads as an external ancestor and a publish answers differently from
+      # `rigor check` over the same tree. The per-file bundles are walked once per generation; each publish
+      # re-folds them with `buffer`'s file re-walked from the buffer's bytes
+      # ({Protection::DiscoverySeed.tables_for_buffer}), so the buffer's own declarations win over its on-disk
+      # ones, and a file whose bytes on disk moved since the bundles were built is re-walked too (its digest no
+      # longer matches).
+      #
+      # The buffer's file is matched by its real path and handed to the fold under the buffer's own spelling: the
+      # binding substitutes bytes only for a path spelled exactly as its logical path (the URI's absolute path),
+      # while the configured paths may be relative (`lib`, the default) or reach the file through a symlink.
+      def discovery_seed_for(buffer)
+        Protection::DiscoverySeed.tables_for_buffer(paths: discovery_paths_for(buffer), bundles: discovery_bundles,
+                                                    buffer: buffer, constant_sources: true)
+      end
+
+      # Builds what {#discovery_seed_for} reads once per generation, so a fork batch's children inherit it instead
+      # of each walking the project.
+      def prepare_discovery_seed
+        discovery_bundles
+        discovery_real_paths
+        nil
+      end
+
       # Whole-project diagnostics for one save round (#246). The first call primes an in-process
       # {Analysis::IncrementalSession} — seeded from the on-disk snapshot a terminal
       # `rigor check --incremental` may have left, and otherwise from a full baseline; every later call is a
@@ -168,9 +196,14 @@ module Rigor
       # file.
       def required_features
         disk = (@disk_feature_files ||= Environment::RequiredFeatures.feature_files(@configuration))
-        found = disk.reject { |path, _| @buffer_sources.key?(path) }.values.flatten
-        found += @buffer_sources.values.flat_map { |source| Environment::RequiredFeatures.features_of(source) }
-        found.uniq.sort.freeze
+        scanned = disk.reject { |path, _| @buffer_sources.key?(path) }.values
+        scanned += @buffer_sources.values.map { |source| Environment::RequiredFeatures.scan_source(source) }
+        features = scanned.flat_map(&:first).uniq
+        names = scanned.flat_map(&:last).to_set
+        names.merge(@disk_sig_names ||= Environment::RequiredFeatures.sig_names(
+          Environment::RequiredFeatures.configured_sig_paths(@configuration)
+        ))
+        Environment::RequiredFeatures.relevant(features, names).sort.freeze
       end
 
       # Drops every cached collaborator and bumps the generation. The next reader rebuilds from scratch.
@@ -188,7 +221,11 @@ module Rigor
         @environment = nil
         @environment_features = nil
         @disk_feature_files = nil
+        @disk_sig_names = nil
         @project_scan = nil
+        @discovery_paths = nil
+        @discovery_real_paths = nil
+        @discovery_bundles = nil
         # The session's per-file cache was computed against the old environment / project scan, so it cannot
         # outlive them. The next save round primes a fresh one.
         @incremental_session = nil
@@ -230,6 +267,25 @@ module Rigor
         )
       end
 
+      # The configured project files, expanded as `rigor check` expands its configured paths.
+      def discovery_paths
+        @discovery_paths ||= Analysis::PathExpansion.configured_files(@configuration).freeze
+      end
+
+      # Every entry that reaches the buffer's file is respelled, so a file configured under two roots (`lib` and a
+      # symlink to it) is not folded from disk through the second.
+      def discovery_paths_for(buffer)
+        Protection::DiscoverySeed.respell_for_buffer(discovery_paths, buffer, real_paths: discovery_real_paths)
+      end
+
+      def discovery_real_paths
+        @discovery_real_paths ||= discovery_paths.map { |path| Rigor::Analysis::BufferBinding.real_path(path) }.freeze
+      end
+
+      def discovery_bundles
+        @discovery_bundles ||= Protection::DiscoverySeed.bundles(paths: discovery_paths)
+      end
+
       def build_project_scan
         runner = Analysis::Runner.new(
           configuration: @configuration,

data/lib/rigor/language_server/server.rb

@@ -282,11 +282,12 @@ module Rigor
       end
 
       # workspace/didChangeWatchedFiles NOTIFICATION. Invalidates the ProjectContext so cached pre-pass /
-      # Environment is rebuilt on the next request. Slice 7's floor: any watched file change triggers a full
-      # context rebuild. Per-file surgical invalidation (per design doc § "Project context refresh") is a
-      # follow-up; this is the LSP-correct floor.
+      # Environment is rebuilt on the next request, and re-publishes the open buffers against the new world
+      # (ADR-124). Slice 7's floor: any watched file change triggers a full context rebuild. Per-file surgical
+      # invalidation (per design doc § "Project context refresh") is a follow-up; this is the LSP-correct floor.
       def handle_did_change_watched_files(_params)
         @project_context&.invalidate!
+        @publisher&.republish_open
         nil
       end
 
@@ -295,6 +296,7 @@ module Rigor
       # (.rigor.yml / Gemfile.lock / etc).
       def handle_did_change_configuration(_params)
         @project_context&.invalidate!
+        @publisher&.republish_open
         nil
       end
 

data/lib/rigor/mcp/server.rb

@@ -235,7 +235,7 @@ module Rigor
       end
 
       def build_argv(name, args) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize,Metrics/PerceivedComplexity
-        effective_config = args["config"] || @config_path
+        effective_config = present_config(args["config"]) || @config_path
 
         case name
         when "rigor_check"
@@ -290,6 +290,14 @@ module Rigor
         end
       end
 
+      # A per-call `config` that is blank names no file, so the session default applies rather than `--config=`
+      # reaching the CLI as an empty path (which the CLI refuses).
+      def present_config(value)
+        return value unless value.is_a?(String) && value.strip.empty?
+
+        nil
+      end
+
       def success(id, result)
         { "jsonrpc" => "2.0", "id" => id, "result" => result }
       end

data/lib/rigor/plugin/base.rb

@@ -8,6 +8,7 @@ require "prism"
 require_relative "manifest"
 require_relative "node_context"
 require_relative "../analysis/diagnostic"
+require_relative "../analysis/run_disclosure_credit"
 require_relative "../cache/engine_source"
 # `producer generation_cap:` defaults to (and validates against) `Cache::Store::UNBOUNDED_GENERATIONS`, and a
 # plugin class body can be evaluated before anything else pulled the cache layer in.
@@ -780,11 +781,12 @@ module Rigor
       # that differs between workers.
       def disclose_once(key, message:, severity: :info, rule: "load-error")
         id = key.to_s
-        return nil if run_registration_taken?(id, batch: false)
-
-        @run_disclosures[id] = {
-          key: id, message: message.to_s, severity: severity.to_sym, rule: rule.to_s
-        }.freeze
+        unless run_registration_taken?(id, batch: false)
+          @run_disclosures[id] = {
+            key: id, message: message.to_s, severity: severity.to_sym, rule: rule.to_s
+          }.freeze
+        end
+        attribute_run_registration(id)
         nil
       end
 
@@ -816,14 +818,15 @@ module Rigor
       # raises `ArgumentError`, which the engine reports as this plugin's `runtime-error`.
       def emit_once(key, diagnostics)
         id = key.to_s
-        return nil if run_registration_taken?(id, batch: true)
-
-        batch = Array(diagnostics).map do |row|
-          next row.dup.freeze if row.is_a?(Rigor::Analysis::Diagnostic)
+        unless run_registration_taken?(id, batch: true)
+          batch = Array(diagnostics).map do |row|
+            next row.dup.freeze if row.is_a?(Rigor::Analysis::Diagnostic)
 
-          raise ArgumentError, "emit_once expects Rigor::Analysis::Diagnostic rows, got #{row.class}"
+            raise ArgumentError, "emit_once expects Rigor::Analysis::Diagnostic rows, got #{row.class}"
+          end
+          @run_disclosures[id] = { key: id, diagnostics: batch.freeze }.freeze
         end
-        @run_disclosures[id] = { key: id, diagnostics: batch.freeze }.freeze
+        attribute_run_registration(id)
         nil
       end
 
@@ -847,6 +850,18 @@ module Rigor
       end
       private :run_registration_taken?
 
+      # Issue #2020 — hands every call, a repeat of a key already registered included, to the engine's per-file
+      # attribution ({Analysis::RunDisclosureCredit}), so an `--incremental` recheck can replay the row for a file
+      # it serves from cache. A repeat counts because a discloser memoises the input its notice is about and
+      # re-registers the notice from each file's hook. A batch registered empty adds nothing to replay.
+      def attribute_run_registration(id)
+        record = @run_disclosures[id]
+        return if record.nil? || record[:diagnostics]&.empty?
+
+        Analysis::RunDisclosureCredit.attribute(self, record)
+      end
+      private :attribute_run_registration
+
       # Boilerplate-reduction helper (review §1.3): the "did you mean …?" suggestion every
       # diagnostic-emitting plugin otherwise hand-rolls. Returns the closest of `candidates` to `name` via
       # `DidYouMean::SpellChecker` (the same engine Ruby's own `NoMethodError` hints use), or `nil` when