rigortype 0.4.6 → 0.4.8

data/sig/rigor/plugin/effect_edge.rbs

@@ -11,7 +11,7 @@ module Rigor
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), and `initialize`
       # stores the result of the private `validate_receiver!` helper (#2312).
       attr_reader receiver: String
-      # sig-gen gap: #2321 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # sig-gen gap: #2325 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `String | Symbol | nil`),
       # stored as `method&.to_sym`.
       attr_reader method: Symbol?

data/sig/rigor/plugin/effect_entry_points.rbs

@@ -4,15 +4,15 @@ module Rigor
     # framework entry points (ADR-103 WD6). Frozen value object; {#globs} are deduplicated and
     # sorted in `initialize`.
     class EffectEntryPoints
-      # sig-gen gap: #2321 — `initialize` declares `name:` `untyped` (input `untyped`, looks deliberate; a declared
+      # sig-gen gap: #2325 — `initialize` declares `name:` `untyped` (input `untyped`, looks deliberate; a declared
       # type is authoring intent tracked by #2325, and only then does this row generate; coercion-facing: it takes
       # anything that answers `to_s`), so no input type reaches the reader.
       attr_reader name: String
-      # sig-gen gap: #2321 — `globs:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # sig-gen gap: #2325 — `globs:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `Array(globs)`, each `to_s`),
       # deduplicated and sorted in `initialize`.
       attr_reader globs: Array[String]
-      # sig-gen gap: #2321 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # sig-gen gap: #2325 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
       # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`).
       attr_reader why: String
 

data/sig/rigor/plugin/interfaces.rbs

@@ -0,0 +1,51 @@
+# ADR-128 — the plugin-facing structural interfaces: what a hook may call on the engine objects it receives.
+#
+# The criterion (ADR-128): a method is public plugin API only if it is declared on `Plugin::Base`, on one of the
+# interfaces below, or in a namespace `docs/internal-spec/public-api.md` lists as public. Being reachable at
+# runtime does not make a method public. `spec/rigor/plugin_boundary_spec.rb` gates the bundled plugins against
+# these member lists, so adding a member here is an API promise, and `public_api_drift_spec.rb` pins the sets.
+#
+# Each interface is backed by a concrete engine class (the `BACKING` table in `spec/support/plugin_boundary.rb`).
+# Engine signatures keep those concrete classes (ADR-128 WD5); an interface appears only at a plugin-facing
+# position, in `base.rbs`.
+module Rigor
+  module Plugin
+    # The scope a hook receives. Backed by `Rigor::Scope`, which has far more members (about 200); only these are
+    # promised. `environment` is non-nil, matching `Scope#environment`.
+    interface _Scope
+      def type_of: (::Prism::Node node) -> Rigor::Type::t
+      def self_type: () -> Rigor::Type::t?
+      def local: (String | Symbol name) -> Rigor::Type::t?
+      def source_path: () -> String?
+      def with_local: (String | Symbol name, Rigor::Type::t type) -> Rigor::Plugin::_Scope
+      def environment: () -> Rigor::Plugin::_Environment
+    end
+
+    # The project's RBS and class-registry handle, backed by `Rigor::Environment`.
+    interface _Environment
+      def nominal_for_name: (String | Symbol name) -> Rigor::Type::Nominal?
+      def rbs_module?: (String | Symbol name) -> bool
+    end
+
+    # The services container `Plugin::Base#init` / `#prepare` receive, backed by `Rigor::Plugin::Services`.
+    # `reflection` and `type` are public namespaces (`Rigor::Reflection`, `Rigor::Type::Combinator`) that a plugin
+    # also reaches by constant, so they are typed as those modules rather than narrowed to an interface.
+    interface _Services
+      def fact_store: () -> Rigor::Plugin::_FactStore
+      def configuration: () -> Rigor::Plugin::_Configuration
+      def reflection: () -> singleton(Rigor::Reflection)
+      def type: () -> singleton(Rigor::Type::Combinator)
+    end
+
+    # The per-run cross-plugin fact store, backed by `Rigor::Plugin::FactStore`.
+    interface _FactStore
+      def publish: (plugin_id: String | Symbol, name: Symbol, value: untyped) -> nil
+      def read: (plugin_id: String | Symbol, name: Symbol) -> untyped
+    end
+
+    # The project configuration, backed by `Rigor::Configuration`.
+    interface _Configuration
+      def paths: () -> Array[String]
+    end
+  end
+end

data/sig/rigor/plugin/io_boundary.rbs

@@ -4,7 +4,7 @@ class Rigor::Plugin::IoBoundary
   def file?: (untyped) -> bool
   def directory?: (untyped) -> bool
   def list_directory: (untyped) -> Array[String]
