rigortype 0.1.17 → 0.1.19

data/lib/rigor/sig_gen/observation_collector.rb

@@ -96,7 +96,8 @@ module Rigor
         parse_result = Prism.parse(source, filepath: path, version: @configuration.target_ruby)
         return if parse_result.errors.any?
 
-        base_scope = Scope.empty(environment: environment).with_discovered_classes(discovered_classes)
+        base_scope = Scope.empty(environment: environment)
+        base_scope = base_scope.with_discovery(base_scope.discovery.with(discovered_classes: discovered_classes))
         scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
         bindings = collect_rspec_bindings(parse_result.value, scope_index)
 
@@ -104,11 +105,10 @@ module Rigor
       end
 
       # Pre-walks `@source_paths` to collect every qualified
-      # class / module declaration. The result feeds
-      # `Scope#with_discovered_classes` for each observe-tree
-      # scope so `Foo.new` and `Foo` resolve to the right
-      # singleton carrier even when no RBS sig describes
-      # `Foo` yet.
+      # class / module declaration. The result seeds the
+      # `discovered_classes` table on each observe-tree scope so
+      # `Foo.new` and `Foo` resolve to the right singleton carrier
+      # even when no RBS sig describes `Foo` yet.
       def preindex_source_classes
         accumulator = {}
         resolve_paths(@source_paths).each { |path| harvest_classes_from(path, accumulator) }

data/lib/rigor/source/literals.rb

@@ -100,6 +100,20 @@ module Rigor
         args.filter_map { |arg| symbol_or_string(arg) }
       end
 
+      # Whether a node is a literal `Prism::SymbolNode` that names `name`.
+      # The key-comparison counterpart to {.symbol_name} — for callers
+      # that need a predicate rather than an extraction (hash-key matching
+      # in keyword or assoc argument positions, e.g.
+      # `el.is_a?(AssocNode) && symbol_named?(el.key, "required")`).
+      # Uses `#unescaped` (not `#value`) for round-trip consistency.
+      #
+      # @param node [Prism::Node, nil]
+      # @param name [String]
+      # @return [Boolean]
+      def symbol_named?(node, name)
+        node.is_a?(Prism::SymbolNode) && node.unescaped == name
+      end
+
       # The literal Symbol/String at positional `index`, or `nil` when the
       # call has no argument list, the index is out of range, or the
       # argument there is not a literal Symbol/String.

data/lib/rigor/triage/catalogue.rb

@@ -304,26 +304,11 @@ module Rigor
         m && [m[1], m[2]]
       end
 
-      # Normalises a message receiver token to a class name.
-      # Integer / string / symbol literals fold to their class;
-      # `Foo[...]` keeps the `Array[...]` form (H4 needs it);
-      # `singleton(Foo)` and bare `Foo` fold to `Foo`.
+      # Normalises a message receiver token to a class name. The fold
+      # logic is shared with the selector axis — see
+      # {Triage.normalize_receiver}.
       def receiver_class(token)
