rigortype 0.2.8 → 0.3.0

data/lib/rigor/cli/coverage_command.rb

@@ -14,6 +14,7 @@ require_relative "../inference/parameter_inference_collector"
 require_relative "../protection/mutation_scanner"
 require_relative "../protection/test_suite_oracle"
 require_relative "../language_server/project_context"
+require_relative "../runtime/jit"
 require_relative "../scope"
 require_relative "coverage_report"
 require_relative "coverage_renderer"
@@ -25,6 +26,8 @@ require_relative "mutation_protection_renderer"
 require_relative "fused_protection_report"
 require_relative "fused_protection_renderer"
 require_relative "coverage_mutation"
+require_relative "protection_fork_scan"
+require_relative "check_runner_factory"
 require_relative "command"
 
 module Rigor
@@ -51,30 +54,43 @@ module Rigor
       DEFAULT_TEST_COMMAND = %w[bundle exec rake].freeze
 
       # @return [Integer] CLI exit status.
-      def run
+      def run # rubocop:disable Metrics/AbcSize
+        # Arm deferred YJIT enablement (Runtime::Jit): a scan long enough to
+        # amortize JIT compile cost enables mid-flight; a short one finishes
+        # first and never pays it. Same seam as `rigor check`.
+        Runtime::Jit.enable_after(Runtime::Jit.deadline_seconds)
         options = parse_options
         return mutation_misuse_error if options[:mutation] && !options[:protection]
         return with_tests_misuse_error if options[:with_tests] && !options[:mutation]
         return include_dynamic_misuse_error if options[:include_dynamic] && !options[:with_tests]
         return run_mutation_protection(options) if options[:mutation]
 
-        paths = collect_paths(@argv, command_name: "coverage")
+        configuration = Configuration.load(options.fetch(:config))
+        paths = resolve_paths(configuration)
         return CLI::EXIT_USAGE if paths.nil?
         return usage_error if paths.empty?
 
-        return run_protection(paths, options) if options[:protection]
+        return run_protection(paths, options, configuration) if options[:protection]
 
-        report = scan_paths(paths, options)
+        report = scan_paths(paths, configuration)
         CoverageRenderer.new(out: @out).render(report, format: options.fetch(:format))
         determine_exit(report, options)
       end
 
       private
 
+      # Like `rigor check`, fall back to the configured `paths:` when no path is given on the command line
+      # (`coverage` previously required an explicit path — operational friction the two commands should not
+      # differ on). The mutation mode keeps its own git-changed-files default and returns before this.
+      def resolve_paths(configuration)
+        args = @argv.empty? ? configuration.paths : @argv
+        collect_paths(args, command_name: "coverage")
+      end
+
       def parse_options
         options = { format: "text", threshold: nil, config: nil, protection: false, mutation: false,
                     with_tests: false, test_command: DEFAULT_TEST_COMMAND, include_dynamic: false,
-                    limit: nil, seed: 1 }
+                    limit: nil, seed: 1, workers: nil }
         OptionParser.new { |opts| define_options(opts, options) }.parse!(@argv)
         options
       end
@@ -87,6 +103,10 @@ module Rigor
           options[:protection] = true
         end
         define_mutation_options(opts, options)
+        opts.on("--workers=N", Integer, "With --protection: fork N workers over the scanned files " \
+                                        "(default: config parallel.workers / RIGOR_RACTOR_WORKERS / 0)") do |v|
+          options[:workers] = v
+        end
         opts.on("--threshold=RATIO", Float, "Exit 1 when the precision (or, with --protection, " \
                                             "protection/effectiveness) ratio is below RATIO (0.0–1.0)") do |v|
           options[:threshold] = v
@@ -135,23 +155,39 @@ module Rigor
         CLI::EXIT_USAGE
       end
 
-      def run_protection(paths, options)
-        report = scan_protection(paths, options)
+      def run_protection(paths, options, configuration)
+        report = scan_protection(paths, options, configuration)
         ProtectionRenderer.new(out: @out).render(report, format: options.fetch(:format))
         determine_protection_exit(report, options)
       end
 
