rigortype 0.4.5 → 0.4.6

data/lib/rigor/cli/diff_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "command"
+require_relative "options"
 
 require "json"
 require "optionparser"
@@ -63,7 +64,7 @@ module Rigor
             options[:current_path] = path
           end
           opt.on("--config=PATH", "Path to .rigor.yml. Forwarded to the implicit `rigor check` run.") do |path|
-            options[:config] = path
+            options[:config] = Options.config_path(path)
           end
         end.parse!(@argv)
         options

data/lib/rigor/cli/lens_command.rb

@@ -22,11 +22,6 @@ module Rigor
         return CLI::EXIT_USAGE if options.nil?
 
         config = options.fetch(:config)
-        if config && !File.file?(config)
-          usage_error("no configuration file at #{config}")
-          return CLI::EXIT_USAGE
-        end
-
         configuration = Configuration.load(config)
         config_path = options.fetch(:config) || Configuration.discover
         # The working directory: Rigor auto-detects sig/ and the lockfiles there (lens.md § Serialization).
@@ -56,6 +51,11 @@ module Rigor
         options
       rescue OptionParser::ParseError => e
         usage_error(e.message)
+      rescue Rigor::ConfigurationError => e
+        # The shared --config check (CLI::Options.config_path). Mapped here the way Rigor::CLI#run maps it, so a
+        # direct LensCommand run exits with the usage code too.
+        @err.puts("rigor: #{e.message}")
+        nil
       end
 
       def usage_error(message)

data/lib/rigor/cli/mcp_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "command"
+require_relative "options"
 require_relative "../runtime/jit"
 
 require "optionparser"
@@ -54,7 +55,7 @@ module Rigor
           end
           opts.on("--config=PATH",
                   "Session-level default config path (individual tool calls may override)") do |value|
-            options[:config] = value
+            options[:config] = Options.config_path(value)
           end
         end
         parser.parse!(@argv)

data/lib/rigor/cli/options.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../analysis/buffer_binding"
+require_relative "../configuration_error"
 
 module Rigor
   class CLI
@@ -10,15 +11,31 @@ module Rigor
     # `--instead-of` flag pair and the buffer-binding resolution that validates it. That resolution used to be copied
     # verbatim into both `Rigor::CLI` and `TypeOfCommand`, so a fix to one (the paired-flag check, the readability
     # check, the error wording) could silently miss the other. Centralising it keeps the two editor-mode entry points in
-    # lockstep.
+    # lockstep. It also owns the `--config` check (#1992), so every command and the MCP tools that pass `--config`
+    # read the same rule.
     module Options
       module_function
 
       # Defines the standard `--config=PATH` flag on `parser`, writing the path into `options[:config]`. Used by every
       # subcommand that loads a `.rigor.yml`; the few whose `--config` help text is intentionally bespoke (`diff`,
-      # `mcp`, `show-bleedingedge`) keep their own `parser.on` rather than this shared wording.
+      # `mcp`, `show-bleedingedge`) keep their own `parser.on` and call {.config_path} for the same check.
       def add_config(parser, options)
-        parser.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+        parser.on("--config=PATH", "Path to the Rigor configuration file") do |value|
+          options[:config] = config_path(value)
+        end
+      end
+
+      # The `--config` value, checked where the flag is read (#1992). A named file that is not there is an error, not
+      # a request for the defaults: the run would otherwise analyse under a configuration the caller did not ask for,
+      # and an MCP caller would get a result for it with no sign anything was missing. Auto-discovery, with no
+      # `--config` given, is not affected.
+      def config_path(value)
+        raise ConfigurationError, "empty config path" if value.strip.empty?
+        raise ConfigurationError, "config path is a directory: #{value}" if File.directory?(value)
+        raise ConfigurationError, "config file not found: #{value}" unless File.exist?(value)
+        raise ConfigurationError, "config file not readable: #{value}" unless File.readable?(value)
+
+        value
       end
 
       # Defines the `--tmp-file` / `--instead-of` editor-mode flag pair on `parser`, writing into `options`.

data/lib/rigor/cli/plugins_command.rb

