rigortype 0.4.3 → 0.4.5

data/lib/rigor/analysis/incremental_run_slot/write_guard.rb

@@ -7,6 +7,7 @@ require_relative "../incremental_run_slot"
 require_relative "../dependency_source_inference/gem_resolver"
 require_relative "../../cache/file_digest"
 require_relative "../../cache/incremental_snapshot"
+require_relative "../../rooted_glob"
 
 module Rigor
   module Analysis
@@ -66,8 +67,8 @@ module Rigor
         # opted-in gems' resolved versions, the key's one input that is neither a file nor the configuration (issue
         # #1814), are read at the mark and watched the same way.
         #
-        # The mark also records which of the paths an existence row can name are present: the lockfiles, the
-        # analysis roots, the `pre_eval:` entries and the signature roots.
+        # The mark also records what each path a presence row can name is ({Cache::Descriptor::FileEntry.kind_of}):
+        # the lockfiles, the analysis roots, the `pre_eval:` entries and the signature roots.
         def self.start(configuration:, roots:, cache_root:, fingerprint:)
           return nil if Gem.win_platform?
 
@@ -79,7 +80,7 @@ module Rigor
           lockfiles = lockfile_paths(configuration)
           named = Array(roots) + configuration.pre_eval + (configuration.signature_paths || ["sig"])
           presence = (lockfiles + named.map { |path| File.absolute_path(path.to_s) }).to_h do |path|
-            [path, File.exist?(path)]
+            [path, Cache::Descriptor::FileEntry.kind_of(path)]
           end
           rows = dependency_rows(configuration)
           return nil if rows.nil?
@@ -174,11 +175,12 @@ module Rigor
         # - no lockfile the key or the fingerprint digests was written, created or removed, and no opted-in gem
         #   resolves to another version than at the mark (issue #1814);
         # - no file `rows` or `pinned` names changed. A content row's file changed if its change time moved. An
-        #   existence row asks only whether its path is there, so a path the mark recorded changed if it came or
-        #   went, and an editor's lock file created and removed beside it, which moves its directory's change
-        #   time, does not count. That needs no clock, so it holds on any filesystem; it cannot see a path that
-        #   comes and goes again within the run. Any other existence row falls back to change times: its own when
-        #   present, its nearest existing ancestor's when absent;
+        #   existence row asks only whether its path is there, and a `:kind` row what it is (#1977), so a path the
+        #   mark recorded changed if it came or went, or for a kind row turned from a directory into a file or back;
+        #   an editor's lock file created and removed beside it, which moves its directory's change time, does not
+        #   count. That needs no clock, so it holds on any filesystem; it cannot see a path that comes and goes
+        #   again within the run. Any other presence row falls back to change times: its own when present, its
+        #   nearest existing ancestor's when absent;
         # - no directory a glob row lists gained or lost an entry, nor, for a stat-mode glob, did any file it
         #   matches change.
         #
@@ -231,15 +233,20 @@ module Rigor
           ns.nil? || device != @device || ns < @started_ns
         end
 
-        # An existence row and a content row for one path are different questions (the first asks only whether it
-        # is there, the second whether it changed), so the row that comes first must not hide the other.
+        # A presence row and a content row for one path are different questions (the first asks only whether it
+        # is there, or what it is, the second whether it changed), so the row that comes first must not hide the
+        # other; nor may an existence row hide a kind row.
+        PRESENCE_COMPARATORS = %i[exists kind].freeze
+        private_constant :PRESENCE_COMPARATORS
+
         def files_unchanged?(entries, strict:)
           seen = Set.new
           entries.none? do |entry|
-            next false unless seen.add?([entry.path, entry.comparator == :exists])
+            presence = PRESENCE_COMPARATORS.include?(entry.comparator) ? entry.comparator : nil
+            next false unless seen.add?([entry.path, presence])
 
-            if entry.comparator == :exists
-              existence_changed?(entry.path, strict: strict)
+            if presence
+              presence_changed?(entry.path, presence, strict: strict)
             else
               changed?(entry.path, strict: strict)
             end
@@ -248,8 +255,8 @@ module Rigor
 
         def globs_unchanged?(entries, strict:)
           entries.none? do |entry|
-            listed = Dir.glob(File.join(entry.root, File.dirname(entry.pattern), ""))
-            matched = entry.mode == :stat ? Dir.glob(File.join(entry.root, entry.pattern)) : []
+            listed = RootedGlob.glob(entry.root, File.join(File.dirname(entry.pattern), ""))
+            matched = entry.mode == :stat ? RootedGlob.glob(entry.root, entry.pattern) : []
             (listed + matched).any? { |path| changed?(path, strict: strict) }
           end
         end