-      def scan_protection(paths, options)
-        configuration = Configuration.load(options.fetch(:config))
+      # Builds the plugin-aware environment and the seeded scope ONCE on the parent, then fork-pools the
+      # per-file scan across the resolved worker count (P3-10). The scan is pure-read and each file is
+      # independent, so this is a fork-map + ordered reduce: {ProtectionForkScan} returns `{path => result}`
+      # and the parent absorbs in `paths` order so the report is byte-identical to a sequential run.
+      def scan_protection(paths, options, configuration)
         environment = plugin_aware_environment(configuration)
-        scope = scope_with_inferred_params(paths, configuration, environment)
+        workers = CheckRunnerFactory.resolve_workers(options, configuration)
+        scope = scope_with_inferred_params(paths, configuration, environment, workers)
         scanner = Inference::ProtectionScanner.new(scope: scope)
         accumulator = ProtectionAccumulator.new
 
-        paths.each { |path| scan_one(path, scanner, accumulator, configuration) }
+        results = ProtectionForkScan.run(
+          paths: paths, scanner: scanner, environment: environment,
+          configuration: configuration, workers: workers
+        )
+        paths.each { |path| absorb_protection_result(accumulator, path, results.fetch(path)) }
         accumulator.to_report
       end
 
+      def absorb_protection_result(accumulator, path, result)
+        if result.is_a?(ProtectionForkScan::ParseError)
+          accumulator.record_parse_error_count(path, result.count)
+        else
+          accumulator.absorb(path, result)
+        end
+      end
+
       # Seed the protection scan's scope with the same cross-file facts `rigor check` resolves against, so a receiver
       # reads the type it actually has rather than a stripped-scope `Dynamic`:
       #
@@ -168,7 +204,7 @@ module Rigor
       #
       # Both span the scanned `paths` only (no whole-project pre-pass) — a site that gains neither is classified exactly
       # as before.
-      def scope_with_inferred_params(paths, configuration, environment)
+      def scope_with_inferred_params(paths, configuration, environment, workers)
         base = Scope.empty(environment: environment)
         seed = {}
 
@@ -176,7 +212,7 @@ module Rigor
         seed[:discovered_classes] = discovered unless discovered.empty?
 
         table = Inference::ParameterInferenceCollector.collect(
-          files: paths, environment: environment, target_ruby: configuration.target_ruby
+          files: paths, environment: environment, target_ruby: configuration.target_ruby, workers: workers
         )
         seed[:param_inferred_types] = table unless table.empty?
 
@@ -200,31 +236,21 @@ module Rigor
         CLI::EXIT_USAGE
       end
 
-      def scan_paths(paths, options)
-        CoverageScan.precision_report(files: paths, configuration: Configuration.load(options.fetch(:config)))
-      end
-
-      # Delegated to the shared scan module (see {CoverageScan}); the protection path below reuses both, and `rigor
-      # check --coverage` reuses `precision_report` over the same machinery.
-      def project_environment(configuration)
-        CoverageScan.project_environment(configuration)
+      def scan_paths(paths, configuration)
+        CoverageScan.precision_report(files: paths, configuration: configuration)
       end
 
       # The protection scan must see the same receiver types `rigor check` does — including plugin-contributed
       # `dynamic_return` types (a controller's `params` → `ActionController::Parameters`, a `Model.where` →
-      # `ActiveRecord::Relation[Model]`). The bare `project_environment` carries only the RBS environment (no plugin
-      # registry), so every plugin-typed receiver reads `Dynamic` and its dispatch site is miscounted as *unprotected* —
-      # a systematic undercount of what Rigor actually types on a plugin-using project. `ProjectContext` builds the
-      # plugin-aware environment (registry materialised + the per-run prepare pass that primes producers like the
-      # controller / model index) exactly as the LSP and the runner do.
+      # `ActiveRecord::Relation[Model]`). The bare `CoverageScan.project_environment` carries only the RBS environment
+      # (no plugin registry), so every plugin-typed receiver reads `Dynamic` and its dispatch site is miscounted as
+      # *unprotected* — a systematic undercount of what Rigor actually types on a plugin-using project.
+      # `ProjectContext` builds the plugin-aware environment (registry materialised + the per-run prepare pass that
+      # primes producers like the controller / model index) exactly as the LSP and the runner do.
       def plugin_aware_environment(configuration)
         LanguageServer::ProjectContext.new(configuration: configuration).environment
       end
 
