rigortype 0.1.18 → 0.1.19

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.rb

@@ -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.rb

@@ -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)
@@ -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.rb

@@ -86,10 +86,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
@@ -152,7 +149,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 +182,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.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.rb

@@ -63,7 +63,7 @@ module Rigor
         }
       )
 
-      producer :worker_index do |_params|
+      producer :worker_index, watch: -> { [[@worker_search_paths, "**/*.rb"]] } do |_params|
         WorkerDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @worker_search_paths,
@@ -74,46 +74,33 @@ module Rigor
       def init(_services)
         @worker_search_paths = Array(config.fetch("worker_search_paths")).map(&:to_s)
         @worker_marker_modules = Array(config.fetch("worker_marker_modules")).map(&:to_s)
-        @worker_index = nil
-        @load_error = nil
       end
 
       # File-level only: the load-error emission. The per-call arity
       # validation runs over the engine-owned walk via the node_rule
       # below (ADR-37). The worker index is lazily loaded + memoised by
-      # worker_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 = worker_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:worker_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:worker_index)
 
         []
       end
 
       node_rule Prism::CallNode do |node, _scope, path|
-        index = worker_index_or_nil
+        index = producer_value(:worker_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, worker_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, worker_index: index), path: path, node: node)
       end
 
       private
 