@@ -257,14 +264,25 @@ module Rigor
         # A lockfile is read for its bytes: one absent at the mark must still be absent, one present must still be
         # there with its change time before the mark.
         def lockfile_changed?(path)
-          return File.exist?(path) unless @presence[path]
+          return File.exist?(path) unless present_at_mark?(path)
 
           changed?(path, strict: true, missing: true)
         end
 
-        def existence_changed?(path, strict:)
+        def present_at_mark?(path)
+          kind = @presence[path]
+          !kind.nil? && kind != Cache::Descriptor::FileEntry::KIND_ABSENT
+        end
+
+        # `comparator` is `:exists` or `:kind`: whether the path came or went, or whether it is no longer the kind
+        # of thing the mark recorded.
+        def presence_changed?(path, comparator, strict:)
           absolute = File.absolute_path(path)
-          return File.exist?(absolute) != @presence[absolute] if @presence.key?(absolute)
+          if @presence.key?(absolute)
+            return File.exist?(absolute) != present_at_mark?(absolute) if comparator == :exists
+
+            return Cache::Descriptor::FileEntry.kind_of(absolute) != @presence[absolute]
+          end
 
           nearest = absolute
           nearest = File.dirname(nearest) until File.exist?(nearest) || File.dirname(nearest) == nearest

data/lib/rigor/analysis/incremental_session.rb

@@ -38,11 +38,21 @@ module Rigor
       # gate) can report what was re-analyzed versus served from cache. `added` / `removed` carry the
       # structural delta so {#run_incremental} (ADR-87 WD3) can recognise a zero-change recheck and skip the
       # unconditional snapshot rewrite.
-      Recheck = Data.define(:diagnostics, :changed, :added, :removed, :affected, :reused, :templates) do
-        # A recheck that changed, added, and removed nothing — the session state is byte-equivalent to the
-        # snapshot that was restored, so persisting it again would only rewrite identical bytes.
+      # `rebaselined` (#1898) is true when the recheck found its served effect collections stale and answered with a
+      # full baseline instead; see {#rebaseline_recheck}.
+      # `stale_readers` (#1553) are the files the recheck re-analysed because a plugin read one of them made went
+      # stale ({#plugin_read_affected}).
+      Recheck = Data.define(:diagnostics, :changed, :added, :removed, :affected, :reused, :templates, :rebaselined,
+                            :stale_readers) do
+        def initialize(rebaselined: false, stale_readers: Set.new, **rest)
+          super
+        end
+
+        # A recheck that changed, added, and removed nothing, and found no stale plugin read — the session state is
+        # byte-equivalent to the snapshot that was restored, so persisting it again would only rewrite identical
+        # bytes. A stale reader's refreshed rows differ (#1553): unsaved, every later run would re-analyse it.
         def no_change?
-          changed.empty? && added.empty? && removed.empty?
+          changed.empty? && added.empty? && removed.empty? && stale_readers.empty?
         end
       end
 
@@ -93,6 +103,9 @@ module Rigor
         @cache = {}              # analyzed path => [Diagnostic]
         @sources = {}            # analyzed path => Set<source path it read from>
         @digests = {}            # analyzed path => ADR-87 packed stat-digest entry at last analysis
+        # Issue #1583 — discovered-not-analysed path => the same packed entry, for a run over path arguments that
+        # #684 widened to the configured `paths:`. Empty on every run over the configured paths.
+        @discovery_digests = {}
         @analyzed = []           # the project files analyzed last round
         @dependents = {}         # inverted @sources (file-level)
         # ADR-46 slice 4 — symbol-granularity tracking.
@@ -122,6 +135,10 @@ module Rigor
         # and a missing invalidation edge is impossible by construction — the reason this is a table diff
         # and not the caller→callee edge recording #204 first sketched.
         @param_table = {}
+        # Issue #1553 — analysed path => the plugin reads ({Plugin::IoBoundary.attributing}) its last analysis made:
+        # the frozen `Cache::Descriptor::FileEntry` / `GlobEntry` rows, as each read observed its input. A recheck
+        # re-analyses every file one of whose rows no longer validates ({#plugin_read_affected}).
+        @plugin_reads = {}
         reset_carried_state
         # ADR-88 WD1 — the plugin fact-surface digest computed for THIS invocation (nil until a
         # `#run_incremental` pass runs / a plugin-free project) and the reporting flags a caller (the CLI
@@ -145,6 +162,49 @@ module Rigor
         current_files
       end
 