-  def list_directory_kinds: (untyped) -> Hash[String, untyped]
+  def list_directory_kinds: (untyped) -> Hash[String, Symbol]
   # Records a `:names` glob row (membership only); a caller needing a match's content `read_file`s it. A `..`
   # segment, a brace or a backslash in `pattern` raises `AccessDeniedError`.
   def glob: (untyped root, untyped pattern) -> Array[String]
@@ -14,7 +14,7 @@ class Rigor::Plugin::IoBoundary
   # whose parameter is undeclared.
   def refusal_summary: () -> { count: Integer, first_path: String?, nearest_root: String? }?
   def open_url: (untyped url) -> String
-  # Returns a frozen `Rigor::Cache::Descriptor` (no RBS yet -> untyped).
-  def cache_descriptor: () -> untyped
+  # The returned descriptor is frozen.
+  def cache_descriptor: () -> Rigor::Cache::Descriptor
   def replay: (untyped descriptor) -> nil
 end

data/sig/rigor/plugin/manifest.rbs

@@ -18,7 +18,7 @@ class Rigor::Plugin::Manifest
   def config_schema: () -> untyped
   def config_defaults: () -> Hash[String, untyped]
   def target_gems: () -> Array[String]
-  # sig-gen gap: #2321 — written by a private `assign_*` helper whose parameters are undeclared (`initialize` hands
+  # sig-gen gap: #2418 — written by a private `assign_*` helper whose parameters are undeclared (`initialize` hands
   # its fields to such helpers); each write is a derived expression (`dup.freeze`, `map`), so the helper's parameter
   # types alone would not generate it.
   def template_globs: () -> Array[String]
@@ -35,31 +35,31 @@ class Rigor::Plugin::Manifest
   def hkt_registrations: () -> untyped
   def hkt_definitions: () -> untyped
   def signature_paths: () -> Array[String]
-  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_protocol_contracts!` requires every element
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_protocol_contracts!` requires every element
   # `is_a?(ProtocolContract)`.
   def protocol_contracts: () -> Array[Rigor::Plugin::ProtocolContract]
   # ADR-32 WD6/WD12 — any object responding to `call`, and its result is a documented multi-shape
   # outcome (`String` / nil / `[:error, msg]` / `[:ok, src, msgs]`), not `String?` — `untyped` is the
   # honest claim until the outcome has a sig'd shape.
   def source_rbs_synthesizer: () -> untyped
-  # sig-gen gap: #2321 — same shape as `template_globs`: the validator (`validate_additional_initializers!`) requires
+  # sig-gen gap: #2418 — same shape as `template_globs`: the validator (`validate_additional_initializers!`) requires
   # every element `is_a?(AdditionalInitializer)`, so the element type is hand-written.
   def additional_initializers: () -> Array[Rigor::Plugin::AdditionalInitializer]
 
-  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_root!` bounds the spelling.
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_root!` bounds the spelling.
   def effect_root: () -> String?
-  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_labels!` requires non-empty `String`
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_labels!` requires non-empty `String`
   # elements.
   def effect_labels: () -> Array[String]
-  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_attributions!` requires every element
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_attributions!` requires every element
   # `is_a?(EffectAttribution)`.
   def effect_attributions: () -> Array[Rigor::Plugin::EffectAttribution]
-  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_edges!` requires `is_a?(EffectEdge)`.
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_edges!` requires `is_a?(EffectEdge)`.
   def effect_edges: () -> Array[Rigor::Plugin::EffectEdge]
-  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_entry_points!` requires
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_entry_points!` requires
   # `is_a?(EffectEntryPoints)`.
   def effect_entry_points: () -> Array[Rigor::Plugin::EffectEntryPoints]
