rigortype 0.3.7 → 0.3.9

data/lib/rigor/cli/skill_describe.rb

@@ -2,6 +2,8 @@
 
 require "yaml"
 
+require_relative "../plugin_gap_advisory"
+
 module Rigor
   class CLI
     # The presence-only project-state probe behind `rigor skill describe` (ADR-73 WD2). It stats files and opens only
@@ -17,19 +19,11 @@ module Rigor
       # RBS into the signature paths, so its presence is the signal that the gem-RBS gap has been addressed.
       RBS_COLLECTION_LOCKFILE = "rbs_collection.lock.yaml"
 
-      # `Gemfile.lock` substrings that mark a Rails app, and the bundled Rails-family plugin ids — used to spot a
-      # configured Rails project that has not enabled any Rails plugin (a `rigor-plugin-tune` cue).
-      RAILS_LOCK_MARKERS = %w[railties actionpack activerecord actioncable].freeze
-      RAILS_PLUGIN_MARKERS = %w[
-        rigor-activerecord rigor-actionpack rigor-actionmailer rigor-activejob
-        rigor-rails-routes rigor-rails-i18n rigor-actioncable rigor-activestorage rigor-rails
-      ].freeze
-
       def initialize(root)
         @root = root
       end
 
-      # @return [Hash] the presence-only state the recommendation routes on.
+      # @return the presence-only state the recommendation routes on.
       def to_h
         config = CONFIG_FILENAMES.find { |name| File.file?(File.join(@root, name)) }
         {
@@ -38,7 +32,7 @@ module Rigor
           sig: File.directory?(File.join(@root, "sig")),
           gems: File.file?(File.join(@root, "Gemfile.lock")),
           rbs_collection: File.file?(File.join(@root, RBS_COLLECTION_LOCKFILE)),
-          rails_unconfigured: rails_unconfigured?(config),
+          plugins_unconfigured: plugins_unconfigured?(config),
           ci: ci_state,
           editor: editor_state,
           mcp: mcp_state
@@ -47,24 +41,26 @@ module Rigor
 
       private
 
-      # True when Rails is in `Gemfile.lock` but the (present) config enables no Rails plugin — so `rigor-plugin-tune`
-      # (wiring the ActiveRecord / routes / i18n plugins) buys more than community RBS would (the 20260620 field trial's
-      # strap case). Only fires on an already-configured project; an un-configured Rails app routes to
-      # `rigor-project-init`, which selects the plugins itself.
-      def rails_unconfigured?(config)
+      # ADR-96 WD2 — true when the project depends on gems that bundled plugins model and enables none of those
+      # plugins, so `rigor-plugin-tune` buys more than community RBS would (the 20260620 field trial's strap
+      # case). Reads each plugin's `target_gems:` rather than the Rails-only table it replaces, so the cue
+      # covers every framework Rigor ships a plugin for. Only fires on an already-configured project; an
+      # un-configured app routes to `rigor-project-init`, which selects the plugins itself.
+      def plugins_unconfigured?(config)
         return false if config.nil?
 
-        lock = File.join(@root, "Gemfile.lock")
-        return false unless File.file?(lock) && file_mentions_any?(lock, RAILS_LOCK_MARKERS)
-
-        !file_mentions_any?(File.join(@root, config), RAILS_PLUGIN_MARKERS)
+        plugins = configured_plugins(File.join(@root, config))
+        PluginGapAdvisory.unconfigured?(project_root: @root, plugins: plugins)
       end
 
-      def file_mentions_any?(path, markers)
-        content = File.read(path)
-        markers.any? { |marker| content.include?(marker) }
+      # The probe reads the config file itself rather than {Rigor::Configuration}: it must stay a
+      # presence-only probe, and `Configuration.load` applies defaults (including the ADR-93 auto-wired
+      # `rigor-rbs-inline` entry) that have nothing to do with the question asked here.
+      def configured_plugins(path)
+        data = YAML.safe_load_file(path, permitted_classes: [], aliases: true)
+        data.is_a?(Hash) ? Array(data["plugins"]) : []
       rescue StandardError
-        false
+        []
       end
 
       # `:wired` (a CI config mentions `rigor`), `:unwired` (a CI config exists but does not), or `:none`.
@@ -121,9 +117,9 @@ module Rigor
       # The entry-point SKILL itself — excluded from the catalogue because it is the skill being run, not a destination.
       ENTRY_POINT_SKILL = "rigor-next-steps"
 
-      # Adoption-journey order for the catalogue and the order the recommendation decision tree walks. `rigor-ask` sits
-      # last: it is the journey-agnostic "answer a question about Rigor" companion the agent can offer at any point,
-      # never a presence-recommended step.
+      # Adoption-journey order for the catalogue and the order the recommendation decision tree walks. The last two are
+      # journey-agnostic companions the agent can offer at any point, never presence-recommended steps:
+      # `rigor-type-oracle` fires on an event (being about to write a type), and `rigor-ask` on a question about Rigor.
       CATALOG_ORDER = %w[
         rigor-project-init
         rigor-rbs-setup
@@ -137,12 +133,13 @@ module Rigor
         rigor-plugin-author
         rigor-upgrade
         rigor-doctor
+        rigor-type-oracle
         rigor-ask
       ].freeze
 
-      # @param skills [Array<Hash>] discovered skills, each `{name:, path:}`.
-      # @param root [String] project root to probe (defaults to the cwd).
-      # @param deep [Boolean] opt into `--deep`: run a real `rigor check` and let its result pick the headline. Off by
+      # @param skills — discovered skills, each `{name:, path:}`.
+      # @param root — project root to probe (defaults to the cwd).
+      # @param deep — opt into `--deep`: run a real `rigor check` and let its result pick the headline. Off by
       #   default, and off is ADR-73 WD2's contract — see {SkillDeepProbe} for why the whole analysis path lives
       #   behind this one flag and in its own file.
       def initialize(skills:, root: Dir.pwd, deep: false)
@@ -151,7 +148,7 @@ module Rigor
         @deep = deep
       end
 
-      # @return [String] the full describe report.
+      # @return the full describe report.
       def render
         catalog = catalog_skills
         state = ProjectStateProbe.new(@root).to_h
@@ -202,14 +199,18 @@ module Rigor
       def recommended_name_and_reason(state)
         if state.fetch(:config).nil?
           ["rigor-project-init", "this project has no Rigor configuration yet — start here."]
-        elsif state.fetch(:rails_unconfigured)
+        elsif state.fetch(:plugins_unconfigured)
           ["rigor-plugin-tune",
-           "Rails is in your Gemfile.lock but no Rails plugins are enabled — wire them so " \
-           "ActiveRecord / routes / i18n calls resolve (a bigger win here than community RBS)."]
-        elsif state.fetch(:gems) && !state.fetch(:rbs_collection)
-          ["rigor-rbs-setup", "your gems ship no community RBS yet — install it so Rigor stops typing them as Dynamic."]
+           "your Gemfile declares gems Rigor ships plugins for and none is enabled — wire them so " \
+           "those framework calls resolve (a bigger win here than community RBS)."]
+        # ADR-73's second `rbs-setup` priority-softening case (2026-09-10): CI wiring is presence-only and
+        # side-effect-free, while community-RBS install is network-bound (`rbs collection install` hits
+        # rubygems.org). A configured project earns the cheap, local win first — checked ahead of the RBS
+        # gap rather than after it.
         elsif state.fetch(:ci) != :wired
           ["rigor-ci-setup", "Rigor is configured but not wired into CI — lock in the regression guard."]