+      # Issue #1583 (and #1560) — whether a file the run discovers but does not analyse was edited, added or
+      # removed since the snapshot. Such a file feeds the cross-file index the analysed files resolve against
+      # (a constant, a method, an ancestor), but no recorded edge or digest of the analysed set sees it move.
+      # A move re-baselines the session: discovery-only files are not tracked per symbol, so the closure
+      # cannot be narrowed, and the full analysis is over the argument set alone. A session over the
+      # configured `paths:` discovers nothing beyond what it analyses and pays nothing here.
+      def discovery_moved?
+        current = current_discovery_only_files
+        return true unless current.size == @discovery_digests.size
+
+        current.any? do |path|
+          entry = @discovery_digests[path]
+          entry.nil? || !Cache::FileDigest.stat_fresh?(path, entry)
+        end
+      rescue StandardError
+        true
+      end
+
+      # A baseline's freshness entries: each analysed file's, and (issue #1583) each discovered-not-analysed file's.
+      def record_baseline_digests
+        @digests = @analyzed.to_h { |path| [path, pack_digest(path)] }
+        @discovery_digests = current_discovery_only_files.to_h { |path| [path, pack_digest(path)] }
+        forget_unbound_digests
+      end
+
+      def restore_digests(payload)
+        @digests = payload.digests
+        @discovery_digests = payload.discovery_digests # Issue #1583 — `{}` in a payload built without it.
+      end
+
+      # Issue #1583 — the discovered-not-analysed files of a run over this session's paths
+      # ({Runner#discovery_only_file_set}). Asked of a runner WITHOUT the editor buffer: a buffered run does not
+      # widen, so a buffered session (editor mode option B, #146) would read an empty set against the snapshot's
+      # and re-baseline on every keystroke. Globbing without it keeps the comparison the one the snapshot's
+      # writer made, so a sibling edit still declines option B and an unchanged project still serves it.
+      def current_discovery_only_files
+        return [] if @paths.nil?
+
+        Runner.new(configuration: @configuration, cache_store: nil, environment: @environment)
+              .discovery_only_file_set(@paths)
+      end
+      private :discovery_moved?, :record_baseline_digests, :restore_digests, :current_discovery_only_files
+
       # The per-file discovery bundles of the last run, keyed by path (ADR-85 WD2).
       attr_reader :seed_bundles
 
@@ -208,9 +268,10 @@ module Rigor
         # ADR-103 WD13 / #382 — a baseline collects every file, so its collections are the whole world.
         @effect_collections = runner.effect_collections_by_path
         @effects_identity = current_effects_identity
+        @effect_plugin_digest = effect_plugin_digest_of(runner)
         @cache = per_file(runner.per_file_diagnostics)
-        @digests = @analyzed.to_h { |path| [path, pack_digest(path)] }
-        forget_unbound_digests
+        @plugin_reads = plugin_reads_of(runner, @analyzed)
+        record_baseline_digests
         @run_level_rows = runner.run_level_rows
         diagnostics
       end
@@ -224,6 +285,8 @@ module Rigor
         added = current - previous
         removed = previous - current
         changed = changed_paths(current & previous)
+        return rebaseline_recheck(changed, added, removed) if discovery_moved?
+
         # ADR-67 WD6c lift — recompute the whole-project inferred-param table BEFORE deciding the closure,
         # and diff it against the snapshot's copy: an entry that moved (because a caller's argument type
         # changed, a caller appeared, or one vanished) invalidates the CALLEE's file and its symbol
@@ -238,15 +301,14 @@ module Rigor
         # go in too, so the runner lists them in the full run's file order (#1524).
         runner = build_runner(analyze_only: analyze_set, record_dependencies: true,
                               param_inferred_types: fresh_params, **forced_target_options(forced),
-                              restored_run_level_rows: @run_level_rows,
-                              served_per_file_diagnostics: @cache.slice(*reused))
+                              restored_run_level_rows: @run_level_rows, **served_state(reused))
         merged = run_runner(runner).diagnostics
-        @last_runner = runner # ADR-88 WD1 — the post-hoc fact-surface fingerprint reads this prepared registry.
+        return rebaseline_recheck(changed, added, removed) if served_effects_stale?(runner, reused)
+
         absorb(runner, current, analyze_set, removed)
         @param_table = fresh_params
-        Recheck.new(diagnostics: merged, changed: changed.to_set, added: added.to_set,
-                    removed: removed.to_set, affected: affected, reused: reused.to_set,
-                    templates: runner.template_unit_paths.size)
+        recheck_result(merged, [changed, added, removed], affected: affected, reused: reused.to_set, runner: runner,
+                                                          stale_readers: @stale_plugin_readers)
       end
 
       # Editor mode option B (#146) — a whole-project recheck with the editor's buffer substituted for one