-  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_ancestry!` requires `is_a?(EffectAncestry)`.
+  # sig-gen gap: #2418 — same shape as `template_globs`: `validate_effect_ancestry!` requires `is_a?(EffectAncestry)`.
   def effect_ancestry: () -> Array[Rigor::Plugin::EffectAncestry]
 
   # The identity opening a root when this plugin's labels join the run's vocabulary: the

data/sig/rigor/plugin/node_context.rbs

@@ -0,0 +1,21 @@
+module Rigor
+  module Plugin
+    # ADR-37 slice 1d — the lexical context of a node, the fifth argument of a `node_rule` block.
+    class NodeContext
+      EMPTY: nil
+
+      attr_reader ancestors: Array[::Prism::Node]
+
+      def initialize: (Array[::Prism::Node] ancestors) -> void
+      # The three finders return the innermost ancestor of a given kind: a `DefNode`, a `ClassNode` or
+      # `ModuleNode`, and a `CallNode` respectively. `enclosing_def` is sig-gen's proposal (#2719, #2914); the other
+      # two blocks (`||`, `&&`) are not a single class test, so their bodies still infer `Prism::Node?`. A narrower
+      # declaration would be an unmarked sig-gen divergence (ADR-107).
+      # Known Steep 2.0.0 limitation (surfaced by `library "prism"`, #2718): it does not narrow `rfind` through an
+      # `is_a?` block, so it warns that the body is `Prism::Node?`; the declaration keeps the precise shape.
+      def enclosing_def: () -> (Prism::DefNode | nil)
+      def enclosing_module: () -> ::Prism::Node?
+      def enclosing_block: (Symbol method_name) -> ::Prism::Node?
+    end
+  end
+end

data/sig/rigor/plugin/protocol_contract.rbs

@@ -23,11 +23,8 @@ module Rigor
         def self.[]: (index: Integer, type_name: String) -> instance | (Integer index, String type_name) -> instance
       end
 
-      # sig-gen gap: #2321 — `attr_reader` rows over ivars `initialize` assigns from expressions derived
-      # from its parameters (`dup.freeze`/`to_sym`), so the stored types are hand-written.
       attr_reader path_glob: String
 
-      # sig-gen gap: #2321 — as above (`to_sym` normalizes the accepted Symbol|String).
       attr_reader method_name: Symbol
 
       # `singleton ? true : false` collapses any truthy input to bool — sig-gen already infers
@@ -38,12 +35,11 @@ module Rigor
       # parameters are undeclared (it guarantees `Array[ParamType]`).
       attr_reader param_types: Array[ParamType]
 
-      # sig-gen gap: #2321 — as above (nil or a non-empty `dup.freeze`d String).
       attr_reader return_type_name: String?
 
-      # sig-gen gap: #2321 — as above (`VALID_SEVERITIES.include?(to_sym)` bounds the stored value
-      # to the three declared literals; a derived-write credit would generate `Symbol`, not the literal union, so
-      # this row needs the declared literals kept as intent).
+      # authored: the declared literal union is intent. `initialize` stores `severity.to_sym` after
+      # `validate_severity!` bounds it to `VALID_SEVERITIES`, so the value is one of the three literals, but sig-gen
+      # generates `Symbol` for it, not the union.
       attr_reader severity: :error | :warning | :info
 
       # `method_name`/`severity` accept String too (both are `to_sym`'d); `param_types` entries are

data/sig/rigor/reflection.rbs

@@ -19,5 +19,42 @@ module Rigor
     def self?.class_type_param_names: (String | Symbol class_name, ?scope: Scope) -> Array[Symbol]
     def self?.discovered_class?: (String | Symbol class_name, ?scope: Scope) -> bool
     def self?.discovered_method?: (String | Symbol class_name, String | Symbol method_name, ?kind: Symbol, ?scope: Scope) -> bool
+    def self?.project_method_defined: (String | Symbol? class_name, String | Symbol method_name, kind: :instance | :singleton, source: :def | :discovered | :either, scope: Scope) -> Trinary
+    def self?.rbs_method_defined: (String | Symbol? class_name, String | Symbol method_name, kind: :instance | :singleton, scope: Scope) -> Trinary
+    def self?.ancestry_reaches: (String | Symbol? class_name, Array[String | Symbol] ancestor_names, kind: :instance | :singleton, scope: Scope) -> Trinary
+    # sig-gen gap: #2302 — the collector's `@classes = []` is grown by `<<`, so sig-gen reads the array as `Array[untyped]`.
+    def self?.class_declarations_in: (Prism::Node root) ?{ (DeclaredCall call) -> void } -> Array[ClassDeclaration]
+
+    # One `class` header of a parsed file, as `class_declarations_in` reports it.
+    class ClassDeclaration < Data
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so sig-gen proposes `untyped`; the shape is hand-written.
+      attr_reader name: String
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so sig-gen proposes `untyped`; the shape is hand-written.
+      attr_reader nesting: Array[String]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so sig-gen proposes `untyped`; the shape is hand-written.
+      attr_reader node: Prism::ClassNode
+
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so the constructor's keywords are `untyped` in sig-gen.
+      def self.new: (name: String, nesting: Array[String], node: Prism::ClassNode) -> instance
+                  | (String name, Array[String] nesting, Prism::ClassNode node) -> instance
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so the constructor's keywords are `untyped` in sig-gen.
+      def self.[]: (name: String, nesting: Array[String], node: Prism::ClassNode) -> instance
+                 | (String name, Array[String] nesting, Prism::ClassNode node) -> instance
+    end
+
+    # One call `class_declarations_in` yields: the `Prism::CallNode` and the class or module it lexically sits in.
+    class DeclaredCall < Data
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so sig-gen proposes `untyped`; the shape is hand-written.
+      attr_reader node: Prism::CallNode
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so sig-gen proposes `untyped`; the shape is hand-written.
+      attr_reader owner: String?
+
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so the constructor's keywords are `untyped` in sig-gen.
+      def self.new: (node: Prism::CallNode, owner: String?) -> instance
+                  | (Prism::CallNode node, String? owner) -> instance
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so the constructor's keywords are `untyped` in sig-gen.
+      def self.[]: (node: Prism::CallNode, owner: String?) -> instance
+                 | (Prism::CallNode node, String? owner) -> instance
+    end
   end
 end

data/sig/rigor/scope.rbs

@@ -18,6 +18,7 @@ module Rigor
     # its bare cause (issue #1302).
     attr_reader optimistic_locals: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark]
     attr_reader optimistic_ivars: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark]
+    attr_reader construction_facts: Hash[Symbol, Set[untyped]]
     attr_reader repeated_or_writes: Hash[untyped, bool]
     # sig-gen gap: #2323 — the same reader shape; `Inference::MatchRebinding::Frame` carries no signature.
     attr_reader match_frame: untyped
@@ -29,7 +30,7 @@ module Rigor
     attr_reader struct_fold_safe_locals: Set[Symbol]
     attr_reader opaque_block_self: bool
     # Issue #1759 — `:refinement` (REFINEMENT_BLOCK_SELF) directly in a `refine X do … end` block body.
-    attr_reader block_self_unknown: bool | :refinement
+    attr_reader block_self_unknown: bool | :refinement | :preserved
     attr_reader singleton_class_body: bool
     attr_reader lexical_nesting: Array[String]?
     # Issue #1429 — a guard's narrowing of a constant reference, keyed by its spelling.
@@ -64,14 +65,24 @@ module Rigor
     # authored: the list holds module names and the `InEffectRefinements::UNKNOWN` Symbol; sig-gen reads the delegated
     # return through an unsigned class as untyped.
     def in_effect_refinements: (untyped node, ?Array[String] declared) -> Array[String | Symbol]
+    # authored: the element is an `Array` led by its Symbol kind by contract (`[:defines, name]`, `[:ivar_set, name]`); a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def discovered_global_write_census: () -> Set[Array[untyped]]
     def discovered_includes: () -> Hash[String, Array[String]]
     # Issue #1123 — the instance-ancestor-ORDER table beside the include one.
     def discovered_prepends: () -> Hash[String, Array[String]]
     def discovered_extends: () -> Hash[String, Array[String]]
+    # authored: the element is `String` (a source path) by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def discovered_class_sources: () -> Hash[String, Set[String]]
+    # authored: the element is `String` (a source path) by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def constant_sources: () -> Hash[String, Set[String]]
+    # authored: the element is `String` (a constant's last segment) by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def published_constant_names: () -> Set[String]
+    # authored: the element is `String` (a constant name) by contract; a Set's element type stays `untyped` in sig-gen (#2177, #2317), so the generator
+    # would never propose it.
     def local_constant_names: () -> Set[String]
     # sig-gen gap: #1150 — the `Data.define` table it reads carries no type, so sig-gen skips the return; the shape is hand-written.
     def bound_constant_names: (String name) -> Array[String]
@@ -89,6 +100,12 @@ module Rigor
     def run_generation: () -> Object?
     def record_dynamic_origin: (untyped node, Symbol cause) -> Scope
     def record_optimistic_origin: (untyped node, Symbol cause) -> Scope
+    # sig-gen gap: #2840 — the reader returns through a sentinel `equal?` guard over `Hash#fetch`; sig-gen emits nothing.
+    def dynamic_origin: (untyped node) -> Symbol?
+    # sig-gen gap: #2840 — the reader returns through a sentinel `equal?` guard over `Hash#fetch`; sig-gen emits nothing.
+    def optimistic_origin: (untyped node) -> Symbol?
+    # sig-gen gap: #2840 — the reader returns through a sentinel `equal?` guard over `Hash#fetch`; sig-gen emits nothing.
+    def void_origin: (untyped node) -> Inference::VoidOrigin?
 
     def record_void_origin: (untyped node, Inference::VoidOrigin origin) -> Scope
 