+        elsif state.fetch(:gems) && !state.fetch(:rbs_collection)
+          ["rigor-rbs-setup", "your gems ship no community RBS yet — install it so Rigor stops typing them as Dynamic."]
         # A present baseline is deliberately NOT a recommendation trigger. A baseline is a healthy, finished onboarding
         # state, not a problem to work off; pushing every baselined project to "reduce it" turns a working build into a
         # chore and tempts scattering `# rigor:disable` through the code to make a number go down — means over ends.

data/lib/rigor/cli/trace_command.rb

@@ -12,7 +12,7 @@ require_relative "../inference/flow_tracer"
 require_relative "../inference/scope_indexer"
 require_relative "command"
 require_relative "trace_renderer"
-require_relative "probe_environment"
+require_relative "../project_environment"
 
 module Rigor
   class CLI
@@ -30,7 +30,7 @@ module Rigor
       DEFAULT_KINDS = %i[bind union dispatch].freeze
       VERBOSE_KINDS = (%i[enter result] + DEFAULT_KINDS).freeze
 
-      # @return [Integer] CLI exit status.
+      # @return CLI exit status.
       def run
         options = parse_options
         file = @argv.first
@@ -92,10 +92,10 @@ module Rigor
       end
 
       # Mirrors the single-file path `rigor type-of` takes: the plugin-aware environment (so a trace replays the