@@ -271,6 +333,9 @@ module Rigor
           # latency this mode exists to avoid, so decline and let the caller drop to single-file scope.
           break nil unless @plugin_fact_reusable.reusable_against?(restored.plugin_fact_digest)
           break nil if source_rbs_unverified?(result)
+          # #1898 — a recheck that re-baselined over stale plugin effect facts ran its baseline with the buffer set,
+          # which analyses the buffer alone, so it is not a whole-project answer. Decline, as above.
+          break nil if result.rebaselined
 
           result
         end
@@ -296,9 +361,10 @@ module Rigor
       # records none at all), so no dependent set can bound who read it. An edit that moved it re-analyses the
       # whole project — what a `sig/` edit already costs through the snapshot fingerprint.
       def affected_closure(changed, added, removed, param_files = Set.new, param_pairs = Set.new)
+        @stale_plugin_readers = plugin_read_affected
         return whole_project_closure(changed, added) if source_rbs_gate.moved?(@seed_bundles, changed, added, removed)
 
-        gated_closure(changed, added, removed, param_files, param_pairs)
+        (gated_closure(changed, added, removed, param_files, param_pairs) | @stale_plugin_readers).freeze
       end
 
       # {#affected_closure} for an edit whose synthesized RBS is byte-identical in every file it touched.
@@ -342,6 +408,65 @@ module Rigor
         closure.freeze
       end
 
+      # Issue #1553 — every analysed file whose last analysis made a plugin read that no longer validates: a file
+      # read through {Plugin::IoBoundary#read_file} or probed through `#file?` / `#directory?` was edited,
+      # removed, or created after a read that found it absent, or a `#list_directory` / `#glob` listing moved.
+      # The ADR-46 edges record type and declaration reads only, so none of these moves a reader into the
+      # closure, and its cached rows were computed from the input as it was. The reader's own text is unchanged,
+      # so it joins the closure alone: a plugin read made while analysing a dependent is credited to that
+      # dependent. Each distinct row is validated once however many files made it (one `File.stat` for a
+      # content row whose stat tuple did not move, one re-glob for a listing row).
+      def plugin_read_affected
+        verdicts = {}
+        @plugin_reads.each_with_object(Set.new) do |(path, rows), stale|
+          next unless rows.any? { |row| !verdicts.fetch(row) { verdicts[row] = plugin_read_fresh?(row) } }
+
+          stale << path
+        end
+      end
+
+      def plugin_read_fresh?(row)
+        if row.is_a?(Cache::Descriptor::GlobEntry)
+          Cache::Descriptor::GlobEntry.fresh?(row)
+        else
+          Cache::Descriptor.new(files: [row]).fresh?
+        end
+      end
+
+      # Issue #1553 — `runner`'s per-file plugin reads for `paths`, each file's rows de-duplicated and frozen.
+      def plugin_reads_of(runner, paths)
+        runner.analysis_reads.slice(*paths).transform_values { |rows| rows.uniq.freeze }
+      end
+
+      # Issue #1906 — a file that rewrites a constant's singleton names without declaring it
+      # (`D.singleton_class.alias_method :own, :keep`, or, since #1941, `def D.own`) contributes opaque singleton
+      # envelopes to the constant's bucket, but a reader's class edge names only the files that declared the constant
+      # when the reader last ran, and the class-declaration diff does not move while the constant stays in the file
+      # (`:own` becoming `:keep`, or the call becoming a `class D` reopening). So a declaration-unstable edit to such a
+      # file fires `class:<last segment>` for each constant that, before the edit, both sat in the file's
+      # singleton-source set and held a singleton envelope entry or an unpositioned singleton side the file recorded (a
+      # computed name there leaves the side unpositioned, and becoming literal reads it again). A file that only
+      # includes into a constant (`ActiveRecord::Base.include(X)`) records neither and fires nothing. A constant the
+      # edit makes the file rewrite needs no key: the class-declaration diff fires if it is new to the file, and the
+      # reader's class edge names the file if the file declared it.
+      def singleton_rewrite_affected(unstable)
+        names = unstable.flat_map { |path| singleton_rewritten_constants(@seed_bundles[path]) }.uniq
+        return Set.new if names.empty?
+
+        Incremental.negative_closure(names.map { |name| "class:#{name.split('::').last}" }, @negative_dependents)
+      end
+
+      def singleton_rewritten_constants(bundle)
+        return [] if bundle.nil?
+
+        envelopes = bundle[:parameter_envelopes] || {}
+        unpositioned = bundle[:unpositioned_mixins] || {}
+        (bundle[:singleton_class_source_names] || []).select do |name|
+          (envelopes[name] || {}).each_key.any? { |key| key.is_a?(Array) && key.first == :singleton } ||
+            unpositioned.dig(name, :extend)
+        end
+      end
+
       # Issue #1367 — every file whose last result holds a `global.*` diagnostic re-checks on any recheck. What
       # exempts such a write is a fact of the whole program — an alias, or a `write` / `to_str` / `to_int` / hatch
       # defined in any spelling on any receiver, a rewritten ancestor, a mixin — which no name-keyed edge can
