rigortype 0.3.8 → 0.3.9

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

@@ -61,9 +61,33 @@ module Rigor
 
         COMMENT_LINE = /\A\s*#/
 
-        private_constant :ECHOED_ANNOTATION, :DECLARATION_LINE, :COMMENT_LINE
+        # The RBS annotation the synthesizer writes on every member whose type upstream DEFAULTED rather
+        # than read off an annotation (issue #823). Its meaning is normative in
+        # `docs/type-specification/rbs-extended.md`: the declaration states the member's presence and its
+        # parameters, and says nothing about what it returns, so the engine infers the return from the body
+        # instead of adopting the placeholder. `Rigor::RbsExtended.inferred_return?` is the reader.
+        INFERRED_RETURN_ANNOTATION = "rigor:v1:inferred-return"
 
-        # @param require_magic_comment [Boolean] when `false` (the default since ADR-93 WD1), the magic
+        # The stand-in type handed to upstream's `Writer#default_type`, and the whole reason this plugin can
+        # tell a defaulted type from an authored one. `RBS::Inline::Writer` substitutes `default_type`
+        # wherever the author wrote nothing — `return_type || default_type` in `RubyDef#method_overloads`,
+        # `attribute_type || default_type` in `RubyAttr#rbs` — and leaves an authored type alone. Rendering
+        # with a distinctive stand-in therefore makes "the author did not write this" a fact in the output
+        # rather than a guess about it: a member whose return renders as this name was defaulted, and one
+        # that renders `untyped` was WRITTEN `untyped` by its author (`#: (String) -> untyped`), which is a
+        # real contract and stays one.
+        #
+        # `default_type` is upstream's own public accessor for exactly this substitution, and `Writer.write`
+        # yields the writer to configure it, so nothing here reaches into upstream internals. The stand-in
+        # never survives into the contributed RBS — {#mark_inferred_returns} rewrites every occurrence back
+        # to `untyped` — which is not cosmetic: an undeclared type alias makes `RBS::DefinitionBuilder` raise
+        # `NoTypeFoundError` for the whole class, the same failure ADR-93 WD4's Finding 5 measured on
+        # `#:nodoc:`.
+        DEFAULTED_TYPE_NAME = :rigor__inline_defaulted
+
+        private_constant :ECHOED_ANNOTATION, :DECLARATION_LINE, :COMMENT_LINE, :DEFAULTED_TYPE_NAME
+
+        # @param require_magic_comment — when `false` (the default since ADR-93 WD1), the magic
         #   comment is not required and the file is processed only if it actually carries an annotation — see
         #   {#annotated?}. When `true` (the old ADR-32 WD2 gate), only files opening with
         #   `# rbs_inline: enabled` are processed, and upstream's opt-in semantics apply verbatim.
@@ -95,7 +119,8 @@ module Rigor
           return nil if parsed.nil?
 
           uses, decls, rbs_decls = parsed
-          rendered = reattach_declaration_annotations(::RBS::Inline::Writer.write(uses, decls, rbs_decls))
+          rendered = mark_inferred_returns(render_with_defaulted_marker(uses, decls, rbs_decls))
+          rendered = reattach_declaration_annotations(rendered)
           return nil if rendered.nil? || rendered.strip.empty?
 
           notices = unhonoured_annotations(result)
@@ -109,6 +134,106 @@ module Rigor
 
         private
 