-        t = token.strip
-        return "Integer" if t.match?(/\A-?\d+\z/)
-        return "Float"   if t.match?(/\A-?\d+\.\d+\z/)
-        return "String"  if t.start_with?('"', "'")
-        return "Symbol"  if t.start_with?(":")
-
-        singleton = t[/\Asingleton\(([\w:]+)\)\z/, 1]
-        return singleton if singleton
-        return t if t.start_with?("Array[")
-
-        nominal = t[/\A([\w:]+)\[/, 1]
-        return nominal if nominal
-        return t if t.match?(/\A[\w:]+\z/)
-
-        nil
+        Triage.normalize_receiver(token)
       end
 
       def activesupport?(receiver, method)

data/lib/rigor/triage.rb

@@ -18,7 +18,15 @@ module Rigor
     Summary = Data.define(:total, :error, :warning, :info)
     RuleCount = Data.define(:rule, :count)
     Hotspot = Data.define(:file, :count, :by_rule)
-    Report = Data.define(:summary, :distribution, :hotspots, :hints)
+    # A (receiver-class, method) dispatch target the diagnostics
+    # cluster on, built from the structured `Diagnostic#receiver_type`
+    # / `#method_name` fields — never from message-string parsing.
+    # `receiver` is nil for method-only diagnostics (a toplevel call,
+    # a `def`-side return / override finding that has no call
+    # receiver); `files` is the distinct-file count (a systemic vs.
+    # localised signal); `rules` is the per-rule breakdown.
+    Selector = Data.define(:receiver, :method_name, :count, :files, :rules)
+    Report = Data.define(:summary, :distribution, :selectors, :hotspots, :hints)
 
     module_function
 
@@ -30,6 +38,7 @@ module Rigor
       Report.new(
         summary: build_summary(diagnostics),
         distribution: build_distribution(diagnostics),
+        selectors: build_selectors(diagnostics),
         hotspots: build_hotspots(diagnostics, top),
         hints: hints ? Catalogue.recognise(diagnostics) : []
       )
@@ -57,6 +66,61 @@ module Rigor
                  .sort_by { |row| [-row.count, row.rule] }
     end
 
+    # The class/method aggregation axis (ADR-23 follow-up). Groups
+    # every diagnostic that carries a `method_name` by its
+    # `(receiver_type, method_name)` pair so a consumer can answer
+    # "which method / class concentrates the diagnostics?" with a
+    # `jq` query over the JSON instead of parsing message text.
+    # Method-only diagnostics (nil `receiver_type`) keep a null
+    # `receiver` and still group by method. The full list is
+    # returned uncapped — the JSON is the agent-facing surface; the
+    # text renderer caps its own rows.
+    def build_selectors(diagnostics)
+      diagnostics.select(&:method_name)
+                 .group_by { |d| [normalize_receiver(d.receiver_type) || d.receiver_type, d.method_name.to_s] }
+                 .map { |(receiver, method), group| selector_for(receiver, method, group) }
+                 .sort_by { |s| [-s.count, s.receiver.to_s, s.method_name] }
+    end
+
+    # Folds a receiver token — a `Diagnostic#receiver_type` display
+    # string or a message-parsed token — to the class the diagnostics
+    # should bucket under, so the selector axis does not fragment one
+    # method across every distinct literal receiver. String / integer
+    # / float / symbol literals collapse to their class; `singleton(C)`
+    # and a bare `C` fold to `C`; a generic `C[...]` keeps the
+    # `Array[String]` element form (the AR-relation heuristic keys on
+    # it). Returns nil for a token it cannot reduce to a class (a
+    # union display, an inferred shape) — the caller keeps the raw
+    # string then, never losing the row. Shared with {Catalogue}.
+    def normalize_receiver(token)
+      return nil if token.nil?
+
+      t = token.to_s.strip
+      return "Integer" if t.match?(/\A-?\d+\z/)
+      return "Float"   if t.match?(/\A-?\d+\.\d+\z/)
+      return "String"  if t.start_with?('"', "'")
+      return "Symbol"  if t.start_with?(":")
+
+      singleton = t[/\Asingleton\(([\w:]+)\)\z/, 1]
+      return singleton if singleton
+      return t if t.start_with?("Array[")
+
+      nominal = t[/\A([\w:]+)\[/, 1]
+      return nominal if nominal
+      return t if t.match?(/\A[\w:]+\z/)
+
+      nil
+    end
+
+    def selector_for(receiver, method, group)
+      rules = group.group_by { |d| rule_key(d) }
+                   .transform_values(&:size)
+                   .sort_by { |rule, count| [-count, rule] }
+                   .to_h
+      Selector.new(receiver: receiver, method_name: method, count: group.size,
+                   files: group.map(&:path).uniq.size, rules: rules)
+    end
+
     def build_hotspots(diagnostics, top)
       diagnostics.group_by(&:path)
                  .map { |path, group| hotspot_for(path, group) }
@@ -79,6 +143,10 @@ module Rigor
           "warning" => report.summary.warning, "info" => report.summary.info
         },
         "distribution" => report.distribution.map { |r| { "rule" => r.rule, "count" => r.count } },
+        "selectors" => report.selectors.map do |s|
+          { "receiver" => s.receiver, "method" => s.method_name, "count" => s.count,
+            "files" => s.files, "rules" => s.rules }
+        end,
         "hotspots" => report.hotspots.map do |h|
           { "file" => h.file, "count" => h.count, "by_rule" => h.by_rule }
         end,

data/lib/rigor/type/combinator.rb

@@ -17,6 +17,7 @@ require_relative "refined"
 require_relative "intersection"
 require_relative "bound_method"
 require_relative "../inference/budget_trace"
+require_relative "../inference/flow_tracer"
 
 module Rigor
   module Type
@@ -79,6 +80,35 @@ module Rigor
         Constant.new(value)
       end
 
+      # Widens every value-pinned (`Constant`) constituent of `type` to its
+      # nominal base (`Constant[1]` -> `Nominal["Integer"]`), recursing
+      # through unions and leaving non-pinned constituents untouched.
+      # `Constant[nil]` is preserved (no nominal base of interest). Shared
+      # by the ADR-55 recursive-return fixpoint and the ADR-56 block /
+      # loop-body fixpoint (`BodyFixpoint`) to force convergence on the
+      # final permitted iteration.
+      def widen_value_pinned(type)
+        case type
+        when Constant
+          type.value.nil? ? type : nominal_of(type.value.class.name)
+        when Refined
+          # A refinement (`non-empty-string`) is a value-narrowed nominal;
+          # widen it to its base so an accumulator whose per-pass result is
+          # a bounded refinement converges on the final iteration rather
+          # than flooring to `Dynamic[top]` (ADR-56).
+          widen_value_pinned(type.base)
+        when IntegerRange
+          # `int<1, 6>` is likewise a value-narrowed `Integer` (it erases to
+          # `Integer` in RBS); widen it so a bounded-int accumulator
+          # converges (ADR-56).
+          nominal_of("Integer")
+        when Union
+          union(*type.members.map { |member| widen_value_pinned(member) })
+        else
+          type
+        end
+      end
+
       # `Object#method(:name)` carrier. Stores the bound
       # `(receiver, method_name)` pair so the dispatcher can
       # substitute the original dispatch at `.call` / `.()` /
@@ -382,6 +412,10 @@ module Rigor
         if Inference::BudgetTrace.enabled? && result.is_a?(Union)
           Inference::BudgetTrace.observe(Inference::BudgetTrace::UNION_ARITY, result.members.size)
         end
+        # `rigor trace` — degenerate merges (`1 | 1 → 1`, Dynamic
+        # absorption) are recorded too; the collapse itself is the
+        # teachable moment.
+        Inference::FlowTracer.union(types, result) if Inference::FlowTracer.active? && types.size >= 2
         result
       end
 

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.1.17"
+  VERSION = "0.1.19"
 end

data/lib/rigor.rb

@@ -30,7 +30,6 @@ require_relative "rigor/cache/rbs_known_class_names"
 require_relative "rigor/cache/rbs_class_ancestor_table"
 require_relative "rigor/cache/rbs_class_type_param_names"
 require_relative "rigor/cache/rbs_environment"
-require_relative "rigor/cache/rbs_instance_definitions"
 require_relative "rigor/type_node"
 require_relative "rigor/flow_contribution"
 require_relative "rigor/flow_contribution/fact"

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable.rb

@@ -70,7 +70,12 @@ module Rigor
         }
       )
 
