rigortype 0.3.8 → 0.4.0

data/lib/rigor/cli/type_of_command.rb

@@ -13,9 +13,10 @@ require_relative "../inference/scope_indexer"
 require_relative "../inference/precision_scanner"
 require_relative "../source/node_children"
 require_relative "type_of_renderer"
+require_relative "type_of_template_probe"
 require_relative "command"
 require_relative "options"
-require_relative "probe_environment"
+require_relative "../project_environment"
 
 module Rigor
   class CLI
@@ -28,10 +29,15 @@ module Rigor
     # type-of UX (extra flags, watch mode, streaming output) without bloating the CLI shell. Output formatting is
     # delegated to {TypeOfRenderer}.
     class TypeOfCommand < Command
+      include TypeOfTemplateProbe
+
       USAGE = "Usage: rigor type-of [options] FILE:LINE[:COL] [FILE:LINE[:COL] ...]"
 
-      Result = Data.define(:file, :line, :column, :node, :type, :tracer, :enumeration) do
-        def initialize(enumeration: nil, **rest)
+      # `location_mapper` is set for a template unit's result (#1040): the `--trace` fallback locations are
+      # positions in the COMPILED Ruby, and the mapper turns one into the `[template_line, column_or_nil]`
+      # the user can find in the file they named.
+      Result = Data.define(:file, :line, :column, :node, :type, :tracer, :enumeration, :location_mapper) do
+        def initialize(enumeration: nil, location_mapper: nil, **rest)
           super
         end
       end
@@ -46,7 +52,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)
@@ -106,13 +112,25 @@ module Rigor
         physical = buffer ? buffer.resolve(file) : file
         return 1 unless file_exists?(buffer ? physical : file)
 
+        unit_probe = template_unit_probe(file, base_scope.environment, buffer)
+        return unit_probe if unit_probe.is_a?(Integer)
+
+        if unit_probe
+          context = { configuration: configuration, base_scope: base_scope, options: options }
+          return resolve_template(file, physical, unit_probe, indexed_targets, context)
+        end
+
         source = File.read(physical)
         parse_result = Prism.parse(source, filepath: file, version: configuration.target_ruby)
         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)
@@ -187,21 +205,21 @@ module Rigor
         end
       end
 
-      def type_result(file, line, column, node, scope_index, options, enumeration: nil)
+      # `presentation` is the Result's optional `enumeration:` / `location_mapper:`.
+      def type_result(file, line, column, node, scope_index, options, **presentation)
         tracer = options[:trace] ? Inference::FallbackTracer.new : nil
         type = scope_index[node].type_of(node, tracer: tracer)
-        Result.new(file: file, line: line, column: column, node: node, type: type, tracer: tracer,
-                   enumeration: enumeration)
+        Result.new(file: file, line: line, column: column, node: node, type: type, tracer: tracer, **presentation)
       end
 
       # 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_of_renderer.rb

@@ -84,7 +84,7 @@ module Rigor
           @out.puts("fallbacks: none")
         else
           @out.puts("fallbacks (#{tracer.size}):")
-          tracer.each { |event| @out.puts("  - #{format_fallback_text(event, result.file)}") }
+          tracer.each { |event| @out.puts("  - #{format_fallback_text(event, result)}") }
         end
       end
 
@@ -118,21 +118,31 @@ module Rigor
           type: result.type.describe,
           erased: result.type.erase_to_rbs
         }
-        payload[:fallbacks] = result.tracer.map { |event| fallback_to_h(event) } if result.tracer
+        payload[:fallbacks] = result.tracer.map { |event| fallback_to_h(event, result) } if result.tracer
         payload
       end
 
-      def format_fallback_text(event, file)
-        "#{event.node_class} (#{event.family}) @ #{location_text(event.location, file)}"
+      def format_fallback_text(event, result)
+        "#{event.node_class} (#{event.family}) @ #{location_text(event.location, result)}"
       end
 