+        # Upstream's writer, told to substitute {DEFAULTED_TYPE_NAME} instead of `untyped` wherever the
+        # author wrote no type. See that constant for why the distinction is worth a stand-in.
+        def render_with_defaulted_marker(uses, decls, rbs_decls)
+          marker = ::RBS::Types::Alias.new(
+            name: ::RBS::TypeName.new(namespace: ::RBS::Namespace.empty, name: DEFAULTED_TYPE_NAME),
+            args: [],
+            location: nil
+          )
+          ::RBS::Inline::Writer.write(uses, decls, rbs_decls) { |writer| writer.default_type = marker }
+        end
+
+        # Issue #823 — the sibling rule. ADR-93 WD1 gates synthesis on a file that carries an annotation;
+        # inside such a file upstream emits a full `def f: (untyped x) -> untyped` skeleton for every
+        # unannotated `def`, and Rigor trusts an accepted signature over body inference. So one `# @rbs`
+        # anywhere in a file used to retype every OTHER method in it to `untyped` — the same mechanism
+        # ADR-93 WD1 measured project-wide before the file gate landed (mail 26 → 42 diagnostics), just
+        # scoped to the annotated file. An annotation on one method must not change the typing of its
+        # siblings in either direction.
+        #
+        # The skeleton is kept — that is what PR #779's member-level drop got wrong, because a partially
+        # declared class reads to RBS as a fully declared one (32 `call.undefined-method` and 12
+        # `call.wrong-arity` on `new`, and 44 classes to `Dynamic[top]` behind cross-file references that
+        # stopped resolving). What changes is what the skeleton CLAIMS: a defaulted type slot is rewritten
+        # back to `untyped` and its member is annotated {INFERRED_RETURN_ANNOTATION}, so the declaration
+        # keeps the class's full method surface, `new`'s arity and every cross-file name, and states nothing
+        # about the return. The engine reads the annotation in `RbsDispatch` and falls through to the same
+        # body-inference tier an undeclared method takes.
+        #
+        # Two properties make the rewrite safe rather than clever:
+        #
+        # - the stand-in is a token this plugin injected, so replacing it is exact — it can only appear
+        #   where upstream substituted it (a comment echoing the same word would merely read `untyped`);
+        # - the lines to annotate come from `RBS::Parser` reading the writer's own output, not from a
+        #   pattern over it, and the replacement is length-preserving per line, so the parser's line numbers
+        #   still address the same members after it.
+        #
+        # Marking is best-effort and the rewrite is not: if the probe parse is skipped or fails, the file
+        # still ships with today's `untyped` skeleton rather than an unresolvable alias (see
+        # {DEFAULTED_TYPE_NAME}). That asymmetry is why the encoding guard is shaped the way it is. Invalid
+        # UTF-8 does not reach here today — the RDoc-directive scan above raises on it first, and {#call}'s
+        # rescue routes the file to WD6 — but the guarded parse is the one `RbsLoader.add_virtual_rbs`
+        # documents as HANG-prone on pre-4.1 rbs lexers, and a hang escapes every rescue there is. So the
+        # probe is skipped for a byte sequence it could hang on, while the substitution runs over bytes and
+        # therefore always completes.
+        def mark_inferred_returns(rendered)
+          return rendered if rendered.nil? || !rendered.b.include?(DEFAULTED_TYPE_NAME.to_s)
+
+          marked_lines = rendered.valid_encoding? ? defaulted_member_lines(rendered) : Set.new
+          scrubbed = rendered.b.gsub(DEFAULTED_TYPE_NAME.to_s, "untyped").force_encoding(rendered.encoding)
+          return scrubbed if marked_lines.empty?
+
+          scrubbed.lines.each_with_index.flat_map do |line, index|
+            next line unless marked_lines.include?(index + 1)
+
+            ["#{line[/\A[ \t]*/]}%a{#{INFERRED_RETURN_ANNOTATION}}\n", line]
+          end.join
+        end
+
+        # The 1-based line of every member in `rendered` whose return type (or, for an attribute, whose
+        # type) is the defaulted stand-in. A member's `location.start_line` is the line its `def` /
+        # `attr_*` keyword sits on, which is where the annotation has to go.
+        def defaulted_member_lines(rendered)
+          buffer = ::RBS::Buffer.new(name: "(rigor: inline defaulted-type probe)", content: rendered)
+          _, _directives, decls = ::RBS::Parser.parse_signature(buffer)
+          collect_defaulted_member_lines(decls, Set.new)
+        rescue ::StandardError
+          # The writer's own output failing to parse is a condition the loader already handles (ADR-32 WD6
+          # fail-soft drops the entry). Declining to mark here keeps that the only failure.
+          Set.new
+        end
+
+        def collect_defaulted_member_lines(nodes, lines)
+          nodes.each do |node|
+            next unless node.respond_to?(:members)
+
+            node.members.each do |member|
+              line = defaulted_member_line(member)
+              lines << line if line
+            end
+            collect_defaulted_member_lines(node.members.grep(::RBS::AST::Declarations::Base), lines)
+          end
+          lines
+        end
+
+        def defaulted_member_line(member)
+          case member
+          when ::RBS::AST::Members::MethodDefinition
+            return nil unless member.overloads.any? { |o| defaulted_type?(o.method_type.type.return_type) }
+          when ::RBS::AST::Members::Attribute
+            return nil unless defaulted_type?(member.type)
+          else
+            return nil
+          end
+          member.location&.start_line
+        end
+
+        def defaulted_type?(type)
+          type.is_a?(::RBS::Types::Alias) && type.name.name == DEFAULTED_TYPE_NAME
+        end
+
         # Re-attaches a class- or module-level `%a{…}` that upstream's writer dropped (#452).
         #
         # `RBS::Inline::Writer` emits a member's annotations as real annotation lines and a *declaration's*

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