-      def scan_one(path, scanner, accumulator, configuration)
-        CoverageScan.scan_into(path, scanner, accumulator, configuration)
-      end
-
       def determine_exit(report, options)
         return 1 unless report.parse_errors.empty?
 

data/lib/rigor/cli/diagnostic_formats.rb

@@ -33,7 +33,9 @@ module Rigor
         FORMATS.include?(format)
       end
 
-      # Renders `result` in the named CI format. Callers gate on {.supports?} first; an unrecognised format returns nil.
+      # Renders `result` in the named CI format. Callers gate on {.supports?} first, so an unrecognised format means
+      # {FORMATS} and the dispatch below have drifted apart — raise rather than return nil, which every caller would
+      # then have to guard.
       def render(result, format)
         case format
         when "sarif" then Sarif.new(result).render
@@ -42,6 +44,7 @@ module Rigor
         when "checkstyle" then Checkstyle.new(result).render
         when "junit" then Junit.new(result).render
         when "teamcity" then Teamcity.new(result).render
+        else raise ArgumentError, "unsupported format: #{format}"
         end
       end
 

data/lib/rigor/cli/docs_command.rb

@@ -20,9 +20,6 @@ module Rigor
     #
     # `<name>` resolves a category-qualified path (`handbook/03-narrowing`), a prefixed basename (`03-narrowing`), or a
     # short name (`narrowing`, when it is unique across categories).
-    #
-    # The pre-v0.3.0 verb spellings `rigor docs list` / `rigor docs path <name>` still work but emit a stderr
-    # deprecation notice; they are removed in v0.3.0 (see docs/ROADMAP.md § "Scheduled CLI deprecations").
     class DocsCommand < Command
       USAGE = <<~USAGE
         Usage: rigor docs [<name>] [--path <name>] [--list [<category>]]
@@ -46,10 +43,6 @@ module Rigor
           rigor docs editor-integration
           rigor docs --path 17-driving-improvement
           rigor docs --list handbook
-
-        Deprecated (removed in v0.3.0) — use the flags above:
-          rigor docs list           ->  rigor docs --list
-          rigor docs path <name>    ->  rigor docs --path <name>
       USAGE
 
       # The bundled docs live at `<gem_root>/docs/`. From `lib/rigor/cli/docs_command.rb` that is three directories up.
@@ -58,18 +51,8 @@ module Rigor
       HANDBOOK_ROOT = File.join(DOCS_ROOT, "handbook")
       LLMS_INDEX = File.join(DOCS_ROOT, "llms.txt")
 
-      # The verb subcommands the flags superseded keep working with a stderr deprecation notice until this version drops
-      # them. Each maps to the canonical advice printed and the flag it rewrites to.
-      LEGACY_VERB_REMOVAL = "v0.3.0"
-      LEGACY_VERBS = {
-        "list" => { old: "list",        advice: "--list",        flag: "--list" },
-        "path" => { old: "path <name>", advice: "--path <name>", flag: "--path" }
-      }.freeze
-
       # @return [Integer] CLI exit status.
       def run
-        rewrite_legacy_verb!
-
         case @argv.first
         when nil
           run_index
@@ -92,19 +75,6 @@ module Rigor
 
       private
 
-      # Translate a deprecated verb spelling into its flag form, warning once on stderr, so the dispatch above only
-      # handles canonical forms.
-      def rewrite_legacy_verb!
-        spec = LEGACY_VERBS[@argv.first]
-        return unless spec
-
-        @err.puts(
-          "rigor docs: `#{spec.fetch(:old)}` is deprecated and will be removed in " \
-          "#{LEGACY_VERB_REMOVAL}; use `rigor docs #{spec.fetch(:advice)}` instead."
-        )
-        @argv[0] = spec.fetch(:flag)
-      end
-
       def run_index
         if File.file?(LLMS_INDEX)
           @out.write(File.read(LLMS_INDEX))

data/lib/rigor/cli/doctor_command.rb

@@ -34,6 +34,8 @@ module Rigor
       CHECK_PLUGINS = "plugins"
       CHECK_BASELINE = "baseline"
       CHECK_RAILS = "rails_plugins"
