rigortype 0.1.18 → 0.2.0

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

@@ -66,7 +66,7 @@ module Rigor
         }
       )
 
-      producer :policy_index do |_params|
+      producer :policy_index, watch: -> { [[@policy_search_paths, "**/*.rb"]] } do |_params|
         PolicyDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @policy_search_paths,
@@ -77,46 +77,35 @@ module Rigor
       def init(_services)
         @policy_search_paths = Array(config.fetch("policy_search_paths")).map(&:to_s)
         @policy_base_classes = Array(config.fetch("policy_base_classes")).map(&:to_s)
-        @policy_index = nil
-        @load_error = nil
       end
 
       # File-level only: the load-error emission. The per-call policy
       # validation runs over the engine-owned walk via the node_rule
       # below (ADR-37). The index is lazily loaded + memoised by
-      # policy_index_or_nil, so both surfaces share one load.
+      # `producer_value`, so both surfaces share one load.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = policy_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:policy_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:policy_index)
 
         []
       end
 
       node_rule Prism::CallNode do |node, scope, path|
-        index = policy_index_or_nil
+        index = producer_value(:policy_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, policy_index: index, scope: scope).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, policy_index: index, scope: scope), path: path, node: node
+        )
       end
 
       private
 
-      def policy_index_or_nil
-        return @policy_index if @policy_index
-
-        descriptor = glob_descriptor(@policy_search_paths, "**/*.rb")
-        @policy_index = cache_for(:policy_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @load_error = "rigor-pundit: failed to discover policies: #{e.class}: #{e.message}"
-        nil
-      end
-
       def load_error_diagnostic(path)
+        error = producer_error(:policy_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-pundit: failed to discover policies: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/analyzer.rb

@@ -169,7 +169,7 @@ module Rigor
 
         # Extracts the literal-string first argument when
         # present. Returns nil for variable / expression keys —
-        # those are out of scope for v0.1.0.
+        # only literal keys are statically validated.
         def literal_key_for(call_node)
           args = call_node.arguments&.arguments || []
           return nil if args.empty?
@@ -224,9 +224,7 @@ module Rigor
 
         def collect_assoc_keys(hash_node)
           # Both `Prism::HashNode` and `Prism::KeywordHashNode`
-          # expose `#elements`; the conditional was an
-          # accidental no-op carried over from an earlier
-          # draft.
+          # expose `#elements`, so a single path handles both.
           hash_node.elements.filter_map do |element|
             next nil unless element.is_a?(Prism::AssocNode)
 

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_loader.rb

@@ -57,7 +57,7 @@ module Rigor
             parsed.each do |locale, tree|
               locale = locale.to_s
               locales << locale
-              flatten_tree(tree, []).each do |dotted_key, value|
+              each_flattened(tree, []) do |dotted_key, value|
                 placeholders = (per_key[dotted_key] ||= {})
                 placeholders[locale] = extract_placeholders(value)
                 kinds = (per_key_kinds[dotted_key] ||= {})
@@ -101,24 +101,40 @@ module Rigor
         end
 
         # Recursively walks the per-locale subtree, yielding
-        # `[dotted_key, leaf_value]` pairs. Hash leaves are
+        # `[dotted_key, leaf_value]` for each leaf. Hash leaves are
         # *not* recorded as entries themselves — only their
-        # descendants — but every leaf scalar / array IS
-        # recorded.
-        def flatten_tree(node, breadcrumbs)
-          case node
-          when Hash
-            node.flat_map do |k, v|
-              flatten_tree(v, breadcrumbs + [k.to_s])
+        # descendants — but every leaf scalar / array IS recorded.
+        #
+        # `breadcrumbs` is a single mutable stack reused across the
+        # whole walk (push before recursing, pop after): for the
+        # 530-file / 14 MB Mastodon locale corpus the old
+        # `flat_map { flatten_tree(v, breadcrumbs + [k]) }` shape
+        # allocated a fresh breadcrumb Array at every node plus an
+        # intermediate result Array at every level — millions of
+        # short-lived objects and the run's top allocation site. The
+        # dotted key is still materialised once per leaf (it has to
+        # be); everything else is now allocation-free traversal.
+        def each_flattened(node, breadcrumbs, &)
+          if node.is_a?(Hash)
+            node.each do |k, v|
+              breadcrumbs.push(k.to_s)
+              each_flattened(v, breadcrumbs, &)
+              breadcrumbs.pop
             end
           else
-            [[breadcrumbs.join("."), node]]
+            yield breadcrumbs.join("."), node
           end
         end
 
         def extract_placeholders(value)
           case value
-          when String then value.scan(PLACEHOLDER_RE).flatten.to_set
+          when String
+            # Most locale leaves carry no `%{var}`; skip the scan +
+            # flatten + to_set allocation trio for them. A string with
+            # no `%{` yields an empty placeholder set either way.
+            return Set.new unless value.include?("%{")
+
+            value.scan(PLACEHOLDER_RE).flatten.to_set
           when Array then value.map { |v| extract_placeholders(v) }.reduce(Set.new) { |a, s| a | s }
           else Set.new
           end

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n.rb

@@ -40,7 +40,7 @@ module Rigor
     #    arguments. Missing placeholders are errors; extra
     #    arguments are warnings.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - Only literal-string keys are validated. `t(key)` with
     #   a variable receiver is silently passed through.
@@ -72,7 +72,13 @@ module Rigor
         }
       )
 