-      def worker_index_or_nil
-        return @worker_index if @worker_index
-
-        descriptor = glob_descriptor(@worker_search_paths, "**/*.rb")
-        @worker_index = cache_for(:worker_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @load_error = "rigor-sidekiq: failed to discover workers: #{e.class}: #{e.message}"
-        nil
-      end
-
       def load_error_diagnostic(path)
+        error = producer_error(:worker_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-sidekiq: failed to discover workers: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

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

@@ -74,7 +74,7 @@ module Rigor
         block_as_methods: [
           Rigor::Plugin::Macro::BlockAsMethod.new(
             receiver_constraint: "Sinatra::Base",
-            verbs: %i[get post put delete head options patch link unlink]
+            method_names: %i[get post put delete head options patch link unlink]
           )
         ]
       )

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

@@ -329,7 +329,32 @@ module Rigor
           chain_lookup(singleton_target, method_name, anchor_kind: :singleton, mixin_kind: :extend)
         elsif receiver
           instance_chain_lookup(receiver, method_name, scope)
+        else
+          implicit_self_lookup(method_name, scope)
+        end
+      end
+
+      # ADR-11 slice 2 (deferred from slice 1) — implicit-self calls.
+      # A receiver-less call inside a method body resolves against the
+      # engine's own `scope.self_type`: `Nominal[Foo]` inside an
+      # instance method (instance-side lookup), `Singleton[Foo]` inside
+      # a `def self.x` body (singleton-side lookup, `extend` mixins).
+      # Without this, an enforced sig on a sibling method was invisible
+      # to in-class calls — the engine's body-inference tiers then
+      # re-typed the sibling's body, overriding an explicit
+      # `T.untyped` opt-out (the dispatcher's plugin tier had already
+      # run and declined). Anything else (toplevel / Dynamic / DSL
+      # self) contributes nothing and the dispatcher continues.
+      def implicit_self_lookup(method_name, scope)
+        self_type = scope&.self_type
+        case self_type
+        when Rigor::Type::Singleton
+          chain_lookup(self_type.class_name, method_name, anchor_kind: :singleton, mixin_kind: :extend)
+        when Rigor::Type::Nominal
+          chain_lookup(self_type.class_name, method_name, anchor_kind: :instance, mixin_kind: :include)
         end
+      rescue StandardError
+        nil
       end
 
       def instance_chain_lookup(receiver_node, method_name, scope)

data/sig/rigor/analysis/fact_store.rbs

@@ -2,6 +2,9 @@ module Rigor
   module Analysis
     module CheckRules
       def self?.diagnose: (path: String, root: untyped, scope_index: Hash[untyped, Scope]) -> Array[Diagnostic]
+      def self?.build_node_collectors: (String path, untyped scope_index) -> Hash[Symbol, untyped]
+      def self?.node_collector_driver: (Hash[Symbol, untyped] collectors) -> untyped
+      def self?.shadow_verify_converged_collectors: (String path, untyped root, untyped scope_index, Hash[Symbol, untyped]? collectors) -> void
     end
 
     class FactStore

data/sig/rigor/inference/builtins/method_catalog.rbs

@@ -1,4 +1,4 @@
 class Rigor::Inference::Builtins::MethodCatalog
   def initialize: (path: String, ?mutating_selectors: Hash[String, Set[untyped]]) -> void
-  def reset!: () -> nil
+  def reset!: () -> Hash[String, untyped]
 end

data/sig/rigor/plugin/base.rbs

@@ -14,7 +14,7 @@ class Rigor::Plugin::Base
   # the no-arg `manifest` reads the cached value back.
   def self.manifest: (**untyped fields) -> Rigor::Plugin::Manifest
 
-  def self.producer: (untyped id, ?serialize: untyped, ?deserialize: untyped) { (untyped params) -> untyped } -> Symbol
+  def self.producer: (untyped id, ?watch: untyped, ?serialize: untyped, ?deserialize: untyped) { (untyped params) -> untyped } -> Symbol
   def self.producers: () -> Hash[Symbol, untyped]
 
   def self.node_rule: (untyped node_type) { (*untyped) -> untyped } -> untyped
@@ -50,11 +50,14 @@ class Rigor::Plugin::Base
 
   # Authoring helpers.
   def diagnostic: (untyped node, path: untyped, message: untyped, ?severity: untyped, ?rule: untyped, ?location: untyped) -> untyped
+  def diagnostics_for: (untyped violations, path: untyped, ?node: untyped) -> Array[untyped]
+  def read_fact: (plugin_id: untyped, name: untyped) -> untyped
+  def producer_value: (untyped id, ?params: untyped) -> untyped
+  def producer_error: (untyped id) -> untyped
   def manifest: () -> Rigor::Plugin::Manifest
   def signature_paths: () -> Array[String]
   def protocol_contracts: () -> untyped
   def io_boundary: () -> Rigor::Plugin::IoBoundary
   def cache_for: (untyped producer_id, ?params: untyped, ?descriptor: untyped) -> untyped
-  def glob_descriptor: (untyped roots, *untyped patterns) -> untyped
   def plugin_entry: () -> untyped
 end

data/sig/rigor/plugin/manifest.rbs

@@ -3,7 +3,7 @@ class Rigor::Plugin::Manifest::Consumption
 end
 
 class Rigor::Plugin::Manifest
-  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?nested_class_templates: untyped, ?trait_registries: untyped, ?external_files: untyped, ?hkt_registrations: untyped, ?hkt_definitions: untyped, ?signature_paths: untyped, ?protocol_contracts: untyped, ?source_rbs_synthesizer: untyped, ?additional_initializers: untyped) -> void
+  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?nested_class_templates: untyped, ?trait_registries: untyped, ?hkt_registrations: untyped, ?hkt_definitions: untyped, ?signature_paths: untyped, ?protocol_contracts: untyped, ?source_rbs_synthesizer: untyped, ?additional_initializers: untyped) -> void
 
   # Public attribute readers (the full `attr_reader` surface). Plugins
   # read `manifest.id` / `manifest.protocol_contracts` etc.; declaring
@@ -25,7 +25,6 @@ class Rigor::Plugin::Manifest
   def heredoc_templates: () -> untyped
   def nested_class_templates: () -> untyped
   def trait_registries: () -> untyped
-  def external_files: () -> untyped
   def hkt_registrations: () -> untyped
   def hkt_definitions: () -> untyped
   def signature_paths: () -> untyped

data/sig/rigor/scope.rbs

@@ -22,6 +22,7 @@ module Rigor
     def in_source_constants: () -> Hash[String, Type::t]
     def discovered_methods: () -> Hash[String, Hash[Symbol, Symbol]]
     def discovered_def_nodes: () -> Hash[String, Hash[Symbol, untyped]]