-      def location_text(location, file)
+      def location_text(location, result)
         return "<no location>" unless location.respond_to?(:start_line)
 
-        "#{file}:#{location.start_line}:#{location.start_column + 1}"
+        line, column = fallback_position(location, result)
+        column ? "#{result.file}:#{line}:#{column}" : "#{result.file}:#{line}"
       end
 
-      def fallback_to_h(event)
+      # A template unit's result (#1040) maps the compiled location back; a column that names nothing in the
+      # template is left out rather than printed as a column of bytes the user never wrote.
+      def fallback_position(location, result)
+        mapper = result.location_mapper
+        return [location.start_line, location.start_column + 1] if mapper.nil?
+
+        mapper.call(location)
+      end
+
+      def fallback_to_h(event, result)
         hash = {
           node_class: event.node_class.name,
           family: event.family,
@@ -140,8 +150,9 @@ module Rigor
         }
         location = event.location
         if location.respond_to?(:start_line)
-          hash[:line] = location.start_line
-          hash[:column] = location.start_column + 1
+          line, column = fallback_position(location, result)
+          hash[:line] = line
+          hash[:column] = column if column
         end
         hash
       end

data/lib/rigor/cli/type_of_template_probe.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../analysis/template_unit_paths"
+require_relative "../analysis/template_unit_positions"
+require_relative "../analysis/template_units"
+require_relative "../inference/precision_scanner"
+require_relative "../inference/scope_indexer"
+require_relative "../source/node_locator"
+
+module Rigor
+  class CLI
+    # #1040 — `rigor type-of` against a **template unit**: a file a loaded plugin compiles into Ruby.
+    #
+    # Before this the command read the template from disk and parsed its bytes as Ruby, so an ERB view
+    # exited 1 on a parse error and an identity-transformed one answered about the wrong node under an
+    # unseeded scope. A template path now takes the path `rigor check` takes: the run's
+    # {Analysis::TemplateUnits} index is built, the COMPILED source is parsed with the unit's `scopes:`, the
+    # file scope is seeded with the unit's `self`, locals and ivars, and the requested template position is
+    # resolved through {Analysis::TemplateUnitPositions} — which declines, with a message, whenever the
+    # position does not denote exactly one compiled node.
+    #
+    # Mixed into {TypeOfCommand}; a path no loaded plugin claims never reaches anything here, so a `.rb`
+    # probe does not build the index or change a byte of its output.
+    module TypeOfTemplateProbe
+      # Why a template position has no answer, keyed by {Analysis::TemplateUnitPositions#node_at}'s reasons.
+      DECLINE_MESSAGES = {
+        no_compiled_line: "the template compiler emitted no Ruby for this line",
+        not_verbatim: "the position is in template markup, or in code the template compiler rewrote " \
+                      "rather than copied, so no compiled expression is made of the bytes there",
+        ambiguous: "the bytes there are template markup, or code the compiler copied to more than one " \
+                   "place, so the position does not name a single compiled expression"
+      }.freeze
+      private_constant :DECLINE_MESSAGES
+      Ractor.make_shareable(DECLINE_MESSAGES)
+
+      private
+
+      # The unit `file` compiles to, `nil` for a path that is not a template unit (the caller probes it as
+      # Ruby), or an exit status after reporting a template the claiming plugin could not compile.
+      def template_unit_probe(file, environment, buffer)
+        registry = environment.plugin_registry
+        return nil unless template_claimed?(registry, file)
+
+        units = (@template_units ||= Analysis::TemplateUnits.collect(registry: registry, buffer: buffer))
+        entry = units[file]
+        return [units, entry] if entry
+
+        # A template the plugin DECLINED is not a unit, and is probed as the command always probed it —
+        # which for a template that is not Ruby is a Prism error about bytes the user did not write, so
+        # the decline is stated first rather than left to be inferred from the error.
+        failures = template_failures(units, file)
+        if failures.empty?
+          @err.puts("type-of: #{file}: plugin declined the template; probing its bytes as Ruby")
+          return nil
+        end
+
+        failures.each do |failure|
+          @err.puts("type-of: #{file}: plugin #{failure.plugin_id} could not compile the template: " \
+                    "#{failure.message}")
+        end
+        1
+      end
+
+      # Only a claimed path builds the index — a `.rb` probe pays no glob expansion and no transform.
+      def template_claimed?(registry, file)
+        return false if registry.nil? || registry.empty?
+
+        relative = Analysis::TemplateUnitPaths.relative(file, Dir.pwd)
+        registry.plugins.any? do |plugin|
+          globs = begin
+            plugin.manifest.template_globs
+          rescue StandardError
+            []
+          end
+          !globs.empty? && Analysis::TemplateUnitPaths.claims?(globs, relative)
+        end
+      end
+
+      def template_failures(units, file)
+        relative = Analysis::TemplateUnitPaths.relative(file, Dir.pwd)
+        units.failures.select { |failure| failure.path == relative }
+      end
+
+      # Every result for one template: the compiled source parsed and indexed once under the unit's seeded
+      # scope, then each requested template position resolved through the inverse map.
+      def resolve_template(file, physical, unit_probe, indexed_targets, context)
+        units, entry = unit_probe
+        parse_result = Prism.parse(entry.source, filepath: file, version: context[:configuration].target_ruby,
+                                                 scopes: units.parse_scopes(file))
+        return 1 if compiled_parse_errors?(parse_result, file, entry)
+
+        scope = units.seed(context[:base_scope].with_source_path(file), file)
+        scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
+        positions = Analysis::TemplateUnitPositions.new(
+          entry: entry, template: File.binread(physical), root: parse_result.value,
+          skip_node_types: Inference::PrecisionScanner::NON_EXPRESSION_NODE_TYPES
+        )
+        probe = { file: file, entry: entry, positions: positions, scope_index: scope_index,
+                  options: context[:options] }
+        indexed_targets.map do |target, index|
+          resolved = resolve_template_target(probe, target)
+          return resolved if resolved.is_a?(Integer)
+
+          [index, resolved]
+        end
+      end
+
+      def resolve_template_target(probe, target)
+        file = probe[:file]
+        positions = probe[:positions]
+        return CLI::EXIT_USAGE unless template_position_in_range?(positions, target)
+        return enumerate_template_line(probe, target.line) if target.column.nil?
+
+        node = positions.node_at(line: target.line, column: target.column)
+        if node.is_a?(Symbol)
+          @err.puts("type-of: no expression found at #{file}:#{target.line}:#{target.column}: " \
+                    "#{DECLINE_MESSAGES.fetch(node)}")
+          return []
+        end
+
+        [type_result(file, target.line, target.column, node, probe[:scope_index], probe[:options],
+                     location_mapper: template_location_mapper(probe))]
+      end
+
+      def enumerate_template_line(probe, line)
+        unless line.between?(1, probe[:positions].template_line_count)
+          @err.puts("type-of: no expression found on #{probe[:file]}:#{line}")
+          return []
+        end
+
+        rows, total = probe[:positions].line_nodes(line)
+        if rows.empty?
+          @err.puts("type-of: no expression found on #{probe[:file]}:#{line}: no compiled expression maps to " \
+                    "a single column of this line (markup, code the template compiler rewrote, or code " \
+                    "copied to more than one place)")
+          return []
+        end
+
+        enumeration = TypeOfCommand::LineEnumeration.new(total: total, shown: rows.length)
+        mapper = template_location_mapper(probe)
+        rows.map do |column, node|
+          type_result(probe[:file], line, column, node, probe[:scope_index], probe[:options],
+                      enumeration: enumeration, location_mapper: mapper)
+        end
+      end
+
+      # The same range errors, and the same exit status, a `.rb` probe gives — measured against the
+      # TEMPLATE's lines, which are the ones the user named. A bare `FILE:LINE` past the end is "no
+      # expression found", exactly as it is for Ruby.
+      def template_position_in_range?(positions, target)
+        return true if target.column.nil?
+
+        message = if target.line < 1 then "line must be >= 1, got #{target.line}"
+                  elsif target.column < 1 then "column must be >= 1, got #{target.column}"
+                  elsif target.line > positions.template_line_count
+                    "line #{target.line} is past the end of the source buffer"
+                  end
+        return true if message.nil?
+
+        @err.puts("type-of: #{message}")
+        false
+      end
+
+      # A `--trace` fallback carries a COMPILED location; it is reported at the template line, and at a
+      # template column only when the location lies in a verbatim run.
+      def template_location_mapper(probe)
+        entry = probe[:entry]
+        positions = probe[:positions]
+        lambda do |location|
+          [entry.template_line(location.start_line), positions.template_column_for(location)]
+        end
+      end
+
+      # A compiled source that does not parse is the plugin's output, not the user's text; its errors are
+      # reported at the template lines they map to, as `rigor check` reports every other finding in a unit.
+      def compiled_parse_errors?(result, file, entry)
+        return false if result.errors.empty?
+
+        result.errors.each do |error|
+          @err.puts("#{file}:#{entry.template_line(error.location.start_line)}: " \
+                    "compiled template does not parse: #{error.message}")
+        end
+        true
+      end
+    end
+  end
+end

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
@@ -149,7 +183,7 @@ module Rigor
         return 1
       end
 