@@ -365,13 +490,15 @@ module Rigor
 
       # The dependents contributed by the declaration-unstable changed files and the behaviourally-unstable
       # symbol pairs: the ADR-46 slice-4 symbol-granular fan-out when either is present (ancestry deps of the
-      # unstable files + symbol deps of the changed pairs), else the coarse file-level fan-out.
+      # unstable files + symbol deps of the changed pairs), else the coarse file-level fan-out; plus the readers of
+      # the constants an unstable file rewrote from outside their bodies ({#singleton_rewrite_affected}).
       def dependents_base(unstable, symbol_pairs)
-        if symbol_pairs.any? || unstable.any? { |f| @ancestry_dependents[f] }
-          Incremental.affected_with_symbols(unstable, symbol_pairs, @symbol_dependents, @ancestry_dependents)
-        else
-          Incremental.affected(unstable, @dependents)
-        end
+        base = if symbol_pairs.any? || unstable.any? { |f| @ancestry_dependents[f] }
+                 Incremental.affected_with_symbols(unstable, symbol_pairs, @symbol_dependents, @ancestry_dependents)
+               else
+                 Incremental.affected(unstable, @dependents)
+               end
+        base | singleton_rewrite_affected(unstable)
       end
 
       # ADR-67 WD6c lift — the fresh whole-project inferred-param table for this recheck ({} when the gate
@@ -466,7 +593,7 @@ module Rigor
       def whole_project_closure(changed, added)
         (@analyzed.to_set | changed | added).freeze
       end
-      private :gated_closure, :whole_project_closure
+      private :gated_closure, :whole_project_closure, :singleton_rewrite_affected, :singleton_rewritten_constants
 
       # The current project file set (cheap directory expansion, no analysis), used to detect files added /
       # removed since the last run. Also where an editor buffer's binding is re-spelled onto the set, since
@@ -489,8 +616,7 @@ module Rigor
         # ADR-67 WD6c lift — seed the subset run from the baseline's own table so the verification engine
         # exercises the exact seeds the served cache entries were computed under (and skips a re-collect).
         runner = build_runner(analyze_only: affected, param_inferred_types: @param_table,
-                              restored_run_level_rows: @run_level_rows,
-                              served_per_file_diagnostics: @cache.slice(*reused))
+                              restored_run_level_rows: @run_level_rows, **served_state(reused))
         run_runner(runner).diagnostics
       end
 
@@ -534,7 +660,7 @@ module Rigor
             result = recheck
             adopt_plugin_fact_fingerprint
             fact_reusable = @plugin_fact_reusable.reusable_against?(restored.plugin_fact_digest)
-            if fact_reusable && effects_reusable && !source_rbs_unverified?(result)
+            if fact_reusable && effects_reusable && !result.rebaselined && !source_rbs_unverified?(result)
               diagnostics = keep_recheck(result)
               warm = true
               # ADR-87 WD3 — a warm recheck that changed nothing leaves the session state byte-equivalent to the
@@ -549,7 +675,8 @@ module Rigor
               # digest (from the recheck runner) is unchanged by the re-analysis, so it is kept for the save.
               # Only a genuine fact-surface reason sets the reporting flag the CLI banner reads.
               @fact_surface_invalidated = true unless fact_reusable
-              diagnostics = baseline
+              # #1898 — a recheck that already re-baselined over stale plugin effect facts is that re-analysis.
+              diagnostics = result.rebaselined ? result.diagnostics : baseline
               warm = false
               skip_save = false
             end
@@ -630,7 +757,7 @@ module Rigor
       # the gate could not see. {#run_incremental} re-analyses the project and {#run_buffer_recheck} declines,
       # the way each treats a moved plugin fact surface. A run that changed nothing is exempt: under an
       # untrusted gate every earlier edit already re-analysed the whole project, so the snapshot it serves is
-      # whole, and a null run stays one.
+      # whole, and a null run stays one. A recheck that found a stale plugin read (#1553) is a change.
       def source_rbs_unverified?(result)
         source_rbs_gate.untrusted? && !result.no_change? && !result.reused.empty?
       end