@@ -20,9 +20,6 @@ module Rigor
 
         module_function
 
-        # @param path [String]
-        # @param root [Prism::Node]
-        # @return [Array<Diagnostic>]
         def diagnose(path:, root:)
           diagnostics = []
           ScopeWalker.collect_scopes(root).each do |outer|

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

@@ -45,13 +45,11 @@ module Rigor
         # ADR-52 slice 5a — every `let` / `subject` name declared anywhere in the file, across all describe
         # scopes. Feeds the plugin's `dynamic_return file_methods:` gate: the engine only consults the rule
         # for a call whose name appears here; the precise line-scoped resolution stays in `let_block_at`.
-        # @return [Array<Symbol>]
         def let_names
           @records.flat_map { |rec| rec.lets.keys }.uniq
         end
 
         # Resolves a `let` name at the given line by walking records innermost to outermost.
-        # @return [Prism::BlockNode, nil]
         def let_block_at(line, name)
           name_sym = name.to_sym
           records_at(line).reverse.each do |rec|
@@ -62,7 +60,6 @@ module Rigor
 
         # Resolves the `describe`-anchor constant name at the given line. The innermost describe with a
         # constant anchor wins; describe-with-String anchors are skipped.
-        # @return [String, nil]
         def describe_const_at(line)
           records_at(line).reverse.each do |rec|
             return rec.describe_const if rec.describe_const

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

@@ -30,12 +30,8 @@ module Rigor
 
         module_function
 
-        # @param block_node [Prism::BlockNode]
-        # @param describe_const [String, nil]
-        # @param factory_index [Object, nil] something responding to `find(factory_name)` and returning an
+        # @param factory_index — something responding to `find(factory_name)` and returning an
         #   entry that responds to `model_class`.
-        # @param environment [Rigor::Environment, nil]
-        # @return [Rigor::Type, nil]
         def resolve(block_node, describe_const:, factory_index:, environment:)
           tail = body_tail(block_node)
           return nil if tail.nil?

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

@@ -38,13 +38,12 @@ module Rigor
       module MatcherAnalyzer
         module_function
 
-        # @param call_node [Prism::CallNode] the call whose contribution we're computing. Returns nil when
+        # @param call_node — the call whose contribution we're computing. Returns nil when
         #   the call shape does not match `expect(local).to matcher`.