-      # same dispatch `rigor check` would, including plugin-synthesized RBS — see {ProbeEnvironment}), an empty
+      # same dispatch `rigor check` would, including plugin-synthesized RBS — see {ProjectEnvironment}), an empty
       # seed scope, one statement-level evaluation of the whole program — but recorded under the FlowTracer.
       def record_events(root, file, configuration)
-        environment = ProbeEnvironment.build(configuration: configuration, source_files: [file])
+        environment = ProjectEnvironment.build(configuration: configuration, source_files: [file])
         scope = Scope.empty(environment: environment, source_path: file)
         Inference::FlowTracer.record { scope.evaluate(root) }
       end

data/lib/rigor/cli/trace_renderer.rb

@@ -28,9 +28,8 @@ module Rigor
       BODY_HEIGHT_MIN = 3    # never shrink the source window below this
       DEFAULT_SIZE = [24, 80].freeze
 
-      # @param out [IO]
-      # @param source [String] the traced file's source.
-      # @param file [String] display path.
+      # @param source — the traced file's source.
+      # @param file — display path.
       def initialize(out:, source:, file:)
         @out = out
         @source = source
@@ -38,11 +37,11 @@ module Rigor
         @lines = source.lines.map(&:chomp)
       end
 
-      # @param events [Array<Rigor::Inference::FlowTracer::Event>] the
+      # @param events — the
       #   pre-filtered frame list (the command owns kind filtering).
-      # @param delay [Float, nil] seconds between frames (autoplay);
+      # @param delay — seconds between frames (autoplay);
       #   nil = step on key press when interactive.
-      # @param interactive [Boolean] whether to clear/redraw and wait.
+      # @param interactive — whether to clear/redraw and wait.
       def play(events, delay: nil, interactive: false)
         @rows, @cols = interactive ? terminal_size : DEFAULT_SIZE
         @interactive = interactive

data/lib/rigor/cli/triage_command.rb

@@ -22,7 +22,7 @@ module Rigor
       USAGE = "Usage: rigor triage [options] [paths]"
       DEFAULT_SECTIONS = %i[distribution selectors hotspots hints].freeze
 
-      # @return [Integer] CLI exit status (always 0).
+      # @return CLI exit status (always 0).
       def run
         options = parse_options
         configuration = Configuration.load(options.fetch(:config))

data/lib/rigor/cli/type_of_command.rb

@@ -15,7 +15,7 @@ require_relative "../source/node_children"
 require_relative "type_of_renderer"
 require_relative "command"
 require_relative "options"
-require_relative "probe_environment"
+require_relative "../project_environment"
 
 module Rigor
   class CLI
@@ -46,7 +46,7 @@ module Rigor
       LINE_ENUMERATION_CAP = 40
       private_constant :LINE_ENUMERATION_CAP
 
-      # @return [Integer] CLI exit status.
+      # @return CLI exit status.
       def run
         options = parse_options
         buffer = Options.resolve_buffer_binding(options, err: @err)
@@ -111,8 +111,12 @@ module Rigor
         return 1 if parse_errors?(parse_result, file)
 
         # Built with no tracer attached — it would otherwise double-record fallback events with the per-node
-        # `type_of` calls below.
-        scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
+        # `type_of` calls below. `with_source_path(file)` (like `annotate` and `trace` already do) matters
+        # beyond diagnostics attribution: a plugin `dynamic_return file_methods:` rule (ADR-52 slice 5a,
+        # e.g. rigor-rspec's `let`-binding resolver, #921) gates on `scope.source_path` and fails closed
+        # when it is nil — an unset source_path silently declined every such rule under this command.
+        scope_index = Inference::ScopeIndexer.index(parse_result.value,
+                                                    default_scope: base_scope.with_source_path(file))
         locator = Source::NodeLocator.new(source: source, root: parse_result.value)
         lines = indexed_targets.filter_map { |target, _index| target.line if target.column.nil? }
         line_nodes, line_totals = collect_line_nodes(parse_result.value, lines)
@@ -196,12 +200,12 @@ module Rigor
 
       # Builds the plugin-aware environment relative to the probed file, so the reported type matches what `rigor
       # check` computes for the same position — including types synthesized from inline RBS annotations by the
