rigortype 0.1.17 → 0.1.19

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

@@ -39,8 +39,8 @@ module Rigor
     # access by walking every configured `paths:` entry's `.rb`
     # files plus every `rbi_paths:` entry's `.rbi` files (slice
     # 4) via the plugin's `IoBoundary`. The catalog is frozen
-    # after the first build and consulted by
-    # `#flow_contribution_for` at every call site. RBI files
+    # after the first build and consulted by the `dynamic_return`
+    # rule at every gated call site. RBI files
     # share the catalog with project-source sigs — both produce
     # `MethodSignature` entries keyed by
     # `(class_name, method_name, kind)`. When a key collides
@@ -101,7 +101,7 @@ module Rigor
         @enforce_sigil = config.fetch("enforce_sigil")
         # ADR-11 deferred follow-up — per-call-site assertion
         # gating. Catalog harvest's `@sigil_by_path` cache is
-        # consulted at every `flow_contribution_for` call so
+        # consulted at every per-call recognition so
         # `T.let` / `T.cast` / `T.must` / `T.bind` /
         # `T.assert_type!` only fire in files Sorbet itself
         # would enforce (`# typed: true` / `:strict` /
@@ -118,7 +118,7 @@ module Rigor
         @parse_errors_by_path = {}
         @catalog_built = false
         # ADR-11 slice 6 — Prism nodes for `T.absurd` calls
-        # we observed in `flow_contribution_for` to be
+        # we observed in the `dynamic_return` rule to be
         # *reachable* (i.e., their discriminant didn't narrow
         # to `bot`). `diagnostics_for_file` walks the per-file
         # AST and surfaces these as `plugin.sorbet.absurd-reachable`
@@ -128,7 +128,7 @@ module Rigor
         # plugin hooks.
         @reachable_absurd_nodes = {}.compare_by_identity
         # ADR-11 light follow-up — `T.reveal_type` calls
-        # observed in `flow_contribution_for`, paired with the
+        # observed in the `dynamic_return` rule, paired with the
         # display string for the inferred type at the call site.
         # Mirrors the absurd-node compare-by-identity hash;
         # `diagnostics_for_file` surfaces each entry as a
@@ -136,7 +136,7 @@ module Rigor
         @reveal_type_calls = {}.compare_by_identity
         # T.bind / T.assert_type! priority slice 1 —
         # `T.assert_type!` calls observed in
-        # `flow_contribution_for` whose static subtype check
+        # the `dynamic_return` rule whose static subtype check
         # FAILED, paired with the inferred + asserted type
         # display strings. Same compare-by-identity discipline.
         # `diagnostics_for_file` walks the file AST for
@@ -160,9 +160,52 @@ module Rigor
         diagnostics
       end
 
-      # ADR-11 slice 1 — return-type contribution from the
-      # parsed `sig { ... }` block. Resolves the receiver in two
-      # passes:
+      # ADR-52 slice 4 — the per-call return-type path, migrated off
+      # the legacy `flow_contribution_for` hook onto the
+      # method-name-gated `dynamic_return` DSL. The recognised name
+      # set is only known at run time (the catalog's `def` names come
+      # from the lazy catalog build), so it is declared as a
+      # callable: the engine `instance_exec`s it once per run on
+      # first dispatch (always after `#prepare`) and memoises the
+      # resolved Symbol Set. The gate is a safe over-approximation —
+      # a project method merely *named* `cast` or `find` passes it
+      # and is declined by the block's own `T.`-receiver / catalog
+      # checks, exactly as the ungated hook used to decline.
+      dynamic_return methods: -> { recognised_method_names } do |call_node, scope|
+        contribution_return_type(call_node, scope)
+      end
+
+      # ADR-52 slice 4 — `T.bind(self, T)`'s self-narrowing fact,
+      # migrated off the legacy hook's `post_return_facts` slot onto
+      # the method-gated `type_specifier` DSL (once
+      # `flow_contribution_for` is gone, the statement evaluator
+      # consults only this path for narrowing facts). The
+      # return-type half (`Constant[nil]`) flows through the
+      # `dynamic_return` rule above; the block re-checks the `T.`
+      # receiver via the recogniser, so an unrelated `bind` call
+      # contributes nothing.
+      type_specifier methods: [:bind] do |call_node, scope|
+        bind_post_return_facts(call_node, scope)
+      end
+
+      private
+
+      # ADR-52 slice 4 — the run-time method-name gate for the
+      # `dynamic_return` rule: the static assertion vocabulary
+      # (`T.let` / `T.cast` / …), `T.absurd`, and every method name
+      # the catalog carries a sig for.
+      def recognised_method_names
+        ensure_catalog
+        names = AssertionRecognizer::SORBET_ASSERTIONS.dup
+        names << :absurd
+        names.concat(@catalog.method_names)
+        names
+      end
+
+      # The migrated body of the legacy `flow_contribution_for` —
+      # same recognition order, but returns the bare `Rigor::Type`
+      # the `dynamic_return` contract expects. Resolves the receiver
+      # in two passes:
       #
       # 1. Constant receiver (`User.find(...)`) → singleton-side
       #    catalog lookup.
