rigortype 0.3.8 → 0.3.9

data/lib/rigor/cli/measurement_integrity_warning.rb

@@ -20,15 +20,14 @@ module Rigor
     module MeasurementIntegrityWarning
       module_function
 
-      # @param report [MutationProtectionReport, FusedProtectionReport] both expose the two counts.
-      # @param err [IO] the stream to warn on.
-      # @param floor [Integer] {CoverageMutation::HARNESS_ERROR_WARN_FLOOR}.
-      # @return [void]
+      # @param report — both expose the two counts.
+      # @param err — the stream to warn on.
+      # @param floor — {CoverageMutation::HARNESS_ERROR_WARN_FLOOR}.
       def emit(report, err:, floor:)
         lines_for(report, floor: floor).each { |line| err.puts(line) }
       end
 
-      # @return [Array<String>] the warnings this report earns, widest consequence first.
+      # @return the warnings this report earns, widest consequence first.
       def lines_for(report, floor:)
         lines = []
         unmeasured = report.respond_to?(:unmeasured_files) ? report.unmeasured_files : 0 # see CoverageCommand

data/lib/rigor/cli/mutation_fork_scan.rb

@@ -32,12 +32,12 @@ module Rigor
       # reliably marshalable, and the accumulator only needs the count).
       ParseError = Data.define(:count)
 
-      # @param paths [Array<String>] the files to measure, in caller order.
-      # @param scanner [Protection::MutationScanner] built on the parent; COW-inherited by workers.
-      # @param environment [Rigor::Environment] the scanner's environment, prewarmed here before forking.
-      # @param configuration [Rigor::Configuration] for the Prism `target_ruby` version.
-      # @param workers [Integer] resolved worker count (≤1 → sequential).
-      # @return [Hash{String => Protection::MutationScanner::FileResult, ParseError}] one entry per path.
+      # @param paths — the files to measure, in caller order.
+      # @param scanner — built on the parent; COW-inherited by workers.
+      # @param environment — the scanner's environment, prewarmed here before forking.
+      # @param configuration — for the Prism `target_ruby` version.
+      # @param workers — resolved worker count (≤1 → sequential).
+      # @return one entry per path.
       def run(paths:, scanner:, environment:, configuration:, workers:)
         # Force the full RBS load on the parent so children copy-on-write inherit a warm environment rather
         # than each rebuilding it after the fork. A no-op on the sequential path but cheap.

data/lib/rigor/cli/mutation_protection_report.rb

@@ -14,7 +14,13 @@ module Rigor
     # `harness_errors` (#264) — mutants where the harness itself raised (a rescued failure), distinguished from
     # a parse-invalid mutant. Defaults to 0 so existing call sites keep constructing a `FileEffectiveness`
     # without the new keyword.
-    FileEffectiveness = Data.define(:path, :killed, :survived, :ratio, :harness_errors) do
+    # A `class ... < Data.define(...)` body, not the `Data.define(...) do ... end` shorthand: Steep
+    # resolves a `def` inside the shorthand block against the *lexically enclosing* class (here,
+    # `Rigor::CLI`, which declares its own differently-shaped `initialize`) rather than the anonymous
+    # Data subclass being defined — a `sig/` declaration for `FileEffectiveness` cannot fix this,
+    # since the misattribution happens before any signature is consulted. The explicit `class` keyword
+    # is a real namespace boundary Steep's block walker respects; behaviour is identical either way.
+    class FileEffectiveness < Data.define(:path, :killed, :survived, :ratio, :harness_errors)
       def initialize(path:, killed:, survived:, ratio:, harness_errors: 0)
         super
       end

data/lib/rigor/cli/plugin_command.rb

@@ -64,7 +64,7 @@ module Rigor
       PLUGINS_ROOT = File.join(GEM_ROOT, "plugins")
       EXAMPLES_ROOT = File.join(GEM_ROOT, "examples")
 
-      # @return [Integer] CLI exit status.
+      # @return CLI exit status.
       def run
         subcommand = @argv.shift || "list"
 

data/lib/rigor/cli/plugins_command.rb

@@ -62,7 +62,7 @@ module Rigor
     class PluginsCommand < Command # rubocop:disable Metrics/ClassLength
       USAGE = "Usage: rigor plugins [options]"
 
-      # @return [Integer] CLI exit status.
+      # @return CLI exit status.
       def run
         options = parse_options
         config_path = options.fetch(:config) || Configuration.discover
@@ -143,6 +143,7 @@ module Rigor
         required_by = loaded_ids & Plugin::Inflector::CONSUMER_PLUGIN_IDS
         return nil if required_by.empty?
 