-        # @param environment [Rigor::Environment, nil] the surrounding environment used to resolve a
+        # @param environment — the surrounding environment used to resolve a
         #   matcher's class-name argument to a `Type::Nominal`. When nil, class-name resolution falls back
         #   to a bare `Nominal[<name>]` carrier (sound — the receiver constant may be a user class not in
         #   RBS).
-        # @return [Rigor::FlowContribution, nil]
         def contribution_for(call_node, environment:)
           verb = assertion_verb(call_node)
           return nil if verb.nil?

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

@@ -48,6 +48,7 @@ module Rigor
     class Rspec < Rigor::Plugin::Base
       manifest(
         id: "rspec",
+        target_gems: ["rspec-core"],
         version: "0.3.0",
         description: "Validates RSpec `let` / `subject` declarations within each scope; " \
                      "narrows expect(x).to <matcher> assertions downstream in `it` bodies; " \

data/plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails/have_http_status_analyzer.rb

@@ -40,9 +40,6 @@ module Rigor
         # The matcher violation for a single CallNode, or nil when the node is not a
         # `have_http_status(<int|symbol>)` matcher or its argument is statically valid. ADR-37: the engine
         # owns the walk, so this is per-node logic — no traversal here.
-        #
-        # @param call_node [Prism::Node]
-        # @return [Violation, nil]
         def violation_for(call_node)
           return nil unless call_to_matcher?(call_node)
 

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

@@ -39,6 +39,7 @@ module Rigor
     class RspecRails < Rigor::Plugin::Base
       manifest(
         id: "rspec-rails",
+        target_gems: ["rspec-rails"],
         version: "0.1.0",
         description: "Validates rspec-rails behavioral matchers (have_http_status floor)."
       )

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

@@ -8,6 +8,7 @@ module Rigor
     class SassC < Base
       manifest(
         id: "sassc",
+        target_gems: ["sassc"],
         version: "0.1.0",
         description: "Models SassC native bindings, nominal pointer typedefs, and struct unions.",
         signature_paths: ["sig"]

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

@@ -72,23 +72,15 @@ module Rigor
 
         module_function
 
-        # @param path [String]
-        # @param root [Prism::Node]
-        # @param model_index [Hash{String => Hash}, nil] the `:model_index` fact value — the flat
+        # @param model_index — the `:model_index` fact value — the flat
         #   `class_name => { table:, columns:, associations:, ... }` Hash `rigor-activerecord` publishes
         #   (ADR-9's "the value is data, not objects" contract; see `Activerecord#index_to_published_hash`).
         #   When nil the analyzer falls silent.
-        # @return [Array<Diagnostic>]
         # The matcher violations for a single call node (0..1), or `[]` when it is not a shoulda matcher,
         # sits outside any `describe <ModelConst>` block, or the model is unknown. ADR-37: the engine owns
         # the walk; the model anchor comes from the node-rule `NodeContext` ancestors (the innermost
         # enclosing `describe`-with-constant — nested const describes override, `describe ".method"`
         # string blocks inherit), exactly as the former recursive anchor propagation did.
-        #
-        # @param matcher_call [Prism::Node]
-        # @param ancestors [Array<Prism::Node>]
-        # @param model_index [Hash{String => Hash}, nil]
-        # @return [Array<Violation>]
         def violations_for(matcher_call:, ancestors:, model_index:)
           return [] if model_index.nil?
           return [] unless matcher_invocation?(matcher_call)

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

@@ -47,6 +47,7 @@ module Rigor
     class ShouldaMatchers < Rigor::Plugin::Base
       manifest(
         id: "shoulda-matchers",
+        target_gems: ["shoulda-matchers"],
         version: "0.1.0",
         description: "Validates shoulda-matchers matchers (validate_presence_of / belong_to / " \
                      "have_many / have_db_column / ...) against :model_index from " \

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

@@ -34,10 +34,6 @@ module Rigor
 
         # The worker-call violations for a single call node (0..2), or `[]` when the node is not a
         # `<Worker>.perform_*` entry call on a known worker. ADR-37: the engine owns the walk.
-        #
-        # @param call_node [Prism::Node]
-        # @param worker_index [WorkerIndex]
-        # @return [Array<Violation>]
         def violations_for(call_node:, worker_index:)
           return [] unless call_node.is_a?(Prism::CallNode) && entry_call?(call_node)
 

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

@@ -52,7 +52,7 @@ module Rigor
 
         module_function
 
-        # @param marker_modules [Array<String>] the modules a worker includes — the plugin's own
+        # @param marker_modules — the modules a worker includes — the plugin's own
         #   `worker_marker_modules:` config, so one project setting drives the arity check and these rows.
         def attributions(marker_modules)
           marker_modules.flat_map do |marker|

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

@@ -51,7 +51,7 @@ module Rigor
           @schedule_paths = schedule_paths
         end
 
-        # @return [Array<String>] the class names named by a `class:` key in a schedule entry, sorted and
+        # @return the class names named by a `class:` key in a schedule entry, sorted and
         #   unique. NOT yet intersected with the discovered workers — the caller does that.
         def worker_names
           names = Set.new

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

@@ -33,7 +33,6 @@ module Rigor
           @marker_modules = marker_modules.to_set { |name| strip_root(name.to_s) }
         end
 
-        # @return [WorkerIndex]
         def discover
           candidates = []
           ruby_files_under(@search_paths).each do |path|

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

@@ -39,8 +39,6 @@ module Rigor
         # never `"::WelcomeWorker"`; see {WorkerDiscoverer}), while a QUERY may legitimately arrive rooted:
         # `::WelcomeWorker.perform_async(1)` renders its receiver as `"::WelcomeWorker"`. The root marker is
         # dropped here, once, so no caller needs a `find(name) || find("::#{name}")` retry (#621).
-        #
-        # @return [Entry, nil]
         def find(class_name)
           @by_name[strip_leading_namespace(class_name.to_s)]
         end

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

@@ -54,6 +54,7 @@ module Rigor
     class Sidekiq < Rigor::Plugin::Base
       manifest(
         id: "sidekiq",
+        target_gems: ["sidekiq"],
         # Bumped 2026-08-16 — publishes `:reachability_roots` for `rigor unused` (ADR-102 WD3): the workers
         # a schedule file enqueues by name, which no `perform_async` call site writes down.
         # Bumped 2026-09-01 (#534 item 4) — the enqueue methods return the jid `String`.

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

@@ -51,6 +51,7 @@ module Rigor
     class Sinatra < Rigor::Plugin::Base
       manifest(
         id: "sinatra",
+        target_gems: ["sinatra"],
         version: "0.1.0",
         description: "Recognises Sinatra's class-level route DSL via ADR-16 Tier A.",
         block_as_methods: [

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

@@ -37,8 +37,7 @@ module Rigor
       #   run, so the same Prism node object is seen in both the `dynamic_return` rule and
       #   `diagnostics_for_file`.
       module AbsurdRecognizer
-        # @param call_node [Prism::CallNode]
-        # @return [Boolean] true when `call_node` is `T.absurd(x)`.
+        # @return true when `call_node` is `T.absurd(x)`.
         def self.absurd_call?(call_node)
           return false unless call_node.is_a?(Prism::CallNode)
           return false unless call_node.name == :absurd
@@ -50,9 +49,7 @@ module Rigor
           arguments&.size == 1
         end
 
-        # @param call_node [Prism::CallNode]
-        # @param scope [Rigor::Scope, nil]
-        # @return [Boolean] true when the discriminant has been narrowed to `bot` (the branch is
+        # @return true when the discriminant has been narrowed to `bot` (the branch is
         #   unreachable, so `T.absurd` is correct). The caller suppresses the `absurd-reachable` diagnostic
         #   in this case.
         def self.exhaustive?(call_node, scope)

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

@@ -53,10 +53,7 @@ module Rigor
 
         module_function
 
-        # @param call_node [Prism::CallNode]
-        # @param scope [Rigor::Scope]
-        # @param plugin_id [String] used for the contribution's `provenance.source_family`.
-        # @return [Rigor::FlowContribution, nil]
+        # @param plugin_id — used for the contribution's `provenance.source_family`.
         def recognize(call_node:, scope:, plugin_id:)
           return nil unless TypeTranslator.sorbet_t_namespaced?(call_node.receiver)
           return nil unless SORBET_ASSERTIONS.include?(call_node.name)

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

@@ -23,7 +23,6 @@ module Rigor
           @frozen_after_build = false
         end
 
-        # @param signature [MethodSignature]
         def record(signature)
           raise "Catalog already finalised" if @frozen_after_build
 
@@ -31,10 +30,9 @@ module Rigor
           @entries[key] = signature
         end
 
-        # @param class_name [String] the class / module that carries the mixin (`class Post; include Foo;
+        # @param class_name — the class / module that carries the mixin (`class Post; include Foo;
         #   end` records under `"Post"`).
-        # @param kind [:include, :extend]
-        # @param module_name [String] the textual name of the mixed-in module as it appeared at the
+        # @param module_name — the textual name of the mixed-in module as it appeared at the
         #   include / extend site (`"Foo"`, `"Foo::Bar"`, `"::Foo"`).
         def record_mixin(class_name:, kind:, module_name:)
           raise "Catalog already finalised" if @frozen_after_build
@@ -55,13 +53,11 @@ module Rigor
           freeze
         end
 
-        # @return [MethodSignature, nil]
         def lookup(class_name:, method_name:, kind:)
           @entries[key_for(class_name, method_name, kind)]
         end
 
-        # @param class_name [String]
-        # @return [Hash{Symbol => Array<String>}] frozen mapping `{ include: [...], extend: [...] }`.
+        # @return frozen mapping `{ include: [...], extend: [...] }`.
         #   Returns {EMPTY_MIXINS} when no mixins were recorded.
         def mixins_for(class_name)
           @mixins[class_name] || EMPTY_MIXINS
@@ -77,8 +73,6 @@ module Rigor
         # static assertion vocabulary), and the precise `(class, kind)` lookup stays in the rule block.
         # Computed fresh per call — the plugin memoises the resolved set, and `freeze!` freezes the
         # catalog itself so a lazy memo ivar here would raise.
-        #
-        # @return [Array<Symbol>]
         def method_names
           @entries.keys.map { |key| key[1] }.uniq
         end

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

@@ -26,10 +26,10 @@ module Rigor
 
         module_function
 
-        # @param root [Prism::Node] the file's program node.
-        # @param catalog [Catalog] mutable; signatures are recorded into it.
-        # @param path [String] file path used for diagnostic provenance.
-        # @return [Array<ParseError>] errors observed during the walk; empty when the file is sig-clean.
+        # @param root — the file's program node.
+        # @param catalog — mutable; signatures are recorded into it.
+        # @param path — file path used for diagnostic provenance.
+        # @return errors observed during the walk; empty when the file is sig-clean.
         def walk(root:, catalog:, path:)
           state = State.new(catalog: catalog, path: path)
           walk_node(root, state, lexical_path: [], in_singleton_class: false)

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

@@ -44,8 +44,7 @@ module Rigor
 
         module_function
 
-        # @param sig_call [Prism::CallNode] the `sig { ... }` / `sig do ... end` call.
-        # @return [ParseResult, ParseError]
+        # @param sig_call — the `sig { ... }` / `sig do ... end` call.
         def parse(sig_call)
           return ParseError.new(reason: :no_block, node: sig_call) if sig_call.block.nil?
 

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

@@ -30,8 +30,8 @@ module Rigor
 
         module_function
 
-        # @param contents [String] raw file contents.
-        # @return [Symbol] one of {VALID_LEVELS}; defaults to {DEFAULT_LEVEL} for sigil-less or
+        # @param contents — raw file contents.
+        # @return one of {VALID_LEVELS}; defaults to {DEFAULT_LEVEL} for sigil-less or
         #   malformed-sigil files.
         def detect(contents)
           return DEFAULT_LEVEL if contents.nil? || contents.empty?
@@ -52,14 +52,13 @@ module Rigor
           DEFAULT_LEVEL
         end
 
-        # @param level [Symbol]
-        # @return [Boolean] true when `# typed: ignore`. The harvest pipeline calls this to short-circuit
+        # @return true when `# typed: ignore`. The harvest pipeline calls this to short-circuit
         #   walking the file's AST.
         def ignored?(level)
           level == :ignore
         end
 
-        # @return [Boolean] true when `level` is at or above the `# typed: true` mark. Used by the
+        # @return true when `level` is at or above the `# typed: true` mark. Used by the
         #   `enforce_sigil` config gate (default `true`): with the gate on, only files marked `:true` /
         #   `:strict` / `:strong` contribute their sigs to the catalog. The `:false` (and sigil-less)
         #   levels still get walked (so RBI files outside the project can be loaded regardless), but their

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

@@ -52,8 +52,7 @@ module Rigor
 
         module_function
 
-        # @param node [Prism::Node, nil]
-        # @return [Rigor::Type] never `nil`; unrecognised forms degrade to `Type::Combinator.untyped`.
+        # @return never `nil`; unrecognised forms degrade to `Type::Combinator.untyped`.
         def translate(node)
           return Rigor::Type::Combinator.untyped if node.nil?
 
@@ -67,7 +66,6 @@ module Rigor
           end
         end
 
-        # @param node [Prism::ConstantReadNode]
         def translate_constant_read(node)
           name = node.name.to_s
           return Rigor::Type::Combinator.untyped if name.empty?
@@ -75,7 +73,6 @@ module Rigor
           Rigor::Type::Combinator.nominal_of(name)
         end
 
-        # @param node [Prism::ConstantPathNode]
         def translate_constant_path(node)
           name = constant_path_name(node)
           return degraded if name.nil?
@@ -233,7 +230,12 @@ module Rigor
 
             pairs << [element.key.unescaped.to_sym, translate(element.value)]
           end
-          Rigor::Type::Combinator.hash_shape_of(pairs)
+          # `.to_h`: `hash_shape_of` validates its argument is a Hash and raises `ArgumentError` on the
+          # array-of-pairs form, so `sig { returns({name: String}) }` degraded to `Dynamic[top]` through
+          # the plugin's rescue instead of producing a shape. Found by #673, when relaxing
+          # `call.argument-type-mismatch` to check the positional arguments of keyword-bearing
+          # signatures made the call site visible.
+          Rigor::Type::Combinator.hash_shape_of(pairs.to_h)
         end
 
         # Renders a constant-path node (`Foo::Bar`, `::Foo::Bar`) as a `::`-joined String. Mirrors the

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

@@ -57,6 +57,7 @@ module Rigor
     class Sorbet < Rigor::Plugin::Base
       manifest(
         id: "sorbet",
+        target_gems: ["sorbet-runtime"],
         version: "0.1.0",
         description: "Ingests Sorbet `sig` blocks as method-signature contributions.",
         config_schema: {
@@ -442,11 +443,10 @@ module Rigor
       EMPTY_CATALOG_BUNDLE = { catalog: Catalog.new.freeze!, sigil_by_path: {}, parse_errors_by_path: {} }.freeze
       private_constant :EMPTY_CATALOG_BUNDLE
 
-      # @param root [String] directory or single file.
-      # @param catalog [Catalog]
-      # @param sigil_by_path [Hash{String=>Symbol}] accumulator: harvested file → detected sigil level.
-      # @param parse_errors_by_path [Hash{String=>Array<Hash>}] accumulator: file → `{kind:,line:,column:}` tuples.
-      # @param extensions [Array<String>] file extensions to accept (e.g. `[".rb"]` for project source,
+      # @param root — directory or single file.
+      # @param sigil_by_path — accumulator: harvested file → detected sigil level.
+      # @param parse_errors_by_path — accumulator: file → `{kind:,line:,column:}` tuples.
+      # @param extensions — file extensions to accept (e.g. `[".rb"]` for project source,
       #   `[".rbi"]` for Sorbet RBI tree).
       def harvest_path(root, catalog, sigil_by_path, parse_errors_by_path, extensions)
         absolute = canonicalize(root)

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

@@ -43,6 +43,7 @@ module Rigor
     class Statesman < Rigor::Plugin::Base
       manifest(
         id: "statesman",
+        target_gems: ["statesman"],
         version: "0.1.0",
         description: "Validates state-machine transition references against declared states.",
         config_schema: {

data/sig/rigor/analysis/reachability/scan_cache.rbs

@@ -0,0 +1,12 @@
+module Rigor
+  module Analysis
+    module Reachability
+      class ScanCache
+        def self.open: (untyped, ?target_ruby: untyped) -> Rigor::Analysis::Reachability::ScanCache
+        def self.source_digest: () -> String
+        def initialize: (path: untyped, header: untyped) -> void
+        def save: () -> nil
+      end
+    end
+  end
+end

data/sig/rigor/cache.rbs

@@ -16,9 +16,8 @@ module Rigor
       def self.fetch: (loader: untyped, store: untyped) -> untyped
 
       # The generation cap this producer declares to `Cache::Store#evict!`
-      # (issue #151). `rigor sig-gen` infers the literal `2` from the base
-      # body; the contract is the wider `Integer`, since a subclass may
-      # override it.
+      # (issue #151). The base body answers `2`; the contract is the wider
+      # `Integer`, since the cap is a knob a subclass may turn.
       def self.generation_cap: () -> Integer
     end
   end

data/sig/rigor/environment.rbs

@@ -33,6 +33,7 @@ module Rigor
     def constant_for_name: (String | Symbol name) -> Type::t?
     def class_known?: (String | Symbol name) -> bool
     def rbs_module?: (String | Symbol name) -> bool
+    def singleton_extended_modules: (String | Symbol name) -> Array[String]
     def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
     def reflection: () -> untyped?
     def missing_rbs_gem_owner: (String | Symbol root_constant_name) -> String?
@@ -53,11 +54,14 @@ module Rigor
       attr_reader libraries: Array[String]
       attr_reader signature_paths: Array[String | _ToPath]
       attr_reader cache_store: untyped?
+      # sig-gen gap: #160 — sig-gen emits no `attr_reader` for the loader's readers; typed as the initializer stores it.
+      attr_reader deferred_signature_paths: Array[Pathname]
 
       def self.default: () -> RbsLoader
       def self.reset_default!: () -> void
       def self.build_env_for: (libraries: Array[String], signature_paths: Array[String | _ToPath]) -> untyped
       def self.vendored_gem_sig_paths: () -> Array[Pathname]
+      def self.capability_role_sig_paths: () -> ([Pathname] | [])
       def self.vendored_gem_names: () -> Array[String]
 
       def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath], ?cache_store: untyped?) -> void
@@ -72,6 +76,7 @@ module Rigor
       def project_declared_class?: (String | Symbol class_name) -> bool
       def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
       def ancestor_names_for: (String | Symbol class_name) -> Array[String]
+      def singleton_extended_module_names: (String | Symbol class_name) -> Array[String]
       def constant_type: (String name) -> Type::t?
       def constant_names: () -> Array[String]
       def each_known_class_name: () { (String name) -> void } -> untyped