@@ -850,7 +977,7 @@ module Rigor
         @analyzed = payload.analyzed
         @cache = payload.cache
         @sources = payload.sources
-        @digests = payload.digests
+        restore_digests(payload)
         # ADR-85 WD2 — restore the per-file discovery bundles if present (absent in a pre-#85 snapshot → empty,
         # so the recheck's discovery re-walks every file: a cold-quality index, always sound). The SCHEMA bump
         # makes a genuinely stale-shaped bundle unreadable rather than mis-folded.
@@ -864,6 +991,7 @@ module Rigor
         restore_structural_declarations(payload)
         @return_summaries  = payload.return_summaries || {}
         @param_table       = payload.param_table || {} # ADR-67 WD6c lift — the seeds the cache was built under.
+        @plugin_reads      = payload.plugin_reads # Issue #1553 — `{}` in a payload built without it.
         # Issues #796 / #794 — absent (nil) in a snapshot written before schema 22 is impossible (the SCHEMA
         # gate rejects one), so nil here means the writing run genuinely had nothing to say.
         @run_level_rows    = payload.run_level_rows
@@ -873,6 +1001,7 @@ module Rigor
         # a partial re-collection cannot be closed into a whole-project fixpoint.
         @effects_identity  = payload.effects_identity
         @effect_collections = effect_collections_reusable?(payload) ? payload.effect_collections.dup : {}
+        @effect_plugin_digest = payload.effect_plugin_digest
         @symbol_dependents = Incremental.invert_symbols(@symbol_sources)
         @ancestry_dependents = Incremental.invert(@ancestry_sources)
         @negative_dependents = Incremental.invert(@missing)
@@ -901,7 +1030,10 @@ module Rigor
           param_table: marshal_safe_param_table,
           effect_collections: marshal_safe_effect_collections,
           effects_identity: @effects_identity,
-          run_level_rows: @run_level_rows
+          run_level_rows: @run_level_rows,
+          effect_plugin_digest: @effect_plugin_digest,
+          plugin_reads: @plugin_reads,
+          discovery_digests: @discovery_digests
         )
       end
 
@@ -913,6 +1045,7 @@ module Rigor
       def reset_effect_state
         @effect_collections = {}
         @effects_identity = nil
+        @effect_plugin_digest = nil
       end
 
       # The state this session carries ACROSS processes in the snapshot rather than deriving each run: the
@@ -1003,6 +1136,7 @@ module Rigor
       # multiple edits: the analyzed set gets fresh diagnostics + digests + dependency edges, removed files
       # are evicted from every map, and the analyzed-file list advances to `current`.
       def absorb(runner, current, analyze_set, removed)
+        @last_runner = runner # ADR-88 WD1 — the post-hoc fact-surface fingerprint reads this prepared registry.
         removed.each { |path| forget(path) }
         @analyzed = current
         # ADR-85 WD2 — the recheck's discovery folded the restored bundles and refreshed them (changed files
@@ -1011,9 +1145,12 @@ module Rigor
         whole_project = current.all? { |path| analyze_set.include?(path) }
         @seed_bundles = source_rbs_gate.stamp(runner.seed_bundles, whole_project: whole_project)
         fresh_by_file = per_file(runner.per_file_diagnostics)
+        # Issue #1553 — a re-analysed file's reads are this run's: a read it no longer makes stops guarding it.
+        fresh_reads = plugin_reads_of(runner, analyze_set)
         analyze_set.each do |path|
           @cache[path] = fresh_by_file[path] || []
           @digests[path] = pack_digest(path)
+          fresh_reads.key?(path) ? @plugin_reads[path] = fresh_reads[path] : @plugin_reads.delete(path)
         end
         forget_unbound_digests
         absorb_dependency_graph(runner)
@@ -1036,6 +1173,7 @@ module Rigor
         @effect_collections.reject! { |path, _| analyzed.include?(path) }
         @effect_collections.merge!(runner.effect_collections_by_path)
         @effects_identity = current_effects_identity
+        @effect_plugin_digest = effect_plugin_digest_of(runner)
       end
 
       # ADR-89 WD2 — replace the behavioural summaries of every re-analyzed file with THIS run's harvest: drop
@@ -1061,6 +1199,7 @@ module Rigor
         @cache.delete(path)
         @digests.delete(path)
         @sources.delete(path)
+        @plugin_reads.delete(path)
         @symbol_sources.delete(path)
         @ancestry_sources.delete(path)
         @missing.delete(path)
@@ -1131,7 +1270,8 @@ module Rigor
       # appeared `"ClassName#method"` to the negative-dependency key it would satisfy (`toplevel:foo` for a
       # top-level def, `method:C#m` otherwise), then unions the recorded negative-dependents of those keys.
       # Issue #1120 — plus the consumers of any refinement name the edit moved ({#refinement_affected}). Issue #1367 —