@@ -173,18 +216,22 @@ module Rigor
       # Implicit-self calls (no receiver, current-class method)
       # are deferred to slice 2 — slice 1 covers the common case
       # where the sig is on the called method's own class.
-      def flow_contribution_for(call_node:, scope:)
+      def contribution_return_type(call_node, scope)
         return nil unless call_node.is_a?(Prism::CallNode)
 
         # ADR-11 slice 6 — `T.absurd(x)` exhaustiveness. Always
-        # contributes a `bot` return + raise effect (matches
-        # Sorbet's runtime behaviour); when the discriminant
-        # *isn't* narrowed to `bot` at this scope, also records
-        # the call node so `diagnostics_for_file` can surface a
-        # `plugin.sorbet.absurd-reachable` warning.
+        # contributes a `bot` return (matches Sorbet's runtime
+        # behaviour: `T.absurd` raises, so its value type is `bot`
+        # and the engine's flow analysis treats code after it as
+        # unreachable; the legacy contribution's `exceptional:
+        # :raises` slot was never consumed on the dispatcher path —
+        # only `return_type` survives the merge). When the
+        # discriminant *isn't* narrowed to `bot` at this scope, also
+        # records the call node so `diagnostics_for_file` can surface
+        # a `plugin.sorbet.absurd-reachable` warning.
         if AbsurdRecognizer.absurd_call?(call_node)
           @reachable_absurd_nodes[call_node] = true unless AbsurdRecognizer.exhaustive?(call_node, scope)
-          return AbsurdRecognizer.contribution(call_node, manifest.id)
+          return Rigor::Type::Combinator.bot
         end
 
         # ADR-11 slice 2 — `T.let` / `T.cast` / `T.must` /
@@ -214,31 +261,31 @@ module Rigor
           if assertion
             record_reveal_type_call(call_node, assertion.return_type) if call_node.name == :reveal_type
             record_assert_type_check(call_node, scope) if call_node.name == :assert_type!
-            return assertion
+            return assertion.return_type
           end
         end
 
         return nil if @catalog.nil? || @catalog.empty?
 
-        signature = lookup_signature(call_node, scope)
-        return nil if signature.nil?
+        lookup_signature(call_node, scope)&.return_type
+      end
+
+      # The `type_specifier` body for `T.bind` — same sigil gate as
+      # the return-type path, then the recogniser's
+      # `post_return_facts` (the `Fact(target_kind: :self)` that
+      # narrows `scope.self_type` for the rest of the block).
+      def bind_post_return_facts(call_node, scope)
+        return nil unless call_node.is_a?(Prism::CallNode)
 
-        return_type = signature.return_type
-        return nil if return_type.nil?
+        ensure_catalog
+        return nil unless assertion_enforced_here?(scope)
 