-      producer :locale_index do |_params|
+      # `watch:` covers every `.yml` / `.yaml` file under the locale
+      # search paths so the cache invalidates when locale files are
+      # added, removed, or edited (ADR-60 WD3). `@load_errors` is a
+      # producer-side capture: it is populated only when the block
+      # runs (a cache miss / a watched file changed), which is exactly
+      # when a malformed YAML must re-surface.
+      producer :locale_index, watch: -> { [[@locale_search_paths, "**/*.yml", "**/*.yaml"]] } do |_params|
         loader = LocaleLoader.new(
           io_boundary: io_boundary,
           search_paths: @locale_search_paths
@@ -85,21 +91,19 @@ module Rigor
       def init(_services)
         @locale_search_paths = Array(config.fetch("locale_search_paths")).map(&:to_s)
         @configured_locales = Array(config.fetch("configured_locales")).map(&:to_s)
-        @locale_index = nil
         @load_errors = []
         @load_errors_emitted = false
-        @runtime_error = nil
       end
 
       # File-level only: the once-per-run YAML load errors + the
       # runtime (cache-load) error. Per-call `t('key')` validation runs
       # over the engine-owned walk via the node_rule below (ADR-37). The
-      # locale index is lazily loaded + memoised by locale_index_or_nil.
+      # locale index is lazily loaded + memoised by `producer_value`.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = locale_index_or_nil
+        index = producer_value(:locale_index)
         diagnostics = []
         diagnostics.concat(consume_load_error_diagnostics(path)) unless @load_errors.empty?
-        diagnostics << runtime_error_diagnostic(path) if index.nil? && @runtime_error
+        diagnostics << runtime_error_diagnostic(path) if index.nil? && producer_error(:locale_index)
         diagnostics
       end
 
@@ -107,39 +111,21 @@ module Rigor
       # (the controller action), supplied by the node-rule NodeContext;
       # the controller scope comes from the file path.
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
-        index = locale_index_or_nil
+        index = producer_value(:locale_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(
-          call_node: node, locale_index: index, configured_locales: @configured_locales,
-          controller_scope: Analyzer.controller_scope_from_path(path),
-          action: context.enclosing_def&.name
-        ).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, locale_index: index, configured_locales: @configured_locales,
+            controller_scope: Analyzer.controller_scope_from_path(path),
+            action: context.enclosing_def&.name
+          ),
+          path: path, node: node
+        )
       end
 
       private
 