-      # ADR-93 auto-wired `rigor-rbs-inline` plugin (see {ProbeEnvironment} for the #162 misattribution this
+      # ADR-93 auto-wired `rigor-rbs-inline` plugin (see {ProjectEnvironment} for the #162 misattribution this
       # closes). The probed file is threaded as the synthesizer's `source_files:`. Project-RBS auto-detection
       # roots at CWD today; future work will walk parent directories to find the enclosing `Gemfile`/`*.gemspec`
       # so probes against files outside the current process's CWD still see the right `sig/` tree.
       def project_environment(files, configuration)
-        ProbeEnvironment.build(configuration: configuration, source_files: files)
+        ProjectEnvironment.build(configuration: configuration, source_files: files)
       end
 
       def file_exists?(file)

data/lib/rigor/cli/type_scan_command.rb

@@ -11,7 +11,7 @@ require_relative "../scope"
 require_relative "type_scan_renderer"
 require_relative "type_scan_report"
 require_relative "command"
-require_relative "probe_environment"
+require_relative "../project_environment"
 require_relative "coverage_scan"
 
 module Rigor
@@ -26,7 +26,7 @@ module Rigor
 
       LocatedEvent = Data.define(:file, :event)
 
-      # @return [Integer] CLI exit status.
+      # @return CLI exit status.
       def run
         options = parse_options
         paths = collect_paths(@argv, command_name: "type-scan")
@@ -89,9 +89,9 @@ module Rigor
       # Builds the plugin-aware environment that auto-detects `<cwd>/sig` by default and honours the
       # configuration's `libraries:` / `signature_paths:` keys when present. The scanned `paths` are threaded as
       # the plugin `source_rbs_synthesizer` inputs so coverage reflects the same synthesized RBS `rigor check`
-      # sees (see {ProbeEnvironment}).
+      # sees (see {ProjectEnvironment}).
       def project_environment(configuration, source_files)
-        ProbeEnvironment.build(configuration: configuration, source_files: source_files)
+        ProjectEnvironment.build(configuration: configuration, source_files: source_files)
       end
 
       def scan_one(path, scanner, accumulator, configuration)

data/lib/rigor/cli/unused_command.rb

@@ -14,7 +14,7 @@ require_relative "../analysis/reachability/project_files"
 require_relative "../cache/store"
 require_relative "options"
 require_relative "command"
-require_relative "probe_environment"
+require_relative "../project_environment"
 
 module Rigor
   class CLI
@@ -219,15 +219,23 @@ module Rigor
       # declaration, which produced three of redmine's artifacts from a single initializer. A name the bundled
       # (non-project) environment already knows is not ours to call unused. The project's own `sig/` is
       # deliberately excluded from this environment, so a project class that ships a signature stays owned.
+      # That exclusion is the ONLY thing withheld: the dependency-discovery axes (issue #882, the shape of
+      # #821) must be passed, because "outside the project" is exactly what they describe. Without the
+      # bundle's per-gem `sig/` and an installed `rbs collection`, a gem-declared class the project reopens
+      # is unknown to this environment, reads as project-owned, and lands in the candidate list — a false
+      # positive in a report whose measured precision cannot afford one.
       #
       # The cache store makes the environment a Marshal restore instead of a cold RBS build on every
       # invocation — the same ADR-54 slot `rigor check` reads, keyed apart by this environment's own
-      # (sig-less) descriptor. The report only ever asks "is this name known", which the cached
+      # (sig-less) descriptor. The discovered bundle and collection directories ride in the loader's
+      # signature paths, so the descriptor digests them and this slot still cannot be served a run whose
+      # dependency sources differ. The report only ever asks "is this name known", which the cached
       # environment answers identically: the one thing the cache degrades is `RBS::Location`, and no
       # location is read here.
       def foreign_predicate(configuration)
         env = Environment.for_project(libraries: configuration.libraries, signature_paths: [],
-                                      cache_store: cache_store(configuration))
+                                      cache_store: cache_store(configuration),
+                                      **ProjectEnvironment.dependency_discovery_options(configuration))
         ->(fqn) { !env.singleton_for_name(fqn).nil? }
       rescue StandardError
         ->(_fqn) { false }

data/lib/rigor/cli/upgrade_command.rb

@@ -13,7 +13,7 @@ module Rigor
     class UpgradeCommand < Command
       USAGE = "Usage: rigor upgrade [options]"
 