-      producer :channel_index do |_params|
+      # `watch:` covers every `.rb` file under the channel search paths
+      # so the cache invalidates when channels are added, removed, or
+      # edited (ADR-60 WD3). The dependency descriptor is recorded after
+      # the discoverer runs, so the `io_boundary` reads inside it are
+      # captured too.
+      producer :channel_index, watch: -> { [[@channel_search_paths, "**/*.rb"]] } do |_params|
         ChannelDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @channel_search_paths,
@@ -81,54 +86,33 @@ module Rigor
       def init(_services)
         @channel_search_paths = Array(config.fetch("channel_search_paths")).map(&:to_s)
         @channel_base_classes = Array(config.fetch("channel_base_classes")).map(&:to_s)
-        @channel_index = nil
-        @load_error = nil
       end
 
       # File-level only: the load-error emission. Per-call broadcast
       # validation runs over the engine-owned walk via the node_rule
       # below (ADR-37). The channel index is lazily loaded + memoised by
-      # channel_index_or_nil, shared by both surfaces.
+      # `producer_value`, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = channel_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:channel_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:channel_index)
 
         []
       end
 
       node_rule Prism::CallNode do |node, _scope, path|
-        index = channel_index_or_nil
+        index = producer_value(:channel_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, channel_index: index).map do |violation|
-          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
-        end
+        diagnostics_for(Analyzer.violations_for(call_node: node, channel_index: index), path: path, node: node)
       end
 
       private
 