-      def locale_index_or_nil
-        return @locale_index if @locale_index
-
-        # Pass an explicit descriptor covering every `.yml` / `.yaml`
-        # file under the configured locale search paths so the cache
-        # invalidates when locale files 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 `LocaleIndex` data and hide per-call load
-        # errors (a malformed YAML in one run would not surface
-        # when a healthy cache entry from an earlier run exists).
-        descriptor = glob_descriptor(@locale_search_paths, "**/*.yml", "**/*.yaml")
-        @locale_index = cache_for(:locale_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @runtime_error = "rigor-rails-i18n: failed to load locales: #{e.class}: #{e.message}"
-        nil
-      end
-
       # The runner only invokes `diagnostics_for_file` for
       # Ruby files (`paths:` is filtered to `.rb`). YAML
       # parse errors therefore can't be anchored on the
@@ -161,9 +147,10 @@ module Rigor
       end
 
       def runtime_error_diagnostic(path)
+        error = producer_error(:locale_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @runtime_error,
+          message: "rigor-rails-i18n: failed to load locales: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/devise_routes.rb

@@ -38,11 +38,9 @@ module Rigor
       #   (`user_facebook_omniauth_authorize_path`) and Devise
       #   declares them from the configured providers, which
       #   live in an initializer this static parser does not
-      #   read. We register the SHAPE-FAMILY suffix matchers
-      #   `_omniauth_authorize_path` / `_omniauth_callback_path`
-      #   via a separate hook (see `OMNIAUTH_HELPER_PATTERNS`);
-      #   these are NOT in the table but consulted by the
-      #   `Analyzer.allowed_dynamic_pattern?` check.
+      #   read. The suffix patterns are registered in
+      #   `OMNIAUTH_SUFFIXES` and consulted by
+      #   `HelperTable#omniauth_match?`.
       module DeviseRoutes
         # The standard Devise controllers and the helper
         # actions each generates. Keys are the controller
@@ -190,7 +188,7 @@ module Rigor
 
         # Returns the set of OmniAuth pattern suffixes the
         # analyzer accepts for a given resource. The analyzer
-        # consults this set (via `HelperTable#allows_omniauth?`)
+        # consults this set (via `HelperTable#omniauth_match?`)
         # when a `*_path` / `*_url` call's name does not match
         # any registered entry and its prefix matches a Devise
         # resource.

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/routes_parser.rb

@@ -1171,9 +1171,10 @@ module Rigor
         end
 
         def in_singular_resource?(*)
-          # Slice 1 doesn't model the singular-resource frame
-          # separately; placeholder so member / collection
-          # blocks at least descend.
+          # Stub: always returns true so member / collection
+          # blocks descend. The singular-resource frame
+          # (`push_singular_resource`) is modelled in Context;
+          # a future caller could use it to tighten this check.
           true
         end
 
@@ -1181,21 +1182,14 @@ module Rigor
         # `plural: true` for `resources :users`, `false` for
         # `resource :profile`.
         def register_resourceful_helpers(name, actions, base_arity, context, plural:)
-          # Singular resources (`resource :foo`) use the
-          # given name AS-IS for both path and helper —
-          # singularising would mangle a deliberately-plural
-          # singular-DSL name like Mastodon's
-          # `resource :relationships, only: [:show, :update]`
-          # (Rails generates `relationships_path`, not
-          # `relationship_path`). Plural resources still
-          # singularise for the show / new / edit helpers.
-          # Plural resources singularise for show / new / edit
-          # helpers (`resources :users` → `user_path(id)`);
-          # singular resources use the name AS-IS even when it
-          # looks plural (Mastodon's `resource :relationships,
-          # only: [:show, :update]` → `relationships_path`).
-          # The path segment uses `name` in both shapes — Rails
-          # never singularises the URL.
+          # Plural resources (`resources :users`) singularise
+          # for show / new / edit helpers → `user_path(id)`.
+          # Singular resources (`resource :foo`) use the name
+          # AS-IS — singularising would mangle deliberately-
+          # plural names like Mastodon's `resource
+          # :relationships` → `relationships_path`, not
+          # `relationship_path`. The URL path uses `name`
+          # in both shapes (Rails never singularises the URL).
           singular = plural ? singularize_word(name.to_s) : name.to_s
           path_base = "#{context.path_prefix}/#{name}"
 

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes.rb

@@ -26,9 +26,9 @@ module Rigor
     # - One level of nested `resources`
     #
     # The plugin publishes its parsed `:helper_table` through
-    # the ADR-9 cross-plugin fact store so future
-    # `rigor-actionpack` Phase 4 can consume it for
-    # route-helper validation in controller code.
+    # the ADR-9 cross-plugin fact store; `rigor-actionpack`
+    # Phase 4 consumes it for route-helper validation in
+    # controller code.
     #
     # ## Configuration
     #
@@ -94,7 +94,12 @@ module Rigor
       #
       # Passes a `file_reader` lambda so the parser can follow
       # `draw(:admin)` → `config/routes/admin.rb` partials.
-      producer :helper_table do |_params|
+      # `watch:` (ADR-60 WD3) covers every `.rb` under `helper_paths:`
+      # so ADDING a helper file invalidates the table — the producer's
+      # own in-block reads (the routes file + the partials it follows
+      # via `draw`) are captured post-compute, but a brand-new helper
+      # file the prior run never read would otherwise read as fresh.
+      producer :helper_table, watch: -> { @helper_paths.map { |dir| [dir, "**/*.rb"] } } do |_params|
         routes_dir = "#{File.dirname(@routes_file)}/routes"
         file_reader = lambda do |name|
           io_boundary.read_file("#{routes_dir}/#{name}")
@@ -132,14 +137,6 @@ module Rigor
         HelperDiscoverer.discover(contents_per_path)
       end
 
-      def pre_read_helper_files
-        each_helper_file do |path|
-          io_boundary.read_file(path)
-        rescue Plugin::AccessDeniedError, Errno::ENOENT
-          next
-        end
-      end
-
       def each_helper_file(&)
         @helper_paths.each do |dir|
           absolute = File.expand_path(dir)
@@ -150,8 +147,8 @@ module Rigor
       end
 
       # Publishes the parsed table to the cross-plugin fact
-      # store so future Tier 2 plugins (rigor-actionpack
-      # Phase 4) can read it via `services.fact_store.read`.
+      # store; `rigor-actionpack` Phase 4 reads it via
+      # `services.fact_store.read`.
       def prepare(services)
         table = helper_table_or_nil
         return if table.nil?
@@ -214,15 +211,11 @@ module Rigor
         return @helper_table if @helper_table_built
 
         @helper_table_built = true
-        # Read first so the IoBoundary's FileEntry digest
-        # captures into the descriptor before `cache_for`
-        # snapshots it (the same pattern documented in
-        # rigor-routes / rigor-activerecord). Helper files are
-        # pre-read for the same reason — editing a file under
-        # `app/helpers/` MUST invalidate the helper_table cache
-        # so the new custom-helper set is picked up.
-        io_boundary.read_file(@routes_file)
-        pre_read_helper_files
+        # ADR-60 WD3 record-and-validate: the producer's in-block reads
+        # (the routes file + the partials it follows) are captured into
+        # the dependency descriptor AFTER the block runs, and the
+        # producer's `watch:` covers helper-file additions — so no
+        # priming read is needed here.
         @helper_table = cache_for(:helper_table, params: {}).call
       rescue Plugin::AccessDeniedError => e
         @load_error = "rigor-rails-routes: #{e.message}"

data/plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb

@@ -147,7 +147,6 @@ module Rigor
           block_as_methods: base.block_as_methods,
           heredoc_templates: base.heredoc_templates,
           trait_registries: base.trait_registries,
-          external_files: base.external_files,
           hkt_registrations: base.hkt_registrations,
           hkt_definitions: base.hkt_definitions,
           signature_paths: base.signature_paths,

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/let_scope_index.rb

@@ -21,10 +21,9 @@ module Rigor
       #   { ... }` and `subject(:name) { ... }` declarations.
       #   `:subject` is the key for the implicit `subject { ... }`.
       #
-      # Pillar 2 Slice 2 — used by the plugin's let-binding
-      # `dynamic_return` rule to bind `let`-named
-      # method-shape calls inside `it` bodies to the let
-      # block's inferred type.
+      # Used by the plugin's let-binding `dynamic_return`
+      # rule to bind `let`-named method-shape calls inside
+      # `it` bodies to the let block's inferred type.
       class LetScopeIndex
         Record = Struct.new(:outer_range, :describe_const, :lets, keyword_init: true) do
           def contains?(line) = outer_range.cover?(line)

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/let_type_resolver.rb

@@ -6,7 +6,7 @@ require "rigor/type"
 module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
-      # Pillar 2 Slice 2 — resolves the runtime type of a
+      # Resolves the runtime type of a
       # `let(:name) { body }` or `subject(:name) { body }`
       # block by pattern-matching its body's tail expression.
       #

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/matcher_analyzer.rb

@@ -8,7 +8,7 @@ require "rigor/flow_contribution/fact"
 module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
-      # Pillar 2 Slice 1 — recognises `expect(x).to MATCHER`
+      # Recognises `expect(x).to MATCHER`
       # patterns at per-call recognition time and emits
       # `post_return_facts` that narrow the named local on the
       # post-call edge.

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

@@ -11,15 +11,13 @@ require_relative "rspec/let_type_resolver"
 module Rigor
   module Plugin
     # rigor-rspec — validates RSpec `let` / `subject`
-    # declarations within each describe / context scope.
+    # declarations within each describe / context scope,
+    # narrows `expect(x).to MATCHER` assertions downstream,
+    # and binds `let`/`subject` locals to their inferred
+    # return types inside `it` bodies.
     #
     # Tier 3A of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
-    # Deliberately scoped — the roadmap describes a much
-    # larger plugin (let-typo detection in `it` bodies,
-    # `expect(x).to receive(:method)` mock-target
-    # validation). Both are out of scope for v0.1.0; this
-    # plugin ships the two checks that have the lowest
-    # false-positive risk:
+    # Ships four checks:
     #
     # 1. **Duplicate `let` / `subject` declarations** in
     #    the same scope (`warning`). RSpec's runtime lets
@@ -31,14 +29,21 @@ module Rigor
     #    (`error`). At runtime this infinite-loops; users
     #    typically meant to call a different method or
     #    forgot to introduce a `super`.
+    # 3. **`expect(x).to MATCHER` narrowing** — narrows
+    #    the named local `x` on the post-call edge for
+    #    eight matchers (see `MatcherAnalyzer`).
+    # 4. **`let`/`subject` local binding** — binds `let`
+    #    / `subject` names in `it` bodies to the block's
+    #    inferred return type (see `LetTypeResolver`).
     #
     # ## Configuration
     #
-    # No knobs in v0.1.0. The plugin walks every analysed
-    # file looking for `RSpec.describe ... do` blocks; spec
-    # files outside the project's `paths:` are not scanned.
+    # No configuration knobs. The plugin walks every
+    # analysed file for `RSpec.describe ... do` blocks;
+    # spec files outside the project's `paths:` are not
+    # scanned.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - **No let-typo detection.** Detecting an `it`
     #   block's reference to a misspelled `let` name
@@ -86,10 +91,7 @@ module Rigor
         ]
       )
 