-        Rigor::FlowContribution.new(
-          return_type: return_type,
-          provenance: Rigor::FlowContribution::Provenance.new(
-            source_family: "plugin.#{manifest.id}",
-            plugin_id: manifest.id,
-            node: call_node,
-            descriptor: nil
-          )
+        contribution = AssertionRecognizer.recognize(
+          call_node: call_node, scope: scope, plugin_id: manifest.id
         )
+        contribution&.post_return_facts
       end
 
-      private
-
       # ADR-11 deferred follow-up — per-call-site assertion
       # gating. With `enforce_sigil: false`, the gate is fully
       # open (matches the pre-feature behaviour). With
@@ -282,9 +329,34 @@ 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)
         return nil if scope.nil?
 
@@ -441,7 +513,7 @@ module Rigor
         # magic comment by skipping the file entirely.
         level = SigilDetector.detect(contents)
         # Per-call-site assertion gating consults this map at
-        # `flow_contribution_for`. Recorded BEFORE the ignored
+        # recognition time. Recorded BEFORE the ignored
         # short-circuit so a `# typed: ignore` file still
         # reports its level to the gate (the gate then chooses
         # to suppress assertions there too — `ignore` is
@@ -481,7 +553,7 @@ module Rigor
       # nodes and emits a `plugin.sorbet.absurd-reachable`
       # warning for any whose object identity matches
       # `@reachable_absurd_nodes` (populated during the engine's
-      # earlier pass through `flow_contribution_for`). Pops
+      # earlier pass through the `dynamic_return` rule). Pops
       # matched entries so a duplicate run doesn't double-emit.
       def absurd_reachable_diagnostics(path, root)
         return [] if @reachable_absurd_nodes.empty?
@@ -569,8 +641,8 @@ module Rigor
       # static subtype check at recogniser time and records the
       # call only when the inferred type is *provably
       # incompatible* with the asserted type. Gradual
-      # consistency rules (`Inference::Acceptance.accepts(...)`
-      # mode `:gradual`): a `Dynamic[top]` inferred type
+      # consistency rules (`Type#accepts` mode `:gradual`): a
+      # `Dynamic[top]` inferred type
       # silences the check; a definite `:no` records for
       # diagnostic emission; `:maybe` (uncertain) is treated as
       # "trust the user" and silenced — the runtime check is
@@ -582,7 +654,7 @@ module Rigor
         inferred, asserted = check
         return if inferred.nil?
 
-        result = Rigor::Inference::Acceptance.accepts(asserted, inferred)
+        result = asserted.accepts(inferred)
         return unless result.no?
 
         @assert_type_mismatches[call_node] = [display_for_type(inferred), display_for_type(asserted)]

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/environment.rbs

@@ -58,10 +58,8 @@ module Rigor
       def rbs_module?: (String | Symbol name) -> bool
       def instance_definition: (String | Symbol class_name) -> untyped?
       def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
-      def uncached_instance_definition: (String | Symbol class_name) -> untyped?
       def singleton_definition: (String | Symbol class_name) -> untyped?
       def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
-      def uncached_singleton_definition: (String | Symbol class_name) -> untyped?
       def class_type_param_names: (String | Symbol class_name) -> Array[Symbol]
       def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
       def constant_type: (String name) -> Type::t?

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/inference.rbs

@@ -109,6 +109,9 @@ module Rigor
       def self?.narrow_not_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
       def self?.narrow_not_refinement: (Type::t current_type, Type::t refinement_type) -> Type::t
       def self?.narrow_for_fact: (Type::t current, untyped fact, untyped environment) -> Type::t
+      def self?.predicate_certainty: (Type::t? type) -> (:truthy | :falsey | nil)
+      def self?.class_pattern_certainty: (Type::t subject_type, String class_name, environment: Environment) -> (:yes | :no | :maybe)
+      def self?.value_pattern_certainty: (Type::t subject_type, untyped pattern_value) -> (:yes | :no | :maybe)
       def self?.predicate_scopes: (untyped node, Scope scope) -> [Scope, Scope]
       def self?.case_when_scopes: (untyped subject, Array[untyped] conditions, Scope scope) -> [Scope, Scope]
       def self?.analyse: (untyped node, Scope scope) -> untyped