-      # and every file whose last result holds a `global.*` diagnostic ({#global_write_reporters}).
+      # and every file whose last result holds a `global.*` diagnostic ({#global_write_reporters}). Issue #1459 — and
+      # the consumers of any method name a file started or stopped defining ({#defined_name_affected}).
       def negative_affected(changed, removed, new_fingerprints, new_class_decls, new_constant_decls, summary = nil)
         appeared_methods = Incremental.appeared_symbols(changed, @symbol_fingerprints, new_fingerprints)
         # Issue #639 — a class DISAPPEARING satisfies the `class:` kind too, now that a resolved bare
@@ -1149,9 +1289,55 @@ module Rigor
         keys.concat(class_move_keys(moved_classes))
         keys.concat(moved_constants.map { |name| "constant:#{name.split('::').last}" })
         Incremental.negative_closure(keys, @negative_dependents) | refinement_affected(changed + removed, summary) |
+          defined_name_affected(changed + removed, summary) | mark_affected(changed + removed, summary) |
           global_write_reporters
       end
 
+      # Issue #1833 — the consumers whose answer read a class mark that moved in this edit. A reader of a class's
+      # envelope bucket records `mark:<last segment>` (`Scope#parameter_envelopes_of`), whichever way it answered, so
+      # a file that adds or drops only a mark (`x.singleton_class.prepend(Comparable)`, `o.extend(Helper)` in a
+      # method body, a `refine` block's refined mark) re-checks it although the file declares nothing it read. A
+      # reader that scans every bucket for an object-extended module (`SourceArity#object_extension_may_shadow?`)
+      # records `mark:*`, which fires when an object-extended mark moves. The before-state is each touched file's
+      # seed bundle, the after-state the scan's merged table.
+      #
+      # Issue #1661 — and `mixin:<qualified name>` for a class or module whose unpositioned mixin edges moved
+      # ({Incremental.changed_unpositioned_owners}): an external chain entry records it for each name it can denote
+      # (`ResolutionChain#record_hooks`), so a new file that taints `Comparable` with `include(*MODS)` re-checks the
+      # readers of a chain through it. It is not `mark:`, which a plain reopening of a module moves (the bucket's
+      # module mark) and which would re-check every reader of `Kernel` on any `module Kernel` reopening.
+      def mark_affected(paths, summary)
+        def_index = summary && summary[:def_index]
+        before = paths.map { |path| @seed_bundles.dig(path, :parameter_envelopes) }
+        moved = Incremental.changed_class_marks(before, [def_index && def_index[:parameter_envelopes]])
+        tainted = Incremental.changed_unpositioned_owners(
+          paths.map { |path| @seed_bundles.dig(path, :unpositioned_mixins) },
+          [def_index && def_index[:unpositioned_mixins]]
+        )
+        return Set.new if moved.empty? && tainted.empty?
+
+        keys = moved.map { |(class_name, _mark)| "mark:#{class_name.split('::').last}" }.uniq
+        keys.concat(mixin_keys(tainted))
+        extended = Scope::DiscoveryIndex::ENVELOPE_OBJECT_EXTENDED_MARK
+        keys << "mark:*" if moved.any? { |(_class_name, mark)| mark == extended }
+        Incremental.negative_closure(keys, @negative_dependents)
+      end
+
+      # Issue #1661 — the `mixin:` keys an owner of a moved unpositioned edge fires. The table keys a receiver-form
+      # owner by the spelling written (`class File; Constants.include(*MODS); end` is `"Constants"`), not the constant
+      # Ruby resolves it to, while the chain files the qualified candidate (`mixin:File::Constants`). The table does
+      # not carry the nesting, and every lexical-prefix candidate of the owner ends in `::<owner>`, so the owner fires
+      # its own key and every recorded `mixin:` key ending in `::<owner>`. A relative spelling over-fires to the
+      # readers of every module sharing its trailing segments; a qualified one fires only its suffix matches.
+      def mixin_keys(owners)
+        keys = owners.map { |name| "mixin:#{name}" }
+        suffixes = owners.map { |name| "::#{name}" }
+        @negative_dependents.each_key do |key|
+          keys << key if key.start_with?("mixin:") && suffixes.any? { |suffix| key.end_with?(suffix) }
+        end
+        keys.uniq
+      end
+
       # The negative keys a class-declaration diff fires: `class:<last segment>` for a class name, and (issue #1820)
       # `subclass_of:<last segment of the superclass>` for a `[class, superclass]` pair appearing or vanishing. Any
       # class declaration moving may move the set of classes whose superclass the tables do not know, which