@@ -233,6 +233,8 @@ module Rigor
           signature_paths: signature_path_rows(plugin),
           open_receivers: manifest.open_receivers.dup,
           owns_receivers: manifest.owns_receivers.dup,
+          per_invocation_classes: manifest.per_invocation_classes.dup,
+          per_invocation_non_action_macros: manifest.per_invocation_non_action_macros.map(&:to_s),
           produces: manifest.produces.map(&:to_s),
           consumes: manifest.consumes.map { |c| "#{c.plugin_id}/#{c.name}#{'?' if c.optional}" },
           source_rbs_synthesizer: !manifest.source_rbs_synthesizer.nil?
@@ -265,6 +267,8 @@ module Rigor
           signature_paths: [],
           open_receivers: [],
           owns_receivers: [],
+          per_invocation_classes: [],
+          per_invocation_non_action_macros: [],
           produces: [],
           consumes: [],
           block_as_methods: 0,
@@ -345,6 +349,7 @@ module Rigor
             config: {},
             signature_paths: [],
             open_receivers: [], owns_receivers: [], produces: [], consumes: [],
+            per_invocation_classes: [], per_invocation_non_action_macros: [],
             block_as_methods: 0, heredoc_templates: 0, trait_registries: 0,
             type_node_resolvers: 0,
             hkt_registrations: 0, hkt_definitions: 0,

data/lib/rigor/cli/plugins_renderer.rb

@@ -185,12 +185,26 @@ module Rigor
         lines = []
         lines << "        open_receivers: #{row[:open_receivers].join(', ')}" if row[:open_receivers].any?
         lines << "        owns_receivers: #{row[:owns_receivers].join(', ')}" if row[:owns_receivers].any?
+        lines.concat(per_invocation_lines(row))
         lines << "        produces: #{row[:produces].join(', ')}" if row[:produces].any?
         lines << "        consumes: #{row[:consumes].join(', ')}" if row[:consumes].any?
         lines.concat(narrow_protocol_lines(row))
         lines
       end
 
+      # ADR-125 — the per-invocation classes a plugin vouches for, and the macros whose arguments name a method that is
+      # not one of their actions.
+      def per_invocation_lines(row)
+        lines = []
+        if row[:per_invocation_classes].any?
+          lines << "        per_invocation_classes: #{row[:per_invocation_classes].join(', ')}"
+        end
+        if row[:per_invocation_non_action_macros].any?
+          lines << "        per_invocation_non_action_macros: #{row[:per_invocation_non_action_macros].join(', ')}"
+        end
+        lines
+      end
+
       # ADR-37 narrow extension protocols (node_rule / dynamic_return / narrowing_facts). Surfaced in the full report
       # alongside the declarative surfaces; `--capabilities` is the focused view.
       def narrow_protocol_lines(row)
@@ -249,8 +263,6 @@ module Rigor
           "signature_paths" => row[:signature_paths].map do |sp|
             { "path" => sp[:path], "exists" => sp[:exists], "rbs_files" => sp[:rbs_files] }
           end,
-          "open_receivers" => row[:open_receivers],
-          "owns_receivers" => row[:owns_receivers],
           "produces" => row[:produces],
           "consumes" => row[:consumes],
           "block_as_methods" => row[:block_as_methods],
@@ -265,6 +277,16 @@ module Rigor
           "dynamic_return_receivers" => row[:dynamic_return_receivers],
           "narrowing_facts_methods" => row[:narrowing_facts_methods],
           "load_error" => row[:load_error]
+        }.merge(receiver_json(row))
+      end
+
+      # ADR-125 — the per-invocation keys are additive; an empty array when the plugin declares none.
+      def receiver_json(row)
+        {
+          "open_receivers" => row[:open_receivers],
+          "owns_receivers" => row[:owns_receivers],
+          "per_invocation_classes" => row[:per_invocation_classes],
+          "per_invocation_non_action_macros" => row[:per_invocation_non_action_macros]
         }
       end
 

data/lib/rigor/cli/show_bleedingedge_command.rb

@@ -6,6 +6,7 @@ require "optionparser"
 require_relative "../bleeding_edge"
 require_relative "../configuration"
 require_relative "command"
+require_relative "options"
 
 module Rigor
   class CLI