+    def discovered_singleton_def_nodes: () -> Hash[String, Hash[Symbol, untyped]]
     def discovered_def_sources: () -> Hash[String, Hash[Symbol, String]]
     def discovered_method_visibilities: () -> Hash[String, Hash[Symbol, Symbol]]
     def discovered_superclasses: () -> Hash[String, String]
@@ -38,6 +39,7 @@ module Rigor
       attr_reader in_source_constants: Hash[String, Type::t]
       attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
       attr_reader discovered_def_nodes: Hash[String, Hash[Symbol, untyped]]
+      attr_reader discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]]
       attr_reader discovered_def_sources: Hash[String, Hash[Symbol, String]]
       attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
       attr_reader discovered_superclasses: Hash[String, String]
@@ -47,7 +49,7 @@ module Rigor
 
       EMPTY: DiscoveryIndex
 
-      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?data_member_layouts: Hash[String, Array[Symbol]]) -> DiscoveryIndex
+      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?data_member_layouts: Hash[String, Array[Symbol]]) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -75,10 +77,17 @@ module Rigor
     def with_ivar: (String | Symbol name, Type::t type) -> Scope
     def with_cvar: (String | Symbol name, Type::t type) -> Scope
     def with_global: (String | Symbol name, Type::t type) -> Scope
+    def declaration_sourced: () -> Set[[Symbol, Symbol]]
+    def seed_declaration_sourced_ivar: (String | Symbol name, Type::t type) -> Scope
+    def with_declaration_sourced_local: (String | Symbol name, Type::t type) -> Scope
+    def with_local_declaration_mark: (String | Symbol name) -> Scope
+    def declaration_sourced?: (Symbol kind, String | Symbol name) -> bool
+    def forget_match_globals: () -> Scope
     def class_ivars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
     def class_cvars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
     def discovered_method?: (String | Symbol class_name, String | Symbol method_name, Symbol kind) -> bool
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
+    def singleton_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
     def user_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def top_level_def_for: (String | Symbol method_name) -> untyped?
     def toplevel?: () -> bool

data/sig/rigor/type.rbs

@@ -342,6 +342,7 @@ module Rigor
       def self?.union: (*Type::t types) -> Type::t
       def self?.key_of: (Type::t type) -> Type::t
       def self?.value_of: (Type::t type) -> Type::t
+      def self?.widen_value_pinned: (Type::t type) -> Type::t
       def self?.int_mask: (Array[Integer] flags) -> Type::t?
       def self?.int_mask_of: (Type::t type) -> Type::t?
       def self?.indexed_access: (Type::t type, Type::t key) -> Type::t

data/sig/rigor.rbs

@@ -11,7 +11,7 @@ module Rigor
     attr_reader cache_path: String
     attr_reader baseline_path: String?
 
-    def self.load: (?String path) -> Configuration
+    def self.load: (?String? path) -> Configuration
     def self.discover: () -> String?
     def self.load_with_includes: (String path, ?visited: Set[String]) -> Hash[String, untyped]
     def initialize: (?Hash[String, untyped] data) -> void

data/skills/rigor-baseline-reduce/references/01-classify.md

@@ -28,6 +28,33 @@ signal — each hint has an `id`:
 | `project-monkey-patch` | A DSL / monkey-patch Rigor can't see. | Escalate — a `pre_eval:` entry or a plugin clears the whole cluster. |
 | `activerecord-relation-misinference` | Likely an engine gap. | Treat sites as candidate false positives (Phase 2). |
 