@@ -208,12 +225,16 @@ 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?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?, ?opaque_block_self: bool, ?block_self_unknown: bool | :refinement, ?singleton_class_body: bool, ?dynamic_origins: Hash[untyped, Symbol], ?indexed_narrowings: Hash[IndexedKey, Type::t], ?method_chain_narrowings: Hash[ChainKey, Type::t], ?declaration_sourced: Set[[Symbol, Symbol] | [Symbol, Symbol, Symbol]], ?published_constant_sourced: Set[[Symbol, Symbol]], ?struct_fold_safe_locals: Set[Symbol], ?lexical_nesting: Array[String]?, ?local_origins: Hash[Symbol, Symbol], ?ivar_origins: Hash[Symbol, Symbol], ?void_origins: Hash[untyped, Inference::VoidOrigin], ?plugin_typed_calls: Hash[untyped, bool], ?optimistic_origins: Hash[untyped, Symbol], ?optimistic_locals: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark], ?optimistic_ivars: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark], ?repeated_or_writes: Hash[untyped, bool], ?match_frame: untyped, ?constant_narrowings: Hash[String, Type::t], ?guard_records: Hash[[Symbol, Symbol | String], Type::t], ?bot_guard_classes: Hash[[Symbol, Symbol | String], Array[String]], ?declared_refinements: Array[String | Symbol]) -> 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?, ?opaque_block_self: bool, ?block_self_unknown: bool | :refinement | :preserved, ?singleton_class_body: bool, ?dynamic_origins: Hash[untyped, Symbol], ?indexed_narrowings: Hash[IndexedKey, Type::t], ?method_chain_narrowings: Hash[ChainKey, Type::t], ?declaration_sourced: Set[[Symbol, Symbol] | [Symbol, Symbol, Symbol]], ?published_constant_sourced: Set[[Symbol, Symbol]], ?struct_fold_safe_locals: Set[Symbol], ?lexical_nesting: Array[String]?, ?local_origins: Hash[Symbol, Symbol], ?ivar_origins: Hash[Symbol, Symbol], ?void_origins: Hash[untyped, Inference::VoidOrigin], ?plugin_typed_calls: Hash[untyped, bool], ?optimistic_origins: Hash[untyped, Symbol], ?optimistic_locals: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark], ?optimistic_ivars: Hash[Symbol, Symbol | Inference::OptimisticOrigin::BoundMark], ?construction_facts: Hash[Symbol, Set[Symbol]], ?repeated_or_writes: Hash[untyped, bool], ?match_frame: untyped, ?constant_narrowings: Hash[String, Type::t], ?guard_records: Hash[[Symbol, Symbol | String], Type::t], ?bot_guard_classes: Hash[[Symbol, Symbol | String], Array[String]], ?declared_refinements: Array[String | Symbol]) -> void
     def with_source_path: (String? path) -> Scope
     def with_struct_fold_safe: (Set[Symbol] locals) -> Scope
     def with_lexical_nesting: (Array[String]? chain) -> Scope
     def struct_fold_safe?: (String | Symbol name) -> bool