-      def init(services)
-        @services = services
-        @factory_index_resolved = false
-        @factory_index = nil
+      def init(_services)
         # Per-path `LetScopeIndex` cache. The let-binding
         # `dynamic_return` rule (and its `file_methods:` gate)
         # consult the index per call node; building it once
@@ -105,14 +107,14 @@ module Rigor
         Analyzer.diagnose(path: path, root: root).map { |diag| build_diagnostic(diag) }
       end
 
-      # ADR-37 slice 2 — Pillar 2 Slice 1 matcher narrowing
+      # ADR-37 slice 2 — matcher narrowing
       # (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
       # method-gated by the engine on the expectation verbs.
       type_specifier methods: %i[to not_to to_not] do |call_node, scope|
         MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
 
-      # Pillar 2 Slice 2 / ADR-52 slice 5a — binds local reads in `it` /
+      # ADR-52 slice 5a — binds local reads in `it` /
       # spec bodies to their `let(:name) { ... }` block's inferred return
       # type. The name set varies per file (each spec file's
       # `describe`/`let` structure), so the rule gates on the per-file
@@ -133,7 +135,7 @@ module Rigor
         let_scope_index_for(path)&.let_names || []
       end
 
-      # Pillar 2 Slice 2 — when the call node is a no-receiver
+      # When the call node is a no-receiver
       # method call (`user`, `subject`, etc.) inside an RSpec
       # `describe` block whose lets include a matching name,
       # return the let block's inferred type.