-      def channel_index_or_nil
-        return @channel_index if @channel_index
-
-        # Pass an explicit descriptor covering every `.rb` file
-        # under the configured channel search paths so the cache
-        # invalidates when channels are added, removed, or edited.
-        # Without it the auto-built descriptor depends on the
-        # `IoBoundary`'s in-process read history — empty on the
-        # first call of a fresh process, so warm cache hits would
-        # serve stale `ChannelIndex` data when project files have
-        # changed between sessions.
-        descriptor = glob_descriptor(@channel_search_paths, "**/*.rb")
-        @channel_index = cache_for(:channel_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @load_error = "rigor-actioncable: failed to discover channels: #{e.class}: #{e.message}"
-        nil
-      end
-
       def load_error_diagnostic(path)
+        error = producer_error(:channel_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-actioncable: failed to discover channels: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer.rb

@@ -65,7 +65,13 @@ module Rigor
         }
       )
 
-      producer :mailer_index do |_params|
+      # `watch:` covers every mailer class under `mailer_search_paths`
+      # AND every view template under `views_root` (ADR-60 WD3) — a
+      # newly-added view a mailer references must invalidate the index,
+      # and `view_exists?` failures the producer never records would
+      # otherwise be invisible to the dependency descriptor.
+      producer :mailer_index,
+               watch: -> { [[@mailer_search_paths, "**/*.rb"], [@views_root, "**/*"]] } do |_params|
         MailerDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @mailer_search_paths,
@@ -78,8 +84,6 @@ module Rigor
         @mailer_search_paths = Array(config.fetch("mailer_search_paths")).map(&:to_s)
         @mailer_base_classes = Array(config.fetch("mailer_base_classes")).map(&:to_s)
         @views_root = config.fetch("views_root").to_s
-        @mailer_index = nil
-        @load_error = nil
       end
 
       # File-level: load-error + the missing-view check (anchored on the
@@ -88,46 +92,22 @@ module Rigor
       # arity) runs over the engine-owned walk via the node_rule below
       # (ADR-37). The mailer index is lazily loaded + memoised, shared.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = mailer_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:mailer_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:mailer_index)
         return [] if index.nil? || index.empty?
 
         missing_view_diagnostics(path, index)
       end
 
       node_rule Prism::CallNode do |node, _scope, path|
-        index = mailer_index_or_nil
+        index = producer_value(:mailer_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, mailer_index: index).map do |violation|
-          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
-        end
+        diagnostics_for(Analyzer.violations_for(call_node: node, mailer_index: index), path: path, node: node)
       end
 
       private
 