+    def entering_block_without_gradual_marks: (Prism::Node block_node) -> Scope
     def entering_opaque_block: () -> Scope
+    PRESERVED_BLOCK_SELF: :preserved
+    def entering_self_preserving_block: () -> Scope
+    def walked_block_self_unknown?: () -> bool
     def block_self_unknown?: () -> bool
     REFINEMENT_BLOCK_SELF: :refinement
     def refinement_block_self?: () -> bool
@@ -229,10 +250,15 @@ module Rigor
     def global: (String | Symbol name) -> Type::t?
     def local_origin: (String | Symbol name) -> Symbol?
     def ivar_origin: (String | Symbol name) -> Symbol?
+    # sig-gen gap: #2403 — the `Hash#[]` miss in `bound_cause` is lost across the call; sig-gen says `Symbol`.
     def optimistic_local: (String | Symbol name) -> Symbol?
+    # sig-gen gap: #2403 — the `Hash#[]` miss in `bound_cause` is lost across the call; sig-gen says `Symbol`.
     def optimistic_ivar: (String | Symbol name) -> Symbol?
     def optimistic_local_miss: (String | Symbol name) -> Object?
     def optimistic_ivar_miss: (String | Symbol name) -> Object?
+    def construction_fact?: (String | Symbol name, ?Symbol fact) -> bool
+    def project_method_name?: (untyped) -> (false | true)
+    def with_construction_fact: (untyped, untyped) -> Rigor::Scope
     def with_local: (String | Symbol name, Type::t type) -> Scope
     def with_rejoined_locals: (untyped) -> Rigor::Scope
     def with_ivar: (String | Symbol name, Type::t type) -> Scope
@@ -271,8 +297,6 @@ module Rigor
     def seed_declaration_sourced_global: (String | Symbol name, Type::t type) -> Scope
     def with_global_copy_marks: (String | Symbol name, Array[String | Symbol] globals) -> Scope
     def without_local_declaration_marks: (String | Symbol name) -> Scope
-    # sig-gen gap: #2322 — the records come out of `@declaration_sourced`, whose set now types; `ref[2]` reads as
-    # `Symbol?`, but the `filter_map` over it answers `Array[untyped]`.
     def declaration_sourced_global_copies: (String | Symbol name) -> Array[Symbol]
     def with_declaration_sourced_local: (String | Symbol name, Type::t type) -> Scope
     def with_local_declaration_mark: (String | Symbol name) -> Scope
@@ -283,6 +307,9 @@ module Rigor
     def with_inferred_param_mark: (String | Symbol name) -> Scope
     def without_inferred_param_mark: (String | Symbol name) -> Scope
     def inferred_param?: (String | Symbol name) -> bool
+    def with_gradual_narrowing_mark: (String | Symbol name) -> Scope
+    def gradual_narrowing?: (String | Symbol name) -> bool
+    def gradual_narrowing_names: () -> Array[Symbol]
     def forget_match_globals: () -> Scope
     def untyped_match_globals: () -> Scope
     def match_globals_bound?: () -> bool