@@ -152,7 +154,7 @@ module Rigor
         LetTypeResolver.resolve(
           block_node,
           describe_const: describe_const,
-          factory_index: factory_index_or_nil,
+          factory_index: read_fact(plugin_id: "factorybot", name: :factory_index),
           environment: scope.environment
         )
       end
@@ -185,14 +187,6 @@ module Rigor
         nil
       end
 
-      def factory_index_or_nil
-        return @factory_index if @factory_index_resolved
-
-        @factory_index = @services&.fact_store&.read(plugin_id: "factorybot", name: :factory_index)
-        @factory_index_resolved = true
-        @factory_index
-      end
-
       def build_diagnostic(diag)
         Rigor::Analysis::Diagnostic.new(
           path: diag.path, line: diag.line, column: diag.column,

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers/analyzer.rb

@@ -31,7 +31,6 @@ module Rigor
       #   validate_absence_of(:col)
       #   validate_format_of(:col)
       #   validate_confirmation_of(:col)
-      #   allow_value(...).for(:col)
       #   have_db_column(:col)
       #   have_db_index(:col)
       #

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers.rb

@@ -70,19 +70,14 @@ module Rigor
         ]
       )
 
-      def init(services)
-        @services = services
-        @model_index = nil
-        @model_index_resolved = false
-      end
-
       # ADR-37 — per-matcher validation over the engine-owned walk. The
       # model anchor (the enclosing `describe <Model>` const) comes from
       # the node-rule NodeContext ancestors; the diagnostic points at the
       # matcher name (message_loc). The :model_index fact (from