@@ -44,7 +45,7 @@ module Rigor
             options[:format] = fmt
           end
           opt.on("--config=PATH", "Path to a .rigor.yml (default: auto-discovery).") do |path|
-            options[:config] = path
+            options[:config] = Options.config_path(path)
           end
         end.parse!(@argv)
         options

data/lib/rigor/cli/sig_gen_command.rb

@@ -3,6 +3,7 @@
 require "optionparser"
 
 require_relative "../configuration"
+require_relative "../analysis/path_expansion"
 require_relative "../effects/config_envelopes"
 require_relative "../effects/registry"
 require_relative "options"
@@ -55,8 +56,11 @@ module Rigor
         configuration = Configuration.load(options.fetch(:config))
         paths = @argv.empty? ? configuration.paths : @argv
 
+        path_errors = path_diagnostics(paths, configuration)
+        report_path_errors(path_errors, options)
+
         observation_roots = observation_roots(configuration, options)
-        observations = collect_observations(configuration, options, observation_roots)
+        observations = collect_observations(configuration, options, observation_roots, paths)
         generator = SigGen::Generator.new(configuration: configuration, paths: paths,
                                           observations: observations,
                                           include_private: options.fetch(:include_private),
@@ -69,15 +73,20 @@ module Rigor
                  when :write then dispatch_write(candidates, configuration, options)
                  when :check then dispatch_check(candidates, configuration, options)
                  else
-                   dispatch_print_or_diff(candidates, mode, options, observation_roots)
+                   dispatch_print_or_diff(candidates, mode, options, observation_roots, path_errors)
                    0
                  end
+        status = 1 if path_errors.any?(&:error?)
+        report_run_notes(candidates, generator, options)
+        status
+      end
+
+      def report_run_notes(candidates, generator, options)
         report_skipped(candidates, options)
         report_inline_declared(candidates, options)
         report_withheld_annotations(candidates, options)
         report_unrenderable(generator.unrenderable)
         report_unresolvable_superclasses(generator.unresolvable_superclasses)
-        status
       end
 
       private
@@ -220,13 +229,38 @@ module Rigor
         unresolvable.sort.each { |class_name, superclass| @err.puts("  #{class_name} < #{superclass}") }
       end
 
-      def dispatch_print_or_diff(candidates, mode, options, observation_roots)
+      # #1991 — the path errors `rigor check` reports for the arguments: a path that is neither a directory nor a
+      # `.rb` file. Warned about beside files that will be read, an error when nothing will be, as `check` grades it.
+      def path_diagnostics(paths, configuration)
+        bad = Analysis::PathExpansion.unusable(paths)
+        return [] if bad.empty?
+
+        any_files = !Analysis::PathExpansion.ruby_files(paths, configuration.exclude_patterns,
+                                                        base: configuration.exclude_base).empty?
+        Analysis::PathExpansion.diagnostics(bad, any_files: any_files)
+      end
+
+      # Without this a missing path was read as empty, so the run said "No candidates" and exited 0 (#1991). JSON
+      # print/diff carries the errors in its payload (see {#path_errors_in_payload?}); every other form says them on
+      # stderr, as `rigor check` does.
+      def report_path_errors(path_errors, options)
+        return if path_errors_in_payload?(options)
+
+        path_errors.each { |diagnostic| @err.puts(diagnostic.to_s) }
+      end
+
+      def path_errors_in_payload?(options)
+        options.fetch(:format) == "json" && %w[print diff].include?(options.fetch(:mode))
+      end
+
+      def dispatch_print_or_diff(candidates, mode, options, observation_roots, path_errors)
         SigGen::Renderer.new(out: @out).render(
           candidates: candidates,
           mode: mode,
           format: options.fetch(:format),
           selection: options.fetch(:selection),
-          observation: observation_report(observation_roots, options)
+          observation: observation_report(observation_roots, options),
+          diagnostics: path_errors_in_payload?(options) ? path_errors : []
         )
       end
 
@@ -291,7 +325,11 @@ module Rigor
       # specified, observe the project's test roots: `test_paths:`, or whichever of `spec/` and `test/` exist. With no
       # root at all the run still succeeds, but says so — otherwise every parameter stays `untyped` with nothing
       # naming the reason.
-      def collect_observations(configuration, options, observe_paths)
+      #
+      # The collector pre-indexes the classes of the paths the run generates for as well as the configured ones, so
+      # a call site on a class named only on the command line (`sig-gen ../lib` from a subdirectory, where no
+      # config file is discovered and the default `paths:` resolve under the subdirectory) attaches (#2078).
+      def collect_observations(configuration, options, observe_paths, paths)
         return {} if options.fetch(:params) != "observed"
 
         if observe_paths.empty?
@@ -299,7 +337,8 @@ module Rigor
         else
           warn_missing_test_roots(observe_paths)
         end
-        SigGen::ObservationCollector.new(configuration: configuration, paths: observe_paths).collect
+        SigGen::ObservationCollector.new(configuration: configuration, paths: observe_paths,
+                                         source_paths: (configuration.paths + paths).uniq).collect
       end
 
       # The roots `--params=observed` reads: `--observe=PATH...` when given, else the project's test roots.

data/lib/rigor/cli/type_of_command.rb

@@ -17,6 +17,7 @@ require_relative "type_of_template_probe"
 require_relative "command"
 require_relative "options"
 require_relative "../project_environment"
+require_relative "type_of_project_scope"
 
 module Rigor
   class CLI
@@ -88,7 +89,7 @@ module Rigor
       def execute(targets:, options:, buffer: nil)
         configuration = Configuration.load(options.fetch(:config))
         environment = project_environment(targets.map(&:file).uniq, configuration, buffer)
-        base_scope = Scope.empty(environment: environment)
+        base_scope = TypeOfProjectScope.build(environment: environment, configuration: configuration, buffer: buffer)
 
         results_by_target = Array.new(targets.length)
         targets.each_with_index.group_by { |target, _index| target.file }.each do |file, indexed_targets|

data/lib/rigor/cli/type_of_project_scope.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../scope"
+require_relative "../protection/discovery_seed"
+
+module Rigor
+  class CLI
+    # Issue #512 — the scope `rigor type-of` probes with: single-file, plus the cross-file tables a prior
+    # `rigor check --incremental` left in the snapshot ({Protection::DiscoverySeed.from_snapshot}) when there are
+    # any. A probe never re-parses the project for its seed, so without a reusable snapshot this is the bare
+    # `Scope.empty` it always was.
+    #
+    # The seed is the full {Inference::ProjectSeedTables} fold, so a `contested_*` sibling travels with the member
+    # it qualifies (ADR-119): this is a recorded whole-index consumer in `admission_census.yml`.
+    module TypeOfProjectScope
+      module_function
+
+      def build(environment:, configuration:, buffer: nil)
+        base = Scope.empty(environment: environment)
+        seed = Protection::DiscoverySeed.from_snapshot(configuration: configuration, buffer: buffer)
+        return base if seed.nil? || seed.empty?
+
+        base.with_discovery(base.discovery.with(**seed))
+      end
+    end
+  end
+end

data/lib/rigor/config_audit.rb

@@ -156,9 +156,8 @@ module Rigor
       disable = Array(configuration.disabled_rules).filter_map do |token|
         disable_token_warning(token.to_s, plugin_ids)
       end
-      overrides = configuration.severity_overrides.keys.filter_map do |key|
-        override_key_warning(key.to_s, plugin_ids)
-      end
+      keys = configuration.severity_overrides.keys.map(&:to_s)
+      overrides = keys.filter_map { |key| override_key_warning(key, plugin_ids, keys) }
       disable + overrides
     end
 
@@ -172,14 +171,26 @@ module Rigor
     # `plugin.`-qualified key naming an unconfigured plugin, and any key outside the built-in vocabulary that is
     # not a qualified plugin id (a plugin's bare rule included), is inert. A reserved run-level row is the home of
     # this map, so naming one is never flagged; `all` is not a family wildcard here, so it is.
-    def self.override_key_warning(key, plugin_ids)
-      reason = override_key_problem(key, plugin_ids)
+    def self.override_key_warning(key, plugin_ids, present = [])
+      reason = legacy_alias_problem(key, present) || override_key_problem(key, plugin_ids)
       return nil if reason.nil?
 
       Warning.new(kind: :severity_override, message: "severity_overrides: #{key.inspect} #{reason}",
                   fields: { "token" => key })
     end
 
+    # #2005 — `disable:` expands a legacy alias to its canonical id, but the severity resolver matches canonical ids
+    # only, so an alias key reaches no row. Name the canonical id rather than accept the key. `present` holds the
+    # keys the map already has: when the canonical id is one of them, the advice to write it is already followed.
+    def self.legacy_alias_problem(key, present)
+      canonical = Analysis::CheckRules::LEGACY_RULE_ALIASES[key]
+      return nil if canonical.nil?
+
+      reason = "is a legacy alias of `#{canonical}`; the override has no effect"
+      present.include?(canonical) ? reason : "#{reason}, so write `#{canonical}`"
+    end
+    private_class_method :legacy_alias_problem
+
     def self.override_key_problem(key, plugin_ids)
       return "is not a recognized rule id; the override has no effect" if key == "all"
       return nil unless Array(Analysis::CheckRules.resolve_rule_token(key)).empty?

data/lib/rigor/configuration.rb

@@ -321,12 +321,22 @@ module Rigor
 
     # The test roots a run uses: the declared `test_paths:` as written (already resolved against the
     # config file's directory by {.load}), or — when the key is unset — whichever of
-    # {CONVENTIONAL_TEST_PATHS} is a directory under `root`, as absolute paths. `root` is the directory
-    # the run treats as the project root (the CLI's CWD), as for `signature_paths:` auto-detection.
-    def resolved_test_paths(root: Dir.pwd)
+    # {CONVENTIONAL_TEST_PATHS} is a directory under a root, as absolute paths. The roots, unless `root` names
+    # one, are the directory of the config file in use, the one `paths:` and a declared `test_paths:` resolve
+    # against, and then the working directory, read only when the first holds neither. Auto-detecting against
+    # the working directory alone found nothing for a run from a subdirectory, or for the MCP server started
+    # elsewhere, though both name the config file (#2078); a config file kept in a subdirectory
+    # (`--config=config/rigor.yml`) still finds the project's `spec/` from the project root.
+    def resolved_test_paths(root: nil)
       return test_paths unless test_paths.nil?
 
-      CONVENTIONAL_TEST_PATHS.map { |dir| File.absolute_path(dir, root) }.select { |dir| File.directory?(dir) }
+      roots = root ? [root] : [exclude_base, Dir.pwd].uniq
+      roots.each do |dir|
+        found = CONVENTIONAL_TEST_PATHS.map { |test_dir| File.absolute_path(test_dir, dir) }
+                                       .select { File.directory?(it) }
+        return found unless found.empty?
+      end
+      []
     end
 
     # Loads a configuration file.

data/lib/rigor/environment/rbs_loader.rb

@@ -10,6 +10,7 @@ require_relative "member_consistency"
 require_relative "required_features"
 require_relative "gated_signature_guard"
 require_relative "gated_signature_plan"
+require_relative "ruby_library_roots"
 require_relative "../rooted_glob"
 
 module Rigor
@@ -1653,9 +1654,10 @@ module Rigor
       #   arity. Read back by the env-cache producer, which rebuilds the env from the loader's readers on
       #   a miss — a list it cannot read is a stand-down that runs only on a `--no-cache` build.
       def initialize(libraries: [], signature_paths: [], cache_store: nil, virtual_rbs: [],
-                     deferred_signature_paths: [])
+                     deferred_signature_paths: [], project_signature_paths: [], required_features: [])
         @libraries = libraries.map(&:to_s).freeze
         @signature_paths = signature_paths.map { |p| Pathname(p) }.freeze