@@ -307,6 +334,13 @@ module Rigor
     def def_node_slot: (untyped class_name, untyped method_name, ?Symbol kind) -> untyped
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> ::Prism::DefNode?
     def user_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([::Prism::DefNode, String] | [nil, nil])
+    # Returns `[opaque_flag, recorder_keys]`. Steep 2.0.0 cannot verify a tuple through the
+    # `Array#freeze` on the returned literal and reports a MethodBodyTypeMismatch warning; the
+    # declaration keeps the precise shape because `rigor sig-gen` proves it.
+    def subclassing_opacity: () -> [false | true, Array[untyped]]
+    # authored: each owner is a frozen `[class_name, open_to_override]` pair. sig-gen types the lazily built
+    # `(owners ||= []) <<` array as `Array[untyped]`; the body keeps it to avoid `Hash#filter_map`'s per-entry pair.
+    def user_instance_def_owners: (untyped) -> Array[Array[untyped]]
     def discovered_method_through_ancestors?: (String | Symbol? class_name, String | Symbol method_name, Symbol kind, ?name_memo: Hash[untyped, untyped]) -> bool
     def external_ancestor_name_candidates: (String | Symbol class_name, ?name_memo: Hash[untyped, untyped]) -> Array[Array[String]]
     def enqueue_ancestors: (String current, Array[String] queue, Hash[untyped, untyped] name_memo, ?mixins: bool) -> void
@@ -320,6 +354,7 @@ module Rigor
     def known_user_class?: (String | Symbol name) -> bool
     def singleton_def_for: (String | Symbol class_name, String | Symbol method_name) -> ::Prism::DefNode?
     def module_function_def?: (untyped, untyped) -> (false | true)
+    def module_function_row_def?: (untyped, untyped) -> (false | true)
     def singleton_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([::Prism::DefNode, String] | [nil, nil])
     def user_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def user_singleton_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
@@ -330,6 +365,9 @@ module Rigor
     # sig-gen gap: #1167 — the instance-side twin: the same untyped `call_node`, the same untyped-return skip.
     def instance_def_shadows_call?: (String | Symbol class_name, String | Symbol method_name, untyped call_node) -> bool
     def top_level_def_for: (String | Symbol method_name) -> ::Prism::DefNode?
+    def ownerless_definition?: (untyped, ?top_level: untyped) -> (false | true)
+    def toplevel_def_ambiguity: (String | Symbol method_name) -> (:contested | :several | :main_singleton | :aliased | :anonymous | :object)?
+    def declared_class?: (String | Symbol class_name) -> bool
     def bindable_top_level_def_for: (String | Symbol method_name) -> ::Prism::DefNode?
     def toplevel?: () -> bool
     def discovered_method_visibility: (String | Symbol class_name, String | Symbol method_name) -> Symbol?
@@ -337,6 +375,7 @@ module Rigor
     def data_member_layout: (String | Symbol class_name) -> Array[Symbol]?
     def struct_member_layout: (String | Symbol class_name) -> { members: Array[Symbol], keyword_init: bool }?
     def includes_of: (String | Symbol class_name) -> Array[String]
+    def prepends_of: (String | Symbol class_name) -> Array[String]
     # sig-gen gap: #2302 — `names = []` grown by `concat` reads `Array[untyped]`, so the element type is
     # hand-written, matching {#includes_of}.
     def singleton_extends_of: (String | Symbol class_name) -> Array[String]

data/sig/rigor/trinary.rbs

@@ -22,6 +22,7 @@ module Rigor
     def and: (Trinary other) -> Trinary
     def or: (Trinary other) -> Trinary
     def ==: (untyped other) -> bool
+    alias eql? ==
     def hash: () -> Integer
     def to_s: () -> String
     def inspect: () -> String

data/sig/rigor/type.rbs

@@ -56,8 +56,8 @@ module Rigor
     end
 
     class Dynamic
-      attr_reader static_facet: Type::t
-      def initialize: (Type::t static_facet) -> void
+      attr_reader static_facet: Type::t | Interface
+      def initialize: (Type::t | Interface static_facet) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> "untyped"
       def top: () -> Trinary
@@ -169,6 +169,11 @@ module Rigor
       def inspect: () -> String
     end
 
+    # ADR-130 — a `Rigor::Plugin` interface, carried only as a `Dynamic`'s facet (`Dynamic[Rigor::Plugin::_Scope]`), so
+    # it is not a member of `Type::t`. Declared for that name only; its members are read from the source.
+    class Interface
+    end
+
     class Union
       attr_reader members: Array[Type::t]
       def initialize: (Array[Type::t] members) -> void
@@ -446,7 +451,8 @@ module Rigor
       def self?.top: () -> Top
       def self?.bot: () -> Bot
       def self?.untyped: () -> Dynamic