-      def mailer_index_or_nil
-        return @mailer_index if @mailer_index
-
-        # Two-glob descriptor: every mailer class under
-        # `mailer_search_paths` AND every view template under
-        # `views_root`. Without explicit enumeration the cache
-        # invalidates only on files the `IoBoundary` has already
-        # read in the current process — empty on the first call
-        # of a fresh process, so warm hits would serve stale
-        # `MailerIndex` data after mailers are added / removed or
-        # view templates are added (`view_exists?` failures aren't
-        # recorded, so the auto-built descriptor cannot detect a
-        # newly-added view).
-        mailer_d = glob_descriptor(@mailer_search_paths, "**/*.rb")
-        view_d = glob_descriptor([@views_root], "**/*")
-        descriptor = Rigor::Cache::Descriptor.compose(mailer_d, view_d)
-        @mailer_index = cache_for(:mailer_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @load_error = "rigor-actionmailer: failed to discover mailers: #{e.class}: #{e.message}"
-        nil
-      end
-
       # Anchors `missing-view` diagnostics on the mailer file
       # itself: when the file currently being analysed is the
       # mailer's source file, emit one diagnostic per missing
@@ -158,9 +138,10 @@ module Rigor
       end
 
       def load_error_diagnostic(path)
+        error = producer_error(:mailer_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-actionmailer: failed to discover mailers: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/analyzer.rb

@@ -478,8 +478,7 @@ module Rigor
         def partial_target_from_kwargs(hash_node, controller_path)
           partial_value = hash_node.elements.find do |elem|
             elem.is_a?(Prism::AssocNode) &&
-              elem.key.is_a?(Prism::SymbolNode) &&
-              elem.key.value == "partial"
+              Source::Literals.symbol_named?(elem.key, "partial")
           end&.value
           return nil unless partial_value.is_a?(Prism::StringNode)
 

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack.rb

@@ -91,27 +91,22 @@ module Rigor
         ]
       )
 
-      # Phase 2 cached producer — the controller index built
-      # from `controller_search_paths`. The IoBoundary records
-      # a `FileEntry` digest for every file the discoverer
-      # reads, so the cache invalidates when any controller
-      # file changes.
-      producer :controller_index do |_params|
+      # Phase 2 cached producer — the controller index built from
+      # `controller_search_paths`. `watch:` (ADR-60 WD3) covers every
+      # `.rb` file under those roots so the cache invalidates when a
+      # controller is added, removed, or edited; the discoverer's
+      # in-block `io_boundary` reads are captured into the dependency
+      # descriptor too, so no explicit priming is needed.
+      producer :controller_index, watch: -> { [[@controller_search_paths, "**/*.rb"]] } do |_params|
         ControllerDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @controller_search_paths
         ).discover
       end
 
-      def init(services)
-        @services = services
+      def init(_services)
         @controller_search_paths = Array(config.fetch("controller_search_paths")).map(&:to_s)
         @view_search_paths = Array(config.fetch("view_search_paths")).map(&:to_s)
-        @helper_table = nil
-        @helper_table_resolved = false
-        @controller_index = nil
-        @model_index_value = nil
-        @model_index_resolved = false
       end
 
       # ADR-37 — the four Action Pack phases run per-call over the
@@ -123,16 +118,16 @@ module Rigor
       # The filter / render phases read the enclosing controller from the
       # node-rule `NodeContext` ancestors (its fifth block argument).
 
-      # Phase 4 — route-helper consumption.
+      # Phase 4 — route-helper consumption. `:helper_table` is
+      # rigor-rails-routes's published fact (ADR-9), read lazily via
+      # `read_fact`.
       node_rule Prism::CallNode do |node, _scope, path|
         next [] unless controller_file?(path)
 
-        table = helper_table
+        table = read_fact(plugin_id: "rails-routes", name: :helper_table)
         next [] if table.nil? || table.empty?
 
-        Analyzer.helper_violations_for(call_node: node, helper_table: table).map do |v|
-          diagnostic(node, path: path, location: v.location, message: v.message, severity: v.severity, rule: v.rule)
-        end
+        diagnostics_for(Analyzer.helper_violations_for(call_node: node, helper_table: table), path: path, node: node)
       end
 
       # Phase 2 — filter-chain validation. Skips silently when the
@@ -141,12 +136,13 @@ module Rigor
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
         next [] unless controller_file?(path)
 