+        assign_reopen_inputs(project_signature_paths, required_features)
         # Issue #610 — the subset of `signature_paths:` a bundled PLUGIN contributed. Loaded last and
         # allowed to stand down against a colliding generic arity ({.add_deferred_signatures}). Every entry
         # is also in `@signature_paths`, so the env cache descriptor already digests these files.
@@ -1764,6 +1766,9 @@ module Rigor
       # a partial sidecar as authoritative made `sig-gen --write` on redmine report 5.9x more
       # `call.undefined-method` than the same project with no `sig/` at all.
       #
+      # A class declared only by RBS synthesized from the project's own source joins the set too
+      # ({#inline_only_entry?}, issue #1934).
+      #
       # Memoised per loader: one pass over `class_decls` (~1-2k entries), and every consumer is a check
       # rule on the analysis hot path. Attribution is by buffer NAME, which survives the ADR-54 environment
       # cache since #725 — an environment blob written before that carries the `<cached>` sentinel instead,
@@ -1777,10 +1782,14 @@ module Rigor
         return Set.new.freeze if environment.nil?
 
         project_files = self.class.project_sig_files(@signature_paths)
-        return Set.new.freeze if project_files.empty?
+        virtual_names = @virtual_rbs.to_set(&:first)
+        return Set.new.freeze if project_files.empty? && virtual_names.empty?
 
         names = environment.class_decls.each_with_object(Set.new) do |(rbs_name, entry), acc|