@@ -117,6 +120,8 @@ module Rigor
       def self?.trusted_equality_literal?: (untyped literal) -> bool
       def self?.falsey_value?: (untyped value) -> bool
       def self?.falsey_nominal?: (Type::Nominal nominal) -> bool
+
+      VALUE_EQUALITY_CLASSES: Array[Class]
     end
 
     module ClosureEscapeAnalyzer

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
@@ -23,7 +23,7 @@ class Rigor::Plugin::Base
   def self.node_file_context: () { (untyped root, untyped scope) -> untyped } -> untyped
   def self.node_file_context_block: () -> untyped
 
-  def self.dynamic_return: (receivers: Array[String]) { (untyped call_node, untyped scope) -> untyped } -> nil
+  def self.dynamic_return: (?receivers: (Array[String] | ^() -> Array[String])?, ?methods: (Array[untyped] | ^() -> Array[untyped])?) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.dynamic_returns: () -> Array[untyped]
 
   def self.type_specifier: (methods: Array[untyped]) { (untyped call_node, untyped scope) -> untyped } -> nil
@@ -41,7 +41,6 @@ class Rigor::Plugin::Base
   # Overridable lifecycle / extension hooks (default no-ops).
   def init: (untyped services) -> nil
   def prepare: (untyped services) -> nil
-  def flow_contribution_for: (call_node: untyped, scope: untyped) -> untyped
   def diagnostics_for_file: (path: untyped, scope: untyped, root: untyped) -> Array[untyped]
 
   # Engine-executed dispatch over the declared DSLs.
@@ -51,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

@@ -4,27 +4,54 @@ module Rigor
     attr_reader locals: Hash[Symbol, Type::t]
     attr_reader fact_store: Analysis::FactStore
     attr_reader self_type: Type::t?
-    attr_reader declared_types: Hash[untyped, Type::t]
     attr_reader ivars: Hash[Symbol, Type::t]
     attr_reader cvars: Hash[Symbol, Type::t]
     attr_reader globals: Hash[Symbol, Type::t]
-    attr_reader class_ivars: Hash[String, Hash[Symbol, Type::t]]
-    attr_reader class_cvars: Hash[String, Hash[Symbol, Type::t]]
-    attr_reader program_globals: Hash[Symbol, Type::t]
-    attr_reader discovered_classes: Hash[String, Type::Singleton]
-    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_def_sources: Hash[String, Hash[Symbol, String]]
-    attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
-    attr_reader discovered_superclasses: Hash[String, String]
-    attr_reader discovered_includes: Hash[String, Array[String]]
-    attr_reader discovered_class_sources: Hash[String, Set[String]]
-    attr_reader data_member_layouts: Hash[String, Array[Symbol]]
+    attr_reader discovery: DiscoveryIndex
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
 
+    # ADR-53 Track A — the seed-time discovery tables live on the
+    # DiscoveryIndex; Scope keeps per-table readers as delegates.
+    def declared_types: () -> Hash[untyped, Type::t]
+    def class_ivars: () -> Hash[String, Hash[Symbol, Type::t]]
+    def class_cvars: () -> Hash[String, Hash[Symbol, Type::t]]
+    def program_globals: () -> Hash[Symbol, Type::t]
+    def discovered_classes: () -> Hash[String, Type::Singleton]
+    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]
+    def discovered_includes: () -> Hash[String, Array[String]]
+    def discovered_class_sources: () -> Hash[String, Set[String]]
+    def data_member_layouts: () -> Hash[String, Array[Symbol]]
+
+    class DiscoveryIndex
+      attr_reader declared_types: Hash[untyped, Type::t]
+      attr_reader class_ivars: Hash[String, Hash[Symbol, Type::t]]
+      attr_reader class_cvars: Hash[String, Hash[Symbol, Type::t]]
+      attr_reader program_globals: Hash[Symbol, Type::t]
+      attr_reader discovered_classes: Hash[String, Type::Singleton]
+      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]
+      attr_reader discovered_includes: Hash[String, Array[String]]
+      attr_reader discovered_class_sources: Hash[String, Set[String]]
+      attr_reader data_member_layouts: Hash[String, Array[Symbol]]
+
+      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_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
       attr_reader receiver_kind: Symbol
       attr_reader receiver_name: Symbol