-      # rigor-activerecord) is read lazily; without it the rule is silent.
+      # rigor-activerecord) is read lazily via `read_fact`; without it
+      # the rule is silent.
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
-        index = model_index_or_nil
+        index = read_fact(plugin_id: "activerecord", name: :model_index)
         next [] if index.nil?
 
         Analyzer.violations_for(matcher_call: node, ancestors: context.ancestors, model_index: index).map do |violation|
@@ -90,21 +85,6 @@ module Rigor
                            message: violation.message, severity: :warning, rule: violation.rule)
         end
       end
-
-      private
-
-      # Lazily resolves `:model_index` from
-      # `rigor-activerecord`. Returns nil when the plugin
-      # isn't loaded or no index has been published; the
-      # analyzer treats nil as "no cross-check available" and
-      # falls silent.
-      def model_index_or_nil
-        return @model_index if @model_index_resolved
-
-        @model_index = @services.fact_store.read(plugin_id: "activerecord", name: :model_index)
-        @model_index_resolved = true
-        @model_index
-      end
     end
 
     Rigor::Plugin.register(ShouldaMatchers)

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_index.rb

@@ -9,10 +9,11 @@ module Rigor
       # analyzer can validate `Worker.perform_async(...)`
       # call sites.
       #
-      # Same envelope shape as `rigor-activejob`'s
-      # `JobIndex::Entry`: `min_arity` / `max_arity` form a
-      # closed range (`Float::INFINITY` for the upper bound
-      # when `*args` is present).
+      # Uses the same `min_arity` / `max_arity` closed-range
+      # envelope as `rigor-activejob`'s `JobIndex::Entry`
+      # (`Float::INFINITY` upper bound when `*args` is present);
+      # Sidekiq workers serialize args to JSON so keyword arity
+      # is not tracked here.
       class WorkerIndex
         Entry = Data.define(:class_name, :min_arity, :max_arity) do
           def arity_label