-          acc << rbs_name.to_s.delete_prefix("::") if self.class.project_entry?(entry, project_files)
+          next unless self.class.project_entry?(entry, project_files) ||
+                      inline_only_entry?(entry, virtual_names, project_files)
+
+          acc << rbs_name.to_s.delete_prefix("::")
         end
         names.freeze
       rescue ::RBS::BaseError
@@ -1788,6 +1797,92 @@ module Rigor
       end
       private :build_project_declared_classes
 
+      # Issue #1934 — a class whose every declaration a source RBS synthesizer (`rigor-rbs-inline`) wrote from
+      # the project's own `.rb` files is the project's as much as a `sig/` sidecar is: the declaration is the
+      # inline comments of the source under analysis, so a method another project file adds to the class (a
+      # plain `def`, or an `alias_method` whose target the inline declaration names) is the second file of an
+      # ordinary class, not an ADR-17 monkey-patch. Reading the synthesized RBS as bundled reported
+      # `alias_method :title, :label` from another file while the `alias` keyword, which upstream translates,
+      # read clean.
+      #
+      # EVERY declaration, not only the primary one, and only virtual or `sig/` buffers: a core, stdlib or gem
+      # class an inline-annotated file reopens (`class String` with a `#:` method) keeps its bundled
+      # declaration, and a project `def` on it stays the monkey-patch ADR-17 reports. A declaration whose
+      # buffer cannot be attributed (the pre-#725 `<cached>` sentinel) fails the test, which keeps the
+      # pre-#1934 reading.
+      def inline_only_entry?(entry, virtual_names, project_files)
+        return false if virtual_names.empty?
+
+        project_authored_entry?(entry, virtual_names, project_files)
+      end
+      private :inline_only_entry?
+
+      # Every declaration of `entry` sits in a project `sig/` file or in RBS synthesized from the project's
+      # source; a declaration whose buffer cannot be attributed fails the test.
+      def project_authored_entry?(entry, virtual_names, project_files)
+        buffers = self.class.entry_declarations(entry).map { |decl| self.class.declaration_buffer_name(decl) }
+        return false if buffers.empty? || buffers.any?(&:nil?)
+
+        buffers.all? { |name| virtual_names.include?(name) || project_files.include?(File.absolute_path(name)) }
+      end
+      private :project_authored_entry?
+
+      # Issue #2174 — true when every RBS declaration of `class_name` is the project's own (rbs-inline `#:`
+      # annotations, or a file under the configured `signature_paths:`) and its root constant belongs to a library
+      # Ruby ships ({RubyLibraryRoots}) that the project's source requires ({RequiredFeatures.features_of}). Such
+      # a declaration reopens a library class whose real signatures did not load (`class Matrix` with one
+      # annotated method beside `require "matrix"`, and no `matrix` RBS), so it lists only the methods the
+      # project added: the class's surface is not enumerable from it, and a call it omits is not evidence of an
+      # undefined method. A library whose RBS did load contributes a declaration of its own (core, stdlib, a gem's
+      # `sig/`, an rbs collection, a plugin's `sig/`), which takes the class out of this predicate. A project
+      # class that shares a required library's root name declines too; that is the accepted cost.
+      def ruby_library_reopen?(class_name)
+        name = class_name.to_s.delete_prefix("::")
+        return false if @required_features.empty? || !project_authored_classes.include?(name)
+
+        segments = ruby_library_roots[name.split("::").first]
+        !segments.nil? && @required_features.any? { |feature| segments.include?(feature.split("/").first) }
+      end
+
+      def ruby_library_roots
+        @state[:ruby_library_roots] ||= RubyLibraryRoots.shared
+      end
+
+      # Issue #2174 — the subset of `signature_paths:` the user configured (every entry is also in
+      # `@signature_paths`), and the features the project's source requires: read only by
+      # {#ruby_library_reopen?}.
+      def assign_reopen_inputs(project_signature_paths, required_features)
+        @project_signature_paths = project_signature_paths.map { |p| Pathname(p) }.freeze
+        @required_features = required_features.map { |feature| feature.to_s.dup.freeze }.freeze
+      end
+      private :assign_reopen_inputs
+      private :ruby_library_roots
+
+      # The class / module names every one of whose declarations is the project's own
+      # ({#project_authored_entry?}, which {#inline_only_entry?} asks behind its inline-only gate).
+      def project_authored_classes
+        @state[:project_authored_classes] ||= build_project_authored_classes
+      end
+      private :project_authored_classes
+
+      def build_project_authored_classes
+        environment = env
+        return Set.new.freeze if environment.nil?
+
+        # Only the user's configured `signature_paths:`: `@signature_paths` also holds plugin, gem-shipped,
+        # rbs-collection and overlay directories, whose declarations are a library's own.
+        project_files = self.class.project_sig_files(@project_signature_paths)
+        virtual_names = @virtual_rbs.to_set(&:first)
+        return Set.new.freeze if project_files.empty? && virtual_names.empty?
+
+        environment.class_decls.each_with_object(Set.new) do |(rbs_name, entry), acc|
+          acc << rbs_name.to_s.delete_prefix("::") if project_authored_entry?(entry, virtual_names, project_files)
+        end.freeze
+      rescue ::RBS::BaseError
+        Set.new.freeze
+      end
+      private :build_project_authored_classes
+
       # Issue #527 — the class / module names whose PRIMARY declaration lives in the `rbs` gem's own
       # `core/` or `stdlib/` tree, top-level prefix stripped.
       #