-      # @return [Integer] CLI exit status.
+      # @return CLI exit status.
       def run
         @out.puts("rigor upgrade: No migration target available yet (ADR-50 WD7, queued).")
         @out.puts("Current version: #{Rigor::VERSION}")

data/lib/rigor/cli.rb

@@ -12,6 +12,7 @@ require_relative "analysis/result"
 require_relative "cli/options"
 require_relative "cli/diagnostic_formats"
 require_relative "ci_detector"
+require_relative "analysis/check_rules/rule_ids"
 
 module Rigor
   # The CLI class is a dispatcher: each `run_*` method delegates to a command-specific class once the command grows
@@ -20,6 +21,21 @@ module Rigor
   class CLI # rubocop:disable Metrics/ClassLength
     EXIT_USAGE = 64
 
+    # Issue [#609](https://github.com/rigortype/rigor/issues/609) — a run the analyzer could not finish.
+    # Distinct from `1` (the analysis ran and reported diagnostics) so a CI step can tell "your code has
+    # findings" from "Rigor died and this report is not an account of anything".
+    EXIT_INTERNAL_ERROR = 70
+
+    # The exceptions that mean "the process is out of a resource, and the backtrace names nothing
+    # actionable": `SystemStackError` from an ancestry walk that never terminates, `NoMemoryError` from a
+    # runaway allocation. Neither is a `StandardError`, so every rescue between here and the raise site
+    # declines them by design — the whole point of those rescues is to convert a per-file or per-plugin
+    # failure into a diagnostic, and a process running out of stack is not per-file. Left uncaught they
+    # abort with Ruby's own ~40-frame dump, which is non-zero (so a CI gate does catch it) but says
+    # neither that Rigor is at fault nor that the report on disk is empty. `Interrupt`, `SignalException`
+    # and `SystemExit` stay out: those are the user's answer, not a failure.
+    FATAL_ERRORS = [SystemStackError, NoMemoryError].freeze
+
     # The published location of `schemas/rigor-config.schema.json`, written into the `.rigor.yml` that
     # `rigor init` generates so an editor validates the file as the user types.
     #
@@ -95,10 +111,28 @@ module Rigor
       # register presets have loaded) would each need their own rescue at their own point.
       @err.puts("rigor: #{e.message}")
       EXIT_USAGE
+    rescue *FATAL_ERRORS => e
+      report_fatal_error(e)
+      EXIT_INTERNAL_ERROR
     end
 
     private
 
+    # One `rigor:` line naming the failure, then the innermost frames — enough to route a bug report,
+    # without the full dump the raise would otherwise print. The "no report" sentence is the part a user
+    # acts on: the crash usually happens with a redirect in place, so the artifact a CI step goes on to
+    # read is an empty file rather than a missing one.
+    def report_fatal_error(error)
+      @err.puts("rigor: analysis aborted: #{error.class}: #{error.message}")
+      Array(error.backtrace).first(FATAL_BACKTRACE_FRAMES).each { |frame| @err.puts("  from #{frame}") }
+      @err.puts("  Rigor could not finish this run, so its report is EMPTY rather than clean — do not")
+      @err.puts("  read this exit status as a passing check.")
+      @err.puts("  This is a defect in Rigor; please report it at https://github.com/rigortype/rigor/issues.")
+    end
+
+    FATAL_BACKTRACE_FRAMES = 5
+    private_constant :FATAL_BACKTRACE_FRAMES
+
     def dispatch(command)
       handler = HANDLERS[command]
       return arm_jit_deadline { send(handler) } if handler
@@ -169,6 +203,30 @@ module Rigor
       @out.puts "  3. Run `rigor check` to analyse your code."
     end
 
+    # Word-wraps `CheckRules::ALL_RULES` into a comma-separated, `#`-commented block for `init_template`, so the
+    # listed rule ids cannot drift from the catalogue the way a hand-picked subset did (#920) — every rule and only
+    # a rule actually in `ALL_RULES` gets named here.
+    def rule_ids_comment
+      prefix = "#                "
+      max_width = 78 - prefix.length
+      ids = Analysis::CheckRules::ALL_RULES
+      lines = []
+      current = +""
+      ids.each_with_index do |id, index|
+        token = "#{id}#{index == ids.length - 1 ? '.' : ','}"
+        if current.empty?
+          current = token
+        elsif current.length + 1 + token.length <= max_width
+          current << " " << token
+        else
+          lines << current
+          current = token
+        end
+      end
+      lines << current unless current.empty?
+      lines.map { |line| "#{prefix}#{line}" }.join("\n")
+    end
+
     # Renders the starter `.rigor.yml` body. The template serialises `Configuration::DEFAULTS` (so the on-disk file
     # round-trips through `Configuration.load`) and prepends a short header that points the user at the keys they are
     # most likely to want to edit.