@@ -1177,6 +1363,22 @@ module Rigor
         Incremental.negative_closure(names.map { |name| "refinement:#{name}" }, @negative_dependents)
       end
 
+      # Issue #1459 — the consumers whose answer asked whether the program defines a method name anywhere, for each
+      # name a file in `paths` started or stopped defining. The before-state is each file's seed bundle, the
+      # after-state the scan's per-file name sets. Unlike the appeared-symbol diff, it sees a name an `attr_*`,
+      # `alias` or `define_method` adds, and one that vanishes, which brings a declined reading back.
+      def defined_name_affected(paths, summary)
+        after = (summary && summary[:defined_method_names]) || {}
+        before = paths.to_h do |path|
+          bundle = @seed_bundles[path]
+          [path, bundle && Inference::ScopeIndexer.defined_method_names(bundle)]
+        end
+        names = Incremental.changed_defined_names(paths, before, after)
+        return Set.new if names.empty?
+
+        Incremental.negative_closure(names.map { |name| "defines:#{name}" }, @negative_dependents)
+      end
+
       # The qualified class/module names declared in the pre-parsed `index` (shared with
       # {#symbol_fingerprints_from_index}, so the changed set is parsed once). `{ path => Set<class name> }`.
       def class_declarations_from_index(index)
@@ -1335,6 +1537,46 @@ module Rigor
         [forced, (affected | forced) & current]
       end
 
+      # What the session serves a narrowed run for the files it does not analyse: their cached per-file rows (#1524),
+      # and (#1898) their effect collections, so the run closes its effect graph over the whole project.
+      def served_state(reused)
+        { served_per_file_diagnostics: @cache.slice(*reused),
+          served_effect_collections: @effect_collections.slice(*reused) }
+      end
+
+      # Issue #1898 — the plugin effect-fact digest a run's collections were stamped under. A plugin writes its
+      # attributions and edges into a file's collection when the file is collected, and what it contributes can
+      # follow project state no file digest sees (rigor-activejob reads `config.active_job.queue_adapter`), so a
+      # served collection is current only while this digest is. nil when collection is off.
+      def effect_plugin_digest_of(runner)
+        @configuration.effects_enabled? ? runner.effect_plugin_facts.digest : nil
+      end
+
+      # Whether `runner` judged envelopes over served collections stamped under a different plugin effect-fact
+      # digest, or an unknown one. The comparison waits for the run because the plugins load inside it.
+      def served_effects_stale?(runner, reused)
+        return false if reused.empty? || @effect_collections.empty?
+
+        effect_plugin_digest_of(runner) != @effect_plugin_digest
+      end
+
+      # The answer {#recheck} gives when {#served_effects_stale?}: a full baseline, reported as a recheck that
+      # re-analysed every file. {#run_incremental} reads `rebaselined` so it neither runs a second baseline
+      # nor reports the run as warm.
+      def rebaseline_recheck(changed, added, removed)
+        diagnostics = baseline
+        recheck_result(diagnostics, [changed, added, removed],
+                       affected: @analyzed.to_set, reused: Set.new, runner: @last_runner, rebaselined: true)
+      end
+
+      # A {Recheck} over `deltas` (`[changed, added, removed]`), counting `runner`'s template units.
+      def recheck_result(diagnostics, deltas, affected:, reused:, runner:, rebaselined: false, stale_readers: Set.new)
+        changed, added, removed = deltas.map(&:to_set)
+        Recheck.new(diagnostics: diagnostics, changed: changed, added: added, removed: removed, affected: affected,
+                    stale_readers: stale_readers,
+                    reused: reused, templates: runner.template_unit_paths.size, rebaselined: rebaselined)
+      end
+
       # A recheck that forces targets analyses in this process, so the index callback reaches them.
       def forced_target_options(forced)
         forced.empty? ? {} : { workers: 0 }

data/lib/rigor/analysis/path_expansion.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../rooted_glob"
+
 module Rigor
   module Analysis
     # ADR-87 WD4 — project file-set expansion shared by the {Analysis::Runner} (miss path) and the
@@ -27,7 +29,7 @@ module Rigor
       end
 
       def directory_files(dir, exclude_patterns, base: Dir.pwd)
-        reject_excluded(Dir.glob(File.join(dir, RUBY_GLOB)), exclude_patterns, base: base)
+        reject_excluded(RootedGlob.glob(dir, RUBY_GLOB), exclude_patterns, base: base)
       end
 
       # `exclude_patterns` are matched with `File.fnmatch?` WITHOUT `FNM_PATHNAME`, so `**`/`*` span separators