+      CHECK_GEMFILE = "gemfile_install"
+      CHECK_PLUGIN_SKEW = "plugin_skew"
 
       RAILS_LOCK_MARKERS = %w[railties actionpack activerecord actioncable].freeze
       RAILS_PLUGIN_MARKERS = %w[
@@ -63,8 +65,9 @@ module Rigor
         # 3. RBS environment check.
         findings.concat(check_rbs_environment(result))
 
-        # 4. Plugin load check.
-        findings.concat(check_plugins(configuration))
+        # 4. Plugin load check + 8. installation-skew check share one loaded registry.
+        registry = load_plugin_registry(configuration)
+        findings.concat(check_plugins(registry))
 
         # 5. Baseline drift check.
         findings.concat(check_baseline(configuration, result))
@@ -72,6 +75,12 @@ module Rigor
         # 6. Rails locked but no Rails plugins.
         findings.concat(check_rails_plugins(configuration))
 
+        # 7. Rigor itself resolved as a project dependency.
+        findings.concat(check_gemfile_install)
+
+        # 8. A bundled plugin loaded from a different rigortype installation than the engine (#194 slice 3).
+        findings.concat(check_plugin_skew(registry))
+
         report(findings, options.fetch(:format))
         findings.any? { |f| f[:status] == :fail } ? 1 : 0
       rescue OptionParser::InvalidArgument => e
@@ -122,37 +131,67 @@ module Rigor
         stats = result.stats
         return [] unless stats
 
+        quarantined = quarantined_signature_diagnostics(result)
         if stats.rbs_classes_total.zero?
-          [
-            {
-              check: CHECK_RBS,
-              status: :fail,
-              message: "RBS environment is empty (#{stats.rbs_classes_total} classes available)",
-              hint: "The RBS environment failed to build or loaded no signatures. " \
-                    "Check `signature_paths:` for duplicate declarations, or run " \
-                    "`rbs collection install` for gem signatures."
-            }
-          ]
+          [empty_rbs_env_finding(stats)]
+        elsif quarantined.any?
+          [degraded_rbs_env_finding(stats, quarantined)]
         else
-          [
-            {
-              check: CHECK_RBS,
-              status: :pass,
-              message: "RBS environment healthy (#{stats.rbs_classes_total} classes available)",
-              hint: nil
-            }
-          ]
+          [healthy_rbs_env_finding(stats)]
         end
       end
 
-      def check_plugins(configuration)
+      def empty_rbs_env_finding(stats)
+        {
+          check: CHECK_RBS,
+          status: :fail,
+          message: "RBS environment is empty (#{stats.rbs_classes_total} classes available)",
+          hint: "The RBS environment failed to build or loaded no signatures. " \
+                "Check `signature_paths:` for duplicate declarations, or run " \
+                "`rbs collection install` for gem signatures."
+        }
+      end
+
+      # The env is non-empty precisely BECAUSE the broken file was quarantined, so the class count alone reads
+      # as healthy — this is the case doctor used to pass. Classify the diagnostic the run already produced
+      # (ADR-77: route existing evidence) rather than re-probing the sig tree.
+      def degraded_rbs_env_finding(stats, quarantined)
+        {
+          check: CHECK_RBS,
+          status: :warn,
+          message: "RBS environment degraded — #{quarantined.size} `signature_paths:` file(s) " \
+                   "skipped, #{stats.rbs_classes_total} classes available",
+          hint: "An unparseable `.rbs` is skipped so the rest of the env survives, which makes the " \
+                "run quieter, not cleaner: the types it declares are gone. Run `rbs validate` on your " \
+                "`sig/` set and fix the parse error. To make this fail the build, opt into the " \
+                "`reject-unparseable-signatures` bleeding-edge feature."
+        }
+      end
+
+      def healthy_rbs_env_finding(stats)
+        {
+          check: CHECK_RBS,
+          status: :pass,
+          message: "RBS environment healthy (#{stats.rbs_classes_total} classes available)",
+          hint: nil
+        }
+      end
+
+      def quarantined_signature_diagnostics(result)
+        result.diagnostics.select { |diagnostic| diagnostic.rule == "rbs.coverage.quarantined-signature" }
+      end
+
+      def load_plugin_registry(configuration)
         services = Plugin::Services.new(
           reflection: Reflection,
           type: Type::Combinator,
           configuration: configuration,
           cache_store: nil
         )
-        registry = Plugin::Loader.load(configuration: configuration, services: services)
+        Plugin::Loader.load(configuration: configuration, services: services)
+      end
+
+      def check_plugins(registry)
         errors = registry.load_errors
         return [] if errors.empty?
 
@@ -166,6 +205,52 @@ module Rigor
         ]
       end
 