@@ -187,11 +245,10 @@ module Rigor
         #                See https://github.com/rigortype/rigor/tree/master/plugins
         #                for production plugins (rigor-activerecord, rigor-sorbet, …).
         # - disable:     list of `rigor check` rule identifiers to
-        #                silence project-wide. The shipped rules are
-        #                call.undefined-method, call.wrong-arity,
-        #                call.argument-type-mismatch,
-        #                call.possible-nil-receiver, dump.type,
-        #                assert.type-mismatch, flow.always-raises.
+        #                silence project-wide. Every rule id Rigor
+        #                ships (run `rigor explain <rule>` for what
+        #                each one catches):
+        #{rule_ids_comment}
         #                A bare family token (`call`, `flow`,
         #                `assert`, `dump`, `def`) wildcards every
         #                rule under that prefix. Legacy unprefixed
@@ -320,7 +377,10 @@ module Rigor
         @err.puts "Install it with: gem install rigor-playground"
         return EXIT_USAGE
       end
-      Rigor::CLI::PlaygroundCommand.new(@argv[1..], @out, @err).run
+      # `run` shifts the verb off `@argv` before dispatching, so the handler receives the arguments
+      # already. Slicing here dropped the first one — `rigor playground --port=4000` served the
+      # default port, and a bare `rigor playground` passed `nil` into a command that iterates it.
+      Rigor::CLI::PlaygroundCommand.new(@argv, @out, @err).run
     end
 
     def run_skill
@@ -383,11 +443,13 @@ module Rigor
                      (opt-in; effects update/check/diff/explain)
           explain    Print the description of one or all CheckRules
           diff       Compare current diagnostics to a saved baseline JSON
+          baseline   Manage the baseline file (baseline generate/regenerate/dump/drift/prune)
           sig-gen    Emit RBS skeletons inferred from .rb sources
           lsp        Run the Rigor Language Server (LSP) over stdio
           mcp        Run the Rigor MCP server over stdio
           triage     Summarise diagnostics: distribution, hotspots, hints
           coverage   Report type-precision coverage (precise vs Dynamic ratio)
+          unused     Report unreferenced classes, modules and constants as removal candidates
           plugins    Report activation status of every configured plugin
           plugin     Browse bundled plugin source as worked examples (list/path/print/root)
           playground Start the browser playground (requires rigor-playground gem)

data/lib/rigor/config_audit.rb

@@ -18,6 +18,11 @@ module Rigor
   # never written. This module surfaces each such entry up front so the cause is visible
   # instead of inferred.
   #
+  # {.bundled_plugin_signature_path_warnings} widens that by one step, to a value that
+  # resolves to *part* of what it looks like. It belongs here because the symptom is the
+  # same one — a cluster of `call.undefined-method` on working code, traceable to a config
+  # line nothing in the output names.
+  #
   # Every check is held to the same bar that {SignaturePathAudit} set: it mirrors the
   # loader's own acceptance test, so a warning means the loader really did load nothing, and
   # it never fires on a setup that works. In particular the rule-token check only flags a
@@ -27,8 +32,8 @@ module Rigor
   # a typo.
   module ConfigAudit
     # One config-level finding. `kind` discriminates the source key (`:signature_path`,
-    # `:library`, `:disabled_rule`, `:severity_override`, `:bundler_bundle_path`,
-    # `:bundler_lockfile`, `:rbs_collection_lockfile`); `fields` carries the kind-specific
+    # `:bundled_plugin_signature_path`, `:library`, `:disabled_rule`, `:severity_override`,
+    # `:bundler_bundle_path`, `:bundler_lockfile`, `:rbs_collection_lockfile`); `fields` carries the kind-specific
     # structured data merged into {#to_h} for JSON consumers.
     Warning = Data.define(:kind, :message, :fields) do
       def to_h
@@ -36,13 +41,12 @@ module Rigor
       end
     end
 