@@ -1808,9 +1903,23 @@ module Rigor
         @state[:core_stdlib_classes] ||= build_core_stdlib_classes
       end
 
-      def build_core_stdlib_classes
+      # Issue #1154 — the subset of {#core_stdlib_classes} whose primary declaration is in `core/` alone: the classes
+      # the interpreter implements, as opposed to a stdlib library written in Ruby (`Logger` rewrites `@level` in
+      # its `initialize`). Same attribution, same cache behaviour.
+      def core_class?(class_name)
+        (@state[:core_classes] ||= build_core_stdlib_classes(CORE_ROOTS)).include?(class_name.to_s.delete_prefix("::"))
+      end
+
+      CORE_ROOTS = begin
+        [::RBS::EnvironmentLoader::DEFAULT_CORE_ROOT].compact.map { |root| "#{root}/".freeze }.freeze
+      rescue StandardError
+        [].freeze
+      end
+      private_constant :CORE_ROOTS
+
+      def build_core_stdlib_classes(roots = CORE_STDLIB_ROOTS)
         environment = env
-        return Set.new.freeze if environment.nil? || CORE_STDLIB_ROOTS.empty?
+        return Set.new.freeze if environment.nil? || roots.empty?
 
         names = environment.class_decls.each_with_object(Set.new) do |(rbs_name, entry), acc|
           decl = self.class.primary_decl_for(entry)
@@ -1819,7 +1928,7 @@ module Rigor
           path = self.class.declaration_buffer_name(decl)
           next if path.nil?
 
-          acc << rbs_name.to_s.delete_prefix("::") if CORE_STDLIB_ROOTS.any? { |root| path.start_with?(root) }
+          acc << rbs_name.to_s.delete_prefix("::") if roots.any? { |root| path.start_with?(root) }
         end
         names.freeze
       rescue ::RBS::BaseError