+        Plugin::Isolation.configured_strategy = configuration.plugins_isolation
         Plugin::Isolation.target_bundle_root ||= Environment::BundleSigDiscovery.resolve_bundle_path(
           bundle_path: configuration.bundler_bundle_path,
           project_root: Dir.pwd,

data/lib/rigor/cli/prism_colorizer.rb

@@ -35,8 +35,8 @@ module Rigor
 
       VARIABLE_TOKENS = %i[INSTANCE_VARIABLE CLASS_VARIABLE GLOBAL_VARIABLE].freeze
 
-      # @param source [String] Ruby source.
-      # @return [String] the source with ANSI colour escapes, or
+      # @param source — Ruby source.
+      # @return the source with ANSI colour escapes, or
       #   the input unchanged when lexing surfaces an error.
       def colorize(source)
         # Sources read under a POSIX locale arrive tagged US-ASCII even when they carry UTF-8 bytes; retag so the token

data/lib/rigor/cli/protection_fork_scan.rb

@@ -23,12 +23,12 @@ module Rigor
       # reliably marshalable, and the accumulator only needs the count).
       ParseError = Data.define(:count)
 
-      # @param paths [Array<String>] the files to scan, in caller order.
-      # @param scanner [Inference::ProtectionScanner] built on the parent; COW-inherited by workers.
-      # @param environment [Rigor::Environment] the scanner's environment, prewarmed here before forking.
-      # @param configuration [Rigor::Configuration] for the Prism `target_ruby` version.
-      # @param workers [Integer] resolved worker count (≤1 → sequential).
-      # @return [Hash{String => Inference::ProtectionScanner::FileResult, ParseError}] one entry per path.
+      # @param paths — the files to scan, in caller order.
+      # @param scanner — built on the parent; COW-inherited by workers.
+      # @param environment — the scanner's environment, prewarmed here before forking.
+      # @param configuration — for the Prism `target_ruby` version.
+      # @param workers — resolved worker count (≤1 → sequential).
+      # @return one entry per path.
       def run(paths:, scanner:, environment:, configuration:, workers:)
         # Force the full RBS load on the parent so children copy-on-write inherit a warm environment rather
         # than each rebuilding it after the fork (mirrors the check fork pool's parent-side prewarm). A

data/lib/rigor/cli/show_bleedingedge_command.rb

@@ -21,7 +21,7 @@ module Rigor
     class ShowBleedingedgeCommand < Command
       USAGE = "Usage: rigor show-bleedingedge [options]"
 
-      # @return [Integer] CLI exit status.
+      # @return CLI exit status.
       def run
         options = parse_options
         configuration = load_configuration(options)

data/lib/rigor/cli/sig_gen_command.rb

@@ -39,7 +39,7 @@ module Rigor
                                  %i[unrenderable_rbs unresolvable_superclass]).freeze
       private_constant :SUMMARISED_SKIP_REASONS
 
-      # @return [Integer] CLI exit status.
+      # @return CLI exit status.
       def run
         options = parse_options
         return CLI::EXIT_USAGE if options.nil?
@@ -135,7 +135,7 @@ module Rigor
         )
       end
 
-      # @return [Integer] exit status — non-zero when a file the user asked to write could not be written.
+      # @return exit status — non-zero when a file the user asked to write could not be written.
       def dispatch_write(candidates, configuration, options)
         layout_index = SigGen::LayoutIndex.new(signature_paths: configuration.signature_paths)
         path_mapper = SigGen::PathMapper.new(configuration: configuration, layout_index: layout_index)

data/lib/rigor/cli/skill_command.rb

@@ -76,7 +76,7 @@ module Rigor
       # up.
       SKILLS_ROOT = File.expand_path("../../../skills", __dir__)
 
-      # @return [Integer] CLI exit status.
+      # @return CLI exit status.
       def run
         case @argv.first
         when nil

data/lib/rigor/cli/skill_deep_probe.rb

@@ -37,22 +37,22 @@ module Rigor
       #   that could not run is NOT a clean check and the report must never let it read as one.
       # - `route` / `reason` — the headline override, or nil to leave the presence-only recommendation standing.
       Report = Data.define(:status, :detail, :route, :reason) do
-        # @return [Boolean] true when the check did not complete — the caller must then say so rather than let the
+        # @return true when the check did not complete — the caller must then say so rather than let the
         #   fallback recommendation read as an all-clear.
         def failed?
           status == :error
         end
       end
 
-      # @param config [String, nil] the config filename the presence probe found, relative to `root`.
-      # @param root [String] project root (the analysis itself resolves paths against the process cwd, as
+      # @param config — the config filename the presence probe found, relative to `root`.
+      # @param root — project root (the analysis itself resolves paths against the process cwd, as
       #   `rigor check` does).
       def initialize(config:, root: Dir.pwd)
         @config = config
         @root = root
       end
 
-      # @return [Report] never raises — every failure degrades to a `:error`/`:skipped` report whose `route` is nil,
+      # @return never raises — every failure degrades to a `:error`/`:skipped` report whose `route` is nil,
       #   leaving the presence-only headline in charge.
       def run
         if @config.nil?

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}")