+### `rigor triage --format json` `.selectors` — the by-(class, method) axis
+
+Beside `hints`, the triage JSON carries a `selectors` array: one row
+per dispatch target the diagnostics cluster on, built from the
+structured `receiver_type` / `method_name` fields (never message
+parsing). Each row is `{receiver, method, count, files, rules}`. Use
+it to pick *which sites within a rule* to sample first — and to tell a
+systemic cause from a scatter of real bugs — with `jq`, not eyeballing
+the stream:
+
+```sh
+# the dispatch targets responsible for the most diagnostics
+rigor triage --format json | jq -r '.selectors[:15][] | "\(.count)\t\(.files)f\t\(.receiver)#\(.method)"'
+# one method, one receiver, spread across many files → systemic
+# (a plugin / pre_eval clears it) rather than N independent bugs
+rigor triage --format json | jq '.selectors[] | select(.files >= 4)'
+# narrow to a rule you are about to work, ranked by concentration
+rigor triage --format json \
+  | jq '[.selectors[] | select(.rules["call.possible-nil-receiver"])] | sort_by(-.count)'
+```
+
+Read it as: **high `count` × high `files` = a systemic selector**
+(escalate as a decision — one fix clears the cluster); **low `count` =
+a candidate genuine bug** to sample directly in Phase 2. The `receiver`
+is a normalised class (`"hi".squish` and `name.squish` both bucket
+under `String#squish`), so a single idiom does not scatter across rows.
+
 ### `rigor baseline dump --format json` — the bucket list
 
 ```sh

data/skills/rigor-plugin-author/SKILL.md

@@ -98,9 +98,11 @@ AST walk per file — hands every matching node to the block along with a
 `Rigor::Analysis::Diagnostic` (built via the `diagnostic` helper).
 Optionally the plugin also declares `dynamic_return(receivers:)` /
 `type_specifier(methods:)` to *supply* a return type or narrowing facts
-for call sites the core analyzer types as `Dynamic`. (The older
-`#diagnostics_for_file` / `#flow_contribution_for` fat hooks remain as
-deprecated escape valves — see Phase 2.)
+for call sites the core analyzer types as `Dynamic`. `#diagnostics_for_file`
+is the file-rule surface for whole-file diagnostics a per-node walk can't
+express. (`flow_contribution_for` was removed pre-1.0 in ADR-52 WD3 —
+defining it now raises `ArgumentError`; use `dynamic_return` /
+`type_specifier`. See Phase 2.)
 
 ## Phase outline
 
@@ -115,5 +117,5 @@ deprecated escape valves — see Phase 2.)
 | Module | Read | Covers |
 | --- | --- | --- |
 | 1 | [`references/01-plan-and-scaffold.md`](references/01-plan-and-scaffold.md) | **Phase 1.** The gem vs project-private packaging split, directory trees for both, gemspec template, project-private path-gem / `RUBYLIB` activation, the `Rigor::Plugin::Base` skeleton, `.rigor.yml` `plugins:` wiring. |
-| 2 | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) | **Phase 2.** The `node_rule` engine-owned AST walk over Prism nodes, the `Base#diagnostic` helper, asking the analyzer for inferred types via `scope.type_of`, two-pass / lexical context (`node_file_context` / `NodeContext`), the optional `dynamic_return` / `type_specifier` return-type hooks (and the deprecated `flow_contribution_for` escape valve), calling the target library's pure methods directly rather than reimplementing them (ADR-39: `Plugin::Inflector` over the real `ActiveSupport::Inflector`; `Base.suggest` for did-you-mean), and shipping `sig/*.rbs` so the DSL's types are visible. |
+| 2 | [`references/02-walker-and-types.md`](references/02-walker-and-types.md) | **Phase 2.** The `node_rule` engine-owned AST walk over Prism nodes, the `Base#diagnostic` helper, asking the analyzer for inferred types via `scope.type_of`, two-pass / lexical context (`node_file_context` / `NodeContext`), the optional `dynamic_return` / `type_specifier` return-type hooks (`flow_contribution_for` was removed pre-1.0 in ADR-52 WD3), calling the target library's pure methods directly rather than reimplementing them (ADR-39: `Plugin::Inflector` over the real `ActiveSupport::Inflector`; `Base.suggest` for did-you-mean), and shipping `sig/*.rbs` so the DSL's types are visible. |
 | 3 | [`references/03-test-and-ship.md`](references/03-test-and-ship.md) | **Phase 3.** Testing a plugin from outside the monorepo — fixture projects driven through `rigor check --format json`, plus pure unit tests of dispatch tables — with RSpec or Minitest. Version pinning against the pre-1.0 contract. README. Publishing to RubyGems or keeping the plugin private. |