+      # WD5 (#194 slice 3) — a bundled plugin should load from the engine's own `plugins/` tree; slice 2
+      # anchors it there. This guards the residual anchoring cannot see: a bundled plugin whose resolved file
+      # sits OUTSIDE the engine tree — the fallback-require path, or a genuinely mixed installation where a
+      # foreign copy was already loaded. That is the #194 skew, which ran the engine with a load-bearing
+      # false-positive gate silently missing. Only plugins the engine bundles are checked; a third-party /
+      # project-bundle plugin is not the engine's to vouch for and is never flagged, and a nil resolved path
+      # (an injected requirer, an in-process no-op load) carries no provenance and is skipped.
+      def check_plugin_skew(registry)
+        registry.resolved_gem_paths.filter_map do |gem_name, resolved_path|
+          next if resolved_path.nil?
+          next unless Plugin::Loader.bundled_plugin_path(gem_name)
+          next if inside_engine_tree?(resolved_path)
+
+          plugin_skew_finding(gem_name, resolved_path)
+        end
+      end
+
+      def plugin_skew_finding(gem_name, resolved_path)
+        {
+          check: CHECK_PLUGIN_SKEW,
+          status: :warn,
+          message: "Plugin #{gem_name} loaded from a different rigortype installation than the engine " \
+                   "(loaded from #{resolved_path}; engine at #{Plugin::Loader::ENGINE_ROOT})",
+          hint: "The engine and its bundled plugins are versioned together, so a copy resolved from another " \
+                "installation can run the engine with a mismatched plugin (the cause of wrong diagnostics in " \
+                "#194). Ensure a single `rigortype` is on the load path — remove any separately-installed " \
+                "`rigortype` gem that shadows this checkout, or reinstall so the engine and its `plugins/` " \
+                "tree come from one place."
+        }
+      end
+
+      # True when `resolved_path` lives inside the engine's own tree. Both sides are resolved through
+      # `File.realpath` first so a symlinked gem home / checkout (e.g. macOS `/var` → `/private/var`) does not
+      # read as foreign; a vanished file degrades to `File.expand_path` rather than raising.
+      def inside_engine_tree?(resolved_path)
+        engine = real_or_expanded(Plugin::Loader::ENGINE_ROOT)
+        target = real_or_expanded(resolved_path)
+        target == engine || target.start_with?("#{engine}#{File::SEPARATOR}")
+      end
+
+      def real_or_expanded(path)
+        File.realpath(path)
+      rescue StandardError
+        File.expand_path(path)
+      end
+
       def check_baseline(configuration, result)
         path = configuration.baseline_path
         return [] if path.nil? || !File.exist?(path)
@@ -238,6 +323,52 @@ module Rigor
         false
       end
 