-      File.write(path, init_template)
+      File.write(path, init_template(path))
       @out.puts("Created #{path}")
       print_init_next_steps(path)
       0
@@ -169,10 +203,34 @@ 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.
-    def init_template
+    def init_template(path = ".rigor.dist.yml")
       <<~YAML
         # yaml-language-server: $schema=#{CONFIG_SCHEMA_URL}
         # Rigor configuration. The full key reference is
@@ -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
@@ -209,6 +266,12 @@ module Rigor
         #                Leave unset (or `null`) to auto-detect
         #                `<root>/sig`. Use `[]` to disable
         #                project-RBS loading entirely.
+        # - test_paths:  the directories holding your tests.
+        #                `rigor sig-gen --params=observed` reads
+        #                their call sites to type parameters.
+        #                `rigor init` writes the spec/ and test/
+        #                it finds; unset auto-detects them, and
+        #                `[]` declares the project has none.
         # - cache.path:  where Rigor will eventually persist
         #                analysis results across runs.
         #
@@ -218,10 +281,22 @@ module Rigor
         # tempfile, uri, logger, date, prism, rbs). Adding a
         # `sig/<gem>.rbs` file under `sig/` is the simplest way
         # to extend type coverage today.
-        #{YAML.dump(Configuration::DEFAULTS).sub(/\A---\n/, '')}
+        #{YAML.dump(init_settings(path)).sub(/\A---\n/, '')}
       YAML
     end
 
+    # The settings `rigor init` writes: the defaults, with `test_paths:` spelled out as the test roots found now, so
+    # the project's config says where its tests are rather than leaving it to auto-detection. The roots are written
+    # relative to the config file's directory, which is what {Configuration.load} resolves them against.
+    def init_settings(path)
+      test_paths = Configuration.new.resolved_test_paths
+      return Configuration::DEFAULTS if test_paths.empty?
+
+      config_dir = Pathname(File.expand_path(File.dirname(path)))
+      relative = test_paths.map { |root| Pathname(root).relative_path_from(config_dir).to_s }
+      Configuration::DEFAULTS.merge("test_paths" => relative)
+    end
+
     def run_annotate
       require_relative "cli/annotate_command"
 
@@ -320,7 +395,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 +461,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