-      def self?.dynamic: (Type::t static_facet) -> Dynamic
+      def self?.untyped?: (Type::t? type) -> bool
+      def self?.dynamic: (Type::t | Interface static_facet) -> Dynamic
       def self?.nominal_of: (Module | String class_name_or_object, ?type_args: Array[Type::t]) -> Nominal
       def self?.singleton_of: (Module | String class_name_or_object) -> Singleton
       def self?.constant_of: (untyped value) -> Constant

data/sig/rigor.rbs

@@ -165,8 +165,9 @@ module Rigor
       # sig-gen gap: #1008 — `result` is populated by `collect_return_summaries` mutating it by
       # reference from a sibling method; sig-gen folds only the `{}` seed and the empty-memo early
       # return, so it proposes the seed shape instead of the honest, usually-non-empty contract.
-      # Keys are `[path, "Class#method"]` pairs; values are `{ keys:, returns:, effects: }` bundles.
-      def return_summaries: () -> Hash[[String, String], Hash[Symbol, untyped]]
+      # Keys are `[path, "Class#method"]` pairs; values are `{ keys:, returns:, effects: }` bundles, or
+      # nil for a def whose keys the run cannot list. nil for a pool run, which harvests none (#3160).
+      def return_summaries: () -> Hash[[String, String], Hash[Symbol, untyped]?]?
       # ADR-67 — `[class_name, method_name, kind] => { param_name => Type }`.
       def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
       def collect_param_inference_table: (untyped files) -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]

data/skills/rigor-ask/SKILL.md

@@ -130,6 +130,7 @@ A good hand-off is two or three sentences of orientation plus the pointer:
 - baseline reduction → **`rigor-baseline-reduce`** · coverage holes → **`rigor-protection-uplift`**
 - a missing gem/DSL → **`rigor-plugin-author`** · monkey-patch clusters → **`rigor-monkeypatch-resolve`**
 - about to *write* a type (RBS, `#:`, a Sorbet `sig`, a YARD tag, a doc sentence) → **`rigor-type-oracle`**