-    # @param configuration [Rigor::Configuration]
-    # @param project_root [String] the directory the run's relative bundler / collection
+    # @param project_root — the directory the run's relative bundler / collection
     #   paths resolve against (the CLI's CWD), used only by the explicit-path checks.
-    # @return [Array<Warning>]
     def self.warnings(configuration, project_root: Dir.pwd)
       unknown_key_warnings(configuration) +
         signature_path_warnings(configuration) +
+        bundled_plugin_signature_path_warnings(configuration) +
         library_warnings(configuration) +
         rule_token_warnings(configuration) +
         explicit_path_warnings(configuration, project_root)
@@ -100,6 +104,27 @@ module Rigor
       end
     end
 
+    # The one member of this module whose subject is a configured value that resolves to
+    # *something*: a `signature_paths:` entry loading a bundled plugin's own `sig/` while
+    # `plugins:` never names that plugin (issue #697). The RBS arrives, its manifest does not,
+    # and the declarations that manifest marks deliberately partial (ADR-26 `open_receivers:`)
+    # are then read as complete — so the symptom is this module's usual one, a cluster of
+    # high-confidence `call.undefined-method` firings on code that runs, with nothing pointing
+    # at the config line that caused them.
+    #
+    # It is a warning and not a fix on purpose. Teaching the check rules to recognise this
+    # route would be a fourth way for a class to be open-receiver protected, and settling
+    # where that membership belongs is [#660](https://github.com/rigortype/rigor/issues/660)'s
+    # question; until it is answered, the honest move is to make the misconfiguration loud
+    # rather than to grow the mechanism. The false positive itself still fires.
+    def self.bundled_plugin_signature_path_warnings(configuration)
+      routes = SignaturePathAudit.bundled_plugin_routes(configuration.signature_paths, configuration.plugins)
+      routes.map do |route|
+        Warning.new(kind: :bundled_plugin_signature_path, message: route.message,
+                    fields: { "path" => route.path, "gem" => route.gem })
+      end
+    end
+
     # `libraries:` entries RBS does not recognise. Uses the same
     # `RBS::EnvironmentLoader#has_library?` guard the loader filters through
     # ({Environment::RbsLoader} `build_env_for`), so a flagged name is exactly one the loader

data/lib/rigor/configuration/severity_profile.rb

@@ -167,20 +167,20 @@ module Rigor
       # Resolves the configured severity for a diagnostic given the active profile and any per-rule
       # overrides.
       #
-      # @param rule [String, nil] canonical rule id (`call.undefined-method`).
-      # @param authored_severity [Symbol] severity the rule emitted the diagnostic with (`:error`, `:warning`,
+      # @param rule — canonical rule id (`call.undefined-method`).
+      # @param authored_severity — severity the rule emitted the diagnostic with (`:error`, `:warning`,
       #   `:info`).
-      # @param profile [Symbol] one of {VALID_PROFILES}; falls back to {DEFAULT_PROFILE} for unknown values.
-      # @param overrides [Hash{String => Symbol}] per-rule severity overrides from `.rigor.yml`'s
+      # @param profile — one of {VALID_PROFILES}; falls back to {DEFAULT_PROFILE} for unknown values.
+      # @param overrides — per-rule severity overrides from `.rigor.yml`'s
       #   `severity_overrides:` map. Keys are canonical rule ids; values are {VALID_SEVERITIES} symbols.
       #   Family-wildcard keys (`call`) match every rule under that prefix.
-      # @param bleeding_edge_overrides [Hash{String => Symbol}] the severity map imposed by the active ADR-50
+      # @param bleeding_edge_overrides — the severity map imposed by the active ADR-50
       #   § WD2 bleeding-edge features ({Rigor::BleedingEdge.severity_overrides_for}). Consulted *below* the
       #   user's own `overrides` (so an explicit `severity_overrides:` entry, exact or family wildcard,
       #   always wins) and *above* the profile table. Exact rule ids only — the overlay never carries family
       #   wildcards. Empty while the overlay is unpopulated, so the default leaves resolution bit-for-bit
       #   unchanged.
-      # @return [Symbol] the resolved severity. Returns `:off` to mean "drop the diagnostic entirely".
+      # @return the resolved severity. Returns `:off` to mean "drop the diagnostic entirely".
       def resolve(rule:, authored_severity:, profile: DEFAULT_PROFILE, overrides: {}, bleeding_edge_overrides: {})
         return authored_severity if rule.nil?