-        index = controller_index_or_nil
+        index = producer_value(:controller_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.filter_violations_for(call_node: node, ancestors: context.ancestors, controller_index: index).map do |v|
-          diagnostic(node, path: path, location: v.location, message: v.message, severity: v.severity, rule: v.rule)
-        end
+        diagnostics_for(
+          Analyzer.filter_violations_for(call_node: node, ancestors: context.ancestors, controller_index: index),
+          path: path, node: node
+        )
       end
 
       # Phase 3 — render-target validation against the configured
@@ -157,12 +153,13 @@ module Rigor
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
         next [] unless controller_file?(path)
 
-        Analyzer.render_violations_for(
-          call_node: node, ancestors: context.ancestors, path: path,
-          view_search_roots: @view_search_paths, controller_index: controller_index_or_nil
-        ).map do |v|
-          diagnostic(node, path: path, location: v.location, message: v.message, severity: v.severity, rule: v.rule)
-        end
+        diagnostics_for(
+          Analyzer.render_violations_for(
+            call_node: node, ancestors: context.ancestors, path: path,
+            view_search_roots: @view_search_paths, controller_index: producer_value(:controller_index)
+          ),
+          path: path, node: node
+        )
       end
 
       # Phase 1 — strong-parameter validation. Reads the `:model_index`
@@ -173,74 +170,14 @@ module Rigor
       node_rule Prism::CallNode do |node, _scope, path|
         next [] unless controller_file?(path)
 
-        index = model_index
+        index = read_fact(plugin_id: "activerecord", name: :model_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.permit_violations_for(call_node: node, model_index: index).map do |v|
-          diagnostic(node, path: path, location: v.location, message: v.message, severity: v.severity, rule: v.rule)
-        end
+        diagnostics_for(Analyzer.permit_violations_for(call_node: node, model_index: index), path: path, node: node)
       end
 
       private
 
-      def controller_index_or_nil
-        return @controller_index if @controller_index
-
-        # Read project source first so the IoBoundary's
-        # FileEntry digests get captured into the descriptor
-        # before `cache_for` snapshots it (mirrors
-        # rigor-rails-routes / rigor-pundit's pattern).
-        prime_io_boundary_for_index
-        @controller_index = cache_for(:controller_index, params: {}).call
-      rescue StandardError
-        nil
-      end
-
-      def prime_io_boundary_for_index
-        @controller_search_paths.each do |root|
-          absolute = File.expand_path(root)
-          next unless File.directory?(absolute)
-
-          Dir.glob(File.join(absolute, "**", "*.rb")).each do |path|
-            io_boundary.read_file(path)
-          rescue Plugin::AccessDeniedError, Errno::ENOENT
-            nil
-          end
-        end
-      end
-
-      # Lazily resolves the helper table from the cross-plugin
-      # fact store. The cache is per-run because the runner
-      # builds a fresh `FactStore` per invocation; memoizing on
-      # the plugin instance saves the per-file `read` while
-      # still picking up a freshly-published table on the next
-      # `bundle exec rigor check` run.
-      def helper_table
-        return @helper_table if @helper_table_resolved
-
-        @helper_table = @services.fact_store.read(
-          plugin_id: "rails-routes", name: :helper_table
-        )
-        @helper_table_resolved = true
-        @helper_table
-      end
-
-      # Phase 1 — lazily reads the cross-plugin :model_index
-      # fact from rigor-activerecord. The cache is per-run
-      # because the runner builds a fresh FactStore per
-      # invocation; memoizing on the plugin instance saves the
-      # per-file read while still picking up a freshly
-      # published index on the next `bundle exec rigor check`.
-      def model_index
-        return @model_index_value if @model_index_resolved
-
-        @model_index_value = @services.fact_store.read(
-          plugin_id: "activerecord", name: :model_index
-        )
-        @model_index_resolved = true
-        @model_index_value
-      end
-
       def controller_file?(path)
         @controller_search_paths.any? do |root|
           # The runner may pass `path` as either an absolute