+- auditing, fixing, or contributing RBS declarations (a gem's `sig/`, a gem_rbs_collection entry) → **`rigor-rbs-contract`**
 
 When in doubt, give less and point — it respects the user's "three skills
 to remember" promise and keeps each answer to the part only `rigor-ask`

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

@@ -68,10 +68,10 @@ install`), every plugin bundled in the toolchain is readable source.
 Use it as a worked-example library throughout this skill:
 
 ```sh
-rigor plugin list                              # all bundled + example plugins, with paths
-rigor plugin print rigor-activesupport-core-ext  # a plugin's main source, inline
-rigor plugin path  rigor-units                 # the dir, to browse with your file tool
-rigor plugin root                              # gem root + public API (lib/rigor/plugin.rb)
+rigor plugin                                     # all bundled + example plugins, with paths
+rigor plugin rigor-activesupport-core-ext        # a plugin's main source, inline
+rigor plugin --path rigor-units                  # the dir, to browse with your file tool
+rigor plugin --root                              # gem root + public API (lib/rigor/plugin.rb)
 ```
 
 `rigor plugin` (singular) browses the toolchain's plugins; `rigor

data/skills/rigor-plugin-author/references/02-walker-and-types.md

@@ -254,8 +254,8 @@ Two ways to wire the RBS, depending on how the plugin is packaged:
    read one as a worked example:
 
    ```sh
-   rigor plugin print rigor-activesupport-core-ext   # see manifest + sig/ layout
-   rigor plugin path  rigor-activesupport-core-ext   # then browse its sig/ dir
+   rigor plugin rigor-activesupport-core-ext         # see manifest + sig/ layout
+   rigor plugin --path rigor-activesupport-core-ext  # then browse its sig/ dir
    ```
 
 2. **A project-private plugin** — the manifest field still works, but
@@ -280,9 +280,9 @@ They compose — many plugins ship both.
 
 > **Browse a real plugin instead of guessing the API.** Because Rigor
 > is installed on disk (`mise` / `gem install`), every bundled plugin's
-> source is readable as a worked example. `rigor plugin list` shows
-> them all with absolute paths; `rigor plugin print <name>` inlines a
-> plugin's main source; `rigor plugin root` points at the engine source
+> source is readable as a worked example. `rigor plugin` shows
+> them all with absolute paths; `rigor plugin <name>` inlines a
+> plugin's main source; `rigor plugin --root` points at the engine source
 > and the public `Rigor::Plugin::Base` API. When the prose here is
 > thinner than you need, read a shipped plugin that does the same thing.
 

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

@@ -74,9 +74,9 @@ Rigor is installed on disk, so both the plugin under review and the
 worked-example plugins are readable source:
 
 ```sh
-rigor plugin list                 # every bundled + example plugin, with paths
-rigor plugin print rigor-<id>     # a plugin's main source, inline
-rigor plugin path  rigor-<id>     # its directory, to browse
+rigor plugin                    # every bundled + example plugin, with paths
+rigor plugin rigor-<id>         # a plugin's main source, inline
+rigor plugin --path rigor-<id>  # its directory, to browse
 ```
 
 The **authoritative** authoring surface — the one this review scores

data/skills/rigor-project-init/references/01-detect.md

@@ -56,6 +56,7 @@ bundle exec rbs collection install
 Use `bundle exec` when `rbs` appears in `Gemfile` or `Gemfile.lock`
 (the common case — Steep / rbs_rails workflows put it there). If `rbs`
 is not in the Gemfile, use the bare `rbs collection install` instead.
+If `bundle exec rbs` runs an `rbs` that `gem:rigortype` put on `PATH` instead of the project's, see the [install guide's note on `rbs` shadowing](https://github.com/rigortype/rigor/blob/master/docs/install.md#case-a--mise-is-available-recommended).
 
 Ask the user for permission before running, since this installs files
 into `.gem_rbs_collection/` (a generated directory that belongs in

data/skills/rigor-project-init/references/03-baseline-and-bugs.md

@@ -170,6 +170,8 @@ bundle exec rbs collection install   # if rbs is in Gemfile
 # or: rbs collection install
 ```
 
+If `bundle exec rbs` runs an `rbs` that `gem:rigortype` put on `PATH` instead of the project's, see the [install guide's note on `rbs` shadowing](https://github.com/rigortype/rigor/blob/master/docs/install.md#case-a--mise-is-available-recommended).
+
 Re-run `rigor triage`. If the `gem-without-rbs` count drops, carry
 the new, smaller count into Phase 7.
 
@@ -218,8 +220,19 @@ baseline is a ceiling, not a blanket. Reducing it later is the
 Recommend committing `.rigor-baseline.yml` — it documents project
 state; list it in the Final step's file inventory.
 
+**Rule-less diagnostics cannot be baselined.** A file Prism cannot
+parse (a parse error), a missing `paths:` entry or an internal error
+yields a diagnostic with no rule, so it has no `(file, rule)` bucket.
+The summary then prints a second line ("N diagnostic(s) have no rule
+(parse, path or internal errors) in M file(s) and cannot be
+baselined") and lists the files; the command still exits 0. Acknowledge
+mode reaches a green `rigor check` only after those files are fixed or
+added to `exclude:`, or the bad `paths:` entry is removed. Do that
+before wiring `baseline:`, then re-run `rigor baseline regenerate`.
+
 Print the suppression summary for the user: "N diagnostics recorded
-as baseline; M will surface on subsequent runs."
+as baseline; M will surface on subsequent runs." Take N from the
+`covering N diagnostic(s)` count, and count the unbaselineable ones in M.
 
 ## Phase 8 — Surface real bugs & offer escalation
 
@@ -386,7 +399,9 @@ information and Rigor has no built-in coverage. In order:
 
 1. `bundle exec rbs collection install` (bare `rbs collection install`
    if `rbs` is not in the project's Gemfile) — pulls community RBS for
-   the gem if it exists. Re-run triage afterwards.
+   the gem if it exists. Re-run triage afterwards. If `bundle exec rbs`
+   runs a `gem:rigortype` `rbs` instead of the project's, see the
+   [install guide's note on `rbs` shadowing](https://github.com/rigortype/rigor/blob/master/docs/install.md#case-a--mise-is-available-recommended).
 2. `dependencies.source_inference:` in `.rigor.dist.yml` — opt the
    gem into Rigor inferring `Dynamic`-typed returns from its source.
 3. If the gem is widely used and genuinely warrants first-class

data/skills/rigor-project-init/references/06-agent-contract.md

@@ -28,13 +28,13 @@ rigor skill --full rigor-type-oracle
 ```
 
 Its `references/02-agents-md-fragment.md` section carries the paragraph
-and the five bullets. Copy that block **verbatim** — including its
+and the six bullets. Copy that block **verbatim** — including its
 single-long-line shape, which is deliberate (some renderers turn a
 newline inside a paragraph into a line break).
 
-Do not paraphrase it from memory, and do not shorten it: the five bullets
+Do not paraphrase it from memory, and do not shorten it: the six bullets
 are the load-bearing part — expression, method signature, parameter,
-the gap rule, and provenance.
+the gap rule, provenance, and the declared-`void` contract.
 
 ## Where it goes
 
@@ -44,7 +44,7 @@ the gap rule, and provenance.
 | Only `CLAUDE.md` exists | Append it there. |
 | Both exist | Put it in `AGENTS.md`. Add `@AGENTS.md` to `CLAUDE.md` only if it is not already pulled in. |
 | Neither exists | **Create `AGENTS.md`** with this as its first section. |
-| A types / type-checking section already exists | Merge into it; keep the five bullets intact. Never write a second, competing rule. |
+| A types / type-checking section already exists | Merge into it; keep the six bullets intact. Never write a second, competing rule. |
 
 Never overwrite unrelated content. If the project already states a rule
 about type authorship that contradicts this one, stop and show the user