@@ -39,8 +66,9 @@ module Rigor
 
     def self.empty: (?environment: Environment, ?source_path: String?) -> Scope
 
-    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?declared_types: Hash[untyped, Type::t], ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?source_path: String?) -> void
+    def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?) -> void
     def with_source_path: (String? path) -> Scope
+    def with_discovery: (DiscoveryIndex index) -> Scope
     def local: (String | Symbol name) -> Type::t?
     def ivar: (String | Symbol name) -> Type::t?
     def cvar: (String | Symbol name) -> Type::t?
@@ -49,30 +77,24 @@ 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 with_class_ivars: (Hash[String, Hash[Symbol, Type::t]] table) -> Scope
     def class_cvars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
-    def with_class_cvars: (Hash[String, Hash[Symbol, Type::t]] table) -> Scope
-    def with_program_globals: (Hash[Symbol, Type::t] table) -> Scope
-    def with_discovered_classes: (Hash[String, Type::Singleton] table) -> Scope
-    def with_in_source_constants: (Hash[String, Type::t] table) -> Scope
-    def with_discovered_methods: (Hash[String, Hash[Symbol, Symbol]] table) -> Scope
     def discovered_method?: (String | Symbol class_name, String | Symbol method_name, Symbol kind) -> bool
-    def with_discovered_def_nodes: (Hash[String, Hash[Symbol, untyped]] table) -> Scope
-    def with_discovered_def_sources: (Hash[String, Hash[Symbol, String]] table) -> Scope
     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
-    def with_discovered_method_visibilities: (Hash[String, Hash[Symbol, Symbol]] table) -> Scope
     def discovered_method_visibility: (String | Symbol class_name, String | Symbol method_name) -> Symbol?
     def superclass_of: (String | Symbol class_name) -> String?
-    def with_discovered_superclasses: (Hash[String, String] table) -> Scope
     def data_member_layout: (String | Symbol class_name) -> Array[Symbol]?
-    def with_data_member_layouts: (Hash[String, Array[Symbol]] table) -> Scope
     def includes_of: (String | Symbol class_name) -> Array[String]
-    def with_discovered_includes: (Hash[String, Array[String]] table) -> Scope
-    def with_discovered_class_sources: (Hash[String, Set[String]] table) -> Scope
     def indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Type::t?
     def with_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key, Type::t type) -> Scope
     def without_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Scope
@@ -83,7 +105,6 @@ module Rigor
     def without_method_chain_narrowings_for: (Symbol receiver_kind, String | Symbol receiver_name) -> Scope
     def with_fact: (Analysis::FactStore::Fact fact) -> Scope
     def with_self_type: (Type::t? type) -> Scope
-    def with_declared_types: (Hash[untyped, Type::t] table) -> Scope
     def facts_for: (?target: Analysis::FactStore::Target?, ?bucket: Symbol?) -> Array[Analysis::FactStore::Fact]
     def local_facts: (String | Symbol name, ?bucket: Symbol?) -> Array[Analysis::FactStore::Fact]
     def type_of: (untyped node, ?tracer: Inference::FallbackTracer?) -> Type::t

data/sig/rigor/source.rbs

@@ -16,6 +16,7 @@ module Rigor
       def self?.symbol_or_string_name: (untyped? node) -> String?
       def self?.symbol: (untyped? node) -> Symbol?
       def self?.symbol_name: (untyped? node) -> String?
+      def self?.symbol_named?: (untyped? node, String name) -> bool
       def self?.symbol_arguments: (untyped? call_node) -> Array[Symbol]
       def self?.symbol_arg: (untyped? call_node, Integer index) -> Symbol?
     end

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