+      # Rigor is a tool, not a library (ADR-27): resolving it as one of the project's own dependencies pins the
+      # application to Rigor's Ruby and drags Rigor's dependency graph into the app's resolution. The gem carries
+      # guardrails against arriving here, but they only fire during install and at boot — a project that already
+      # made the mistake never sees them again, so doctor names the state.
+      def check_gemfile_install
+        lock = File.join(Dir.pwd, "Gemfile.lock")
+        return [] unless File.file?(lock)
+        return [] unless rubygems_sourced_rigortype?(lock)
+
+        [
+          {
+            check: CHECK_GEMFILE,
+            status: :fail,
+            message: "Rigor is resolved as a dependency of this project (`rigortype` under GEM in Gemfile.lock)",
+            hint: "Remove `rigortype` from the Gemfile and install Rigor on its own — see " \
+                  "https://github.com/rigortype/rigor/blob/master/docs/install.md. To keep the version " \
+                  "pinned, use `mise use --pin gem:rigortype`, or an isolated `BUNDLE_GEMFILE` holding only " \
+                  "Rigor (the CI chapter's pattern), which leaves your application's resolution untouched."
+          }
+        ]
+      end
+
+      # True only when `rigortype` resolves from a GEM remote — i.e. an ordinary `gem "rigortype"` in the app's
+      # Gemfile, the case worth reporting.
+      #
+      # The source is load-bearing, not decoration: Rigor's own repo, every fork of it, and any project vendoring
+      # Rigor for development all carry `rigortype` in Gemfile.lock too — under PATH (`remote: .`, from the
+      # `gemspec` directive) or GIT. Matching the name alone would fail this check on Rigor itself. Reading the
+      # lock by section also keeps a CHECKSUMS entry and a *dependency* line nested under another gem (six-space
+      # indent) from counting as a resolution.
+      def rubygems_sourced_rigortype?(path)
+        section = nil
+        in_specs = false
+
+        File.foreach(path) do |line|
+          case line
+          when /\A(\S.*?)\s*\z/ then (section = Regexp.last_match(1)) && (in_specs = false)
+          when /\A  specs:\s*\z/ then in_specs = true
+          when /\A    rigortype \(/ then return true if section == "GEM" && in_specs
+          end
+        end
+        false
+      rescue StandardError
+        false
+      end
+
       # ------------------------------------------------------------------
       # Reporting
       # ------------------------------------------------------------------
@@ -272,7 +403,9 @@ module Rigor
         if failures.empty? && warnings.empty?
           @out.puts("rigor doctor: all checks passed — no setup problems detected.")
         else
-          @out.puts("rigor doctor: #{failures.size} issue(s) found")
+          # Count warnings too: a warn-only run (a degraded RBS env, a malformed baseline) used to headline
+          # "0 issue(s) found" above the very finding it was reporting.
+          @out.puts("rigor doctor: #{summary_counts(failures, warnings)}")
           failures.each { |f| print_finding(f) }
           warnings.each { |f| print_finding(f) } unless warnings.empty?
         end
@@ -280,6 +413,13 @@ module Rigor
         passes.each { |f| print_finding(f) } unless passes.empty?
       end
 
+      def summary_counts(failures, warnings)
+        parts = []
+        parts << "#{failures.size} issue(s)" unless failures.empty?
+        parts << "#{warnings.size} warning(s)" unless warnings.empty?
+        "#{parts.join(', ')} found"
+      end
+
       def print_finding(finding)
         label = case finding[:status]
                 when :fail then "[FAIL]"

data/lib/rigor/cli/lsp_command.rb

@@ -2,6 +2,7 @@
 
 require_relative "command"
 require_relative "options"
+require_relative "../runtime/jit"
 
 require "optionparser"
 
@@ -25,6 +26,10 @@ module Rigor
           return CLI::EXIT_USAGE
         end
 
+        # A long-lived server always outlasts the JIT compile cost, so enable
+        # YJIT at boot rather than on the analysis deadline (Runtime::Jit).
+        Runtime::Jit.enable_now
+
         require_relative "../language_server"
         require_relative "../configuration"
         require "language_server-protocol"

data/lib/rigor/cli/mcp_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "command"
+require_relative "../runtime/jit"
 
 require "optionparser"
 
@@ -27,6 +28,10 @@ module Rigor
           return CLI::EXIT_USAGE
         end
 
+        # A long-lived server always outlasts the JIT compile cost, so enable
+        # YJIT at boot rather than on the analysis deadline (Runtime::Jit).
+        Runtime::Jit.enable_now
+
         require_relative "../mcp"
         require_relative "../version"
 

data/lib/rigor/cli/plugins_command.rb

@@ -7,6 +7,8 @@ require_relative "options"
 require_relative "../plugin"
 require_relative "../plugin/loader"
 require_relative "../plugin/services"
+require_relative "../plugin/inflector"
+require_relative "../environment/bundle_sig_discovery"
 require_relative "../reflection"
 require_relative "../type/combinator"
 require_relative "plugins_renderer"
@@ -67,7 +69,8 @@ module Rigor
         configuration = Configuration.load(options.fetch(:config))
         rows = build_rows(configuration)
 
-        renderer = PluginsRenderer.new(rows: rows, configuration_path: config_path)
+        renderer = PluginsRenderer.new(rows: rows, configuration_path: config_path,
+                                       inflection: inflection_note(configuration, rows))
         @out.puts(render(renderer, options))
 
         any_load_errors = rows.any? { |row| row.fetch(:status) == :load_error }
@@ -129,6 +132,25 @@ module Rigor
         rows + orphan_errors
       end
 
+      # ADR-90 — activation-time visibility for inflection degradation. When a loaded plugin consumes
+      # `Plugin::Inflector` (ADR-39), probe whether the real `ActiveSupport::Inflector` is actually
+      # reachable — through Rigor's own gem environment or the analyzed project's bundle — so a standalone
+      # install where every inflection-dependent check would silently produce no diagnostics says so here
+      # instead of reporting an unqualified `[OK]`. Returns nil when no consumer is loaded (a non-Rails
+      # project never sees the probe).
+      def inflection_note(configuration, rows)
+        loaded_ids = rows.filter_map { |row| row[:id] if row[:status] == :loaded }
+        required_by = loaded_ids & Plugin::Inflector::CONSUMER_PLUGIN_IDS
+        return nil if required_by.empty?
+
+        Plugin::Isolation.target_bundle_root ||= Environment::BundleSigDiscovery.resolve_bundle_path(
+          bundle_path: configuration.bundler_bundle_path,
+          project_root: Dir.pwd,
+          auto_detect: configuration.bundler_auto_detect
+        )&.to_s
+        { required_by: required_by, available: Plugin::Inflector.available? }
+      end
+
       def build_services(configuration)
         Plugin::Services.new(
           reflection: Reflection,
@@ -148,7 +170,10 @@ module Rigor
         end
 
         if plugin
-          loaded_row(plugin, gem_name, config)
+          # #194 slice 1 — a loaded plugin's resolved file rides on the registry keyed by gem name (the
+          # frozen plugin instance can't carry it). nil when the gem's entry-file basename differs from its
+          # name, or the resolver couldn't pin it.
+          loaded_row(plugin, gem_name, config, registry.resolved_gem_paths[gem_name])
         else
           # Find the load error whose plugin_ref names this entry (the ref is set by Loader to the gem name on require
           # failures and to the manifest id on later failures).
@@ -168,9 +193,10 @@ module Rigor
         [derived_id, gem_name].include?(plugin.manifest.id)
       end
 
-      def loaded_row(plugin, gem_name, config)
+      def loaded_row(plugin, gem_name, config, resolved_path)
         manifest = plugin.manifest
         identity_fields(gem_name, manifest, config)
+          .merge(path: resolved_path)
           .merge(extension_fields(plugin, manifest))
           .merge(narrow_protocol_fields(plugin))
           .merge(load_error: nil)
@@ -185,7 +211,7 @@ module Rigor
         {
           node_rule_types: klass.node_rules.map { |r| r[:node_type].name }.uniq,
           dynamic_return_receivers: klass.dynamic_returns.flat_map { |r| r[:receivers] }.uniq,
-          type_specifier_methods: klass.type_specifiers.flat_map { |r| r[:methods] }.map(&:to_s).uniq
+          narrowing_facts_methods: klass.narrowing_facts_rules.flat_map { |r| r[:methods] }.map(&:to_s).uniq
         }
       end
 
@@ -230,6 +256,9 @@ module Rigor
           id: entry_id,
           version: nil,
           description: nil,
+          # #194 slice 1 — set only when the require SUCCEEDED but a later step failed (the loader stamps the
+          # file on the error); a require that failed outright has no resolvable file, so this stays nil.
+          path: error&.resolved_path,
           config: config,
           signature_paths: [],
           open_receivers: [],
@@ -246,7 +275,7 @@ module Rigor
           source_rbs_synthesizer: false,
           node_rule_types: [],
           dynamic_return_receivers: [],
-          type_specifier_methods: [],
+          narrowing_facts_methods: [],
           load_error: error&.message || "plugin did not register or could not be matched to a registered class"
         }
       end
@@ -310,6 +339,7 @@ module Rigor
             id: nil,
             version: nil,
             description: nil,
+            path: error.resolved_path,
             config: {},
             signature_paths: [],
             open_receivers: [], owns_receivers: [], produces: [], consumes: [],
@@ -317,7 +347,7 @@ module Rigor
             type_node_resolvers: 0,
             hkt_registrations: 0, hkt_definitions: 0,
             protocol_contracts: 0, source_rbs_synthesizer: false,
-            node_rule_types: [], dynamic_return_receivers: [], type_specifier_methods: [],
+            node_rule_types: [], dynamic_return_receivers: [], narrowing_facts_methods: [],
             load_error: error.message
           }
         end