rigortype 0.4.5 → 0.4.7

data/lib/rigor/configuration.rb

@@ -62,6 +62,10 @@ module Rigor
       "disable" => [],
       "libraries" => [],
       "signature_paths" => nil,
+      # Issue #2517 — a core signature directory loaded IN PLACE OF the `rbs` gem's `core/` (a provider such as
+      # rbs-shifter writes one for an older CRuby). `nil` (the default) loads the gem's core. Unlike
+      # `signature_paths:`, which only adds, this replaces: the default core is not loaded beside it.
+      "core_root" => nil,
       # The project's test roots: the directories (or files) holding its tests. `nil` (the default) auto-detects
       # whichever of `spec/` and `test/` exist, the same way `signature_paths: nil` auto-detects `sig/`; `[]`
       # declares that the project has none. `rigor sig-gen --params=observed` harvests call-site observations
@@ -77,10 +81,9 @@ module Rigor
         "inline_declared" => "write"
       },
       # ADR-17 — project-side monkey-patch pre-evaluation. Empty by default; users opt in by listing explicit
-      # files that the analyzer walks before per-file inference so patched-method declarations are visible
-      # across the project (e.g. `lib/core_ext/string_extensions.rb`). Slice 1 plumbing only — listed files
-      # are validated at config-load time (`pre-eval.file-not-found` on a missing path), but the dispatcher
-      # tier consuming the registry lands in slice 2.
+      # files (or globs) that the analyzer walks before per-file inference so patched-method declarations are
+      # visible across the project (e.g. `lib/core_ext/string_extensions.rb`). A missing literal path surfaces
+      # as `pre-eval.file-not-found`.
       "pre_eval" => [],
       # ADR-22 — baseline file path. nil (default) means no baseline is loaded; the `false` literal is
       # treated as the explicit-disable form for `.rigor.yml`-side override of an upstream `.rigor.dist.yml`
@@ -229,6 +232,11 @@ module Rigor
     PATH_KEYS = %w[paths signature_paths test_paths pre_eval].freeze
     private_constant :PATH_KEYS
 
+    # The single-path sibling of {PATH_KEYS}: resolved the same way, but kept a String rather than wrapped in an
+    # Array.
+    SCALAR_PATH_KEYS = %w[core_root].freeze
+    private_constant :SCALAR_PATH_KEYS
+
     # Top-level keys this implementation DECLARES but never reads — see `docs/internal-spec/config.md`
     # § "Reserved namespaces" and ADR-99.
     #
@@ -271,7 +279,8 @@ module Rigor
 
     attr_reader :target_ruby, :paths, :exclude_patterns, :plugins, :cache_path, :cache_max_bytes,
                 :cache_validation, :disabled_rules,
-                :libraries, :signature_paths, :test_paths, :fold_platform_specific_paths, :parameter_inference,
+                :libraries, :signature_paths, :core_root, :test_paths, :fold_platform_specific_paths,
+                :parameter_inference,
                 :plugins_isolation,
                 :plugins_io_network, :plugins_io_allowed_paths,
                 :plugins_io_allowed_url_hosts,
@@ -321,12 +330,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.
@@ -480,6 +499,7 @@ module Rigor
 
       out = data.dup
       PATH_KEYS.each { |key| resolve_path_key!(out, key, base_dir) }
+      SCALAR_PATH_KEYS.each { |key| resolve_scalar_path_key!(out, key, base_dir) }
       resolve_plugins_io_paths!(out, base_dir)
       out
     end
@@ -490,6 +510,12 @@ module Rigor
       out[key] = Array(out[key]).map { |p| ConfigPath.absolute(p.to_s, base_dir) }
     end
 
+    def self.resolve_scalar_path_key!(out, key, base_dir)
+      return unless out.key?(key) && out[key].is_a?(String)
+
+      out[key] = ConfigPath.absolute(out[key], base_dir)
+    end
+
     def self.resolve_plugins_io_paths!(out, base_dir)
       plugins_io = out["plugins_io"]
       return unless plugins_io.is_a?(Hash) && plugins_io["allowed_paths"]
@@ -572,6 +598,7 @@ module Rigor
       @libraries = Array(data.fetch("libraries", DEFAULTS.fetch("libraries"))).map(&:to_s).freeze
       sig_paths = data.fetch("signature_paths", DEFAULTS.fetch("signature_paths"))
       @signature_paths = sig_paths.nil? ? nil : Array(sig_paths).map(&:to_s).freeze
+      @core_root = coerce_core_root(data.fetch("core_root", DEFAULTS.fetch("core_root")))
       test_paths = data.fetch("test_paths", DEFAULTS.fetch("test_paths"))
       @test_paths = test_paths.nil? ? nil : Array(test_paths).map(&:to_s).freeze
       @sig_gen_inline_declared = coerce_sig_gen_inline_declared(data.fetch("sig_gen", nil))
@@ -585,18 +612,13 @@ module Rigor
       # ADR-67 WD6a — resolve to a strict Boolean so a truthy non-`true` value (e.g. a stray String) does not
       # silently enable the gate; only the literal `true` activates the check-walk collector pre-pass.
       @parameter_inference = data.fetch("parameter_inference", DEFAULTS.fetch("parameter_inference")) == true
-      # Resolved before `@effects` — ADR-103 WD15's "effects-on-by-default" reads {#bleeding_edge_active?},
-      # which reads `@bleeding_edge_active_ids`.
-      @bleeding_edge = coerce_bleeding_edge(
-        data.fetch("bleeding_edge", DEFAULTS.fetch("bleeding_edge"))
-      )
-      @bleeding_edge_severity_overrides = BleedingEdge.severity_overrides_for(@bleeding_edge)
-      @bleeding_edge_active_ids = BleedingEdge.active_ids_for(@bleeding_edge)
       # ADR-103 WD13 — presence, not truthiness: `effects:` written with no body parses as nil and still
-      # means "on", so the key's presence in the loaded data is what {#effects_enabled?} reads.
-      @effects = coerce_effects(data, effects_key_present: effects_key_present)
-      coerce_effects_snapshot(@effects)
-      coerce_effects_policy(@effects)
+      # means "on", so the key's presence in the loaded data is what {#effects_enabled?} reads. The raw
+      # input is kept so {#with_bleeding_edge} re-derives the effects block from the same source.
+      @effects_key_present = effects_key_present
+      @effects_written = Ractor.make_shareable(data.fetch("effects", false))
+      derive_bleeding_edge(data.fetch("bleeding_edge", DEFAULTS.fetch("bleeding_edge")))
+      derive_effects
       @cache_path = cache.fetch("path").to_s
       raw_max = cache.fetch("max_bytes")
       @cache_max_bytes = raw_max.nil? ? nil : Integer(raw_max)
@@ -662,6 +684,7 @@ module Rigor
         "disable" => disabled_rules,
         "libraries" => libraries,
         "signature_paths" => signature_paths,
+        "core_root" => core_root,
         # `test_paths:` is deliberately absent, as `effects:` is: `to_h` feeds the run cache key and the
         # incremental-snapshot fingerprint, and the test roots change no diagnostic, so editing them must not
         # invalidate either. `sig_gen:` is absent for the same reason: only `rigor sig-gen` reads it.
@@ -742,15 +765,14 @@ module Rigor
     # It is a frozen `dup` with the bleeding-edge ivars re-set: `dup` returns an unfrozen shallow copy
     # (every other ivar is the receiver's deeply-frozen value, safe to share read-only), the replacements
     # are themselves deeply frozen, and the re-`freeze` keeps the result `Ractor.shareable?` for the worker
-    # path. **Every ivar `#initialize` derives from `@bleeding_edge` has to be re-derived here** — the
-    # selector, the severity map, and the active-id set the {#bleeding_edge_active?} predicate reads.
+    # path. **Every ivar `#initialize` derives from the bleeding-edge selector has to be re-derived here** — it
+    # calls the same {#derive_bleeding_edge} and {#derive_effects} that `#initialize` does, so the selector,
+    # the severity map, the active-id set and the `effects:` default (ADR-103 WD15's "effects-on-by-default")
+    # all follow the new value, and a derived ivar added to `#initialize` is picked up without a second edit.
     def with_bleeding_edge(value)
-      selector = coerce_bleeding_edge(value)
       copy = dup
-      copy.instance_variable_set(:@bleeding_edge, selector)
-      copy.instance_variable_set(:@bleeding_edge_severity_overrides,
-                                 BleedingEdge.severity_overrides_for(selector))
-      copy.instance_variable_set(:@bleeding_edge_active_ids, BleedingEdge.active_ids_for(selector))
+      copy.send(:derive_bleeding_edge, value)
+      copy.send(:derive_effects)
       copy.freeze
     end
 
@@ -784,19 +806,38 @@ module Rigor
     #
     # Same `dup` + re-`freeze` shape as {#with_bleeding_edge}: every other ivar is the receiver's deeply
     # frozen value, safe to share read-only, and the result stays `Ractor.shareable?` for the worker path.
+    # The implicit block is recorded as a written empty one, so a later {#with_bleeding_edge} re-derives
+    # it instead of falling back to the absent-key default and dropping it.
     def with_effects_enabled
       return self if effects_enabled?
 
       copy = dup
-      copy.instance_variable_set(:@effects, {}.freeze)
-      # The implicit block defaults like a written one. `rigor effects` emits no diagnostic either way,
-      # but the two configurations must not differ in a field a later reader could branch on.
-      copy.instance_variable_set(:@effects_check, true)
+      copy.instance_variable_set(:@effects_key_present, true)
+      copy.instance_variable_set(:@effects_written, {}.freeze)
+      copy.send(:derive_effects)
       copy.freeze
     end
 
     private
 
+    # ADR-50 § WD2 / ADR-103 WD15 — derives the bleeding-edge selector and the two ivars the
+    # {#bleeding_edge_active?} predicate and the severity resolution read. `#initialize` and
+    # {#with_bleeding_edge} both call this, so there is one derivation to keep in step.
+    def derive_bleeding_edge(value)
+      @bleeding_edge = coerce_bleeding_edge(value)
+      @bleeding_edge_severity_overrides = BleedingEdge.severity_overrides_for(@bleeding_edge)
+      @bleeding_edge_active_ids = BleedingEdge.active_ids_for(@bleeding_edge)
+    end
+
+    # ADR-103 WD13 / WD15 — derives the `effects:` block and its snapshot and policy ivars from the raw
+    # `effects:` input the instance kept (`@effects_written`, `@effects_key_present`). The effects-on-by-default
+    # default reads the active-id set, so {#derive_bleeding_edge} must run first.
+    def derive_effects
+      @effects = coerce_effects(@effects_written, effects_key_present: @effects_key_present)
+      coerce_effects_snapshot(@effects)
+      coerce_effects_policy(@effects)
+    end
+
     # ADR-103 WD13 — the `effects:` block, or nil when the key is absent or explicitly `false`. A
     # present-but-empty key (`effects:` alone, which YAML parses as nil) and `effects: {}` are the same
     # thing: collection on, every sub-key defaulted. A non-Hash body is normalised to `{}` rather than
@@ -808,8 +849,7 @@ module Rigor
     # as `effects: {}` when the "effects-on-by-default" bleeding-edge feature is adopted. An explicit
     # `effects: false` — `effects_key_present == true` — always stays off regardless of the feature, and a
     # written block always wins outright: the feature can only fill an *absence*.
-    def coerce_effects(data, effects_key_present:)
-      value = data.fetch("effects", false)
+    def coerce_effects(value, effects_key_present:)
       return {}.freeze if value == false && !effects_key_present && effects_forced_on_by_bleeding_edge?
       return nil if value == false
 
@@ -1044,7 +1084,7 @@ module Rigor
       end
     end
 
-    # `target_ruby` is passed to `Prism.parse_file(path, version:)` at the analyser's three parse sites
+    # `target_ruby` is passed as Prism's `version:` option at the analyser's parse sites
     # (`Analysis::Runner`, `CLI::TypeOfCommand`, `CLI::TypeScanCommand`) so projects that target an older
     # Ruby get parse errors for syntax their target doesn't support. Format validation here is loose —
     # accepts any `<major>.<minor>` or `<major>.<minor>.<patch>` form, plus the literal `"latest"`. Prism
@@ -1087,6 +1127,18 @@ module Rigor
     # ADR-22 WD2 (b) — `baseline: <path>` activates the file; `baseline: false` is the explicit-disable form
     # (useful in `.rigor.yml` to override an upstream `.rigor.dist.yml` that names a baseline). `nil`
     # (default / absent key) is also "no baseline".
+    # Issue #2517 — the directory's existence and contents are checked where the environment is built
+    # ({Environment::CoreRoot.validate!}), not here: `rigor init`, `rigor doctor` and the language server's reload
+    # load a configuration without building an environment, and must still be able to read one naming a core that
+    # is not generated yet.
+    def coerce_core_root(value)
+      return nil if value.nil?
+      raise ConfigurationError, "core_root must be a directory path, got #{value.inspect}" unless value.is_a?(String)
+      raise ConfigurationError, "core_root must not be empty" if value.strip.empty?
+
+      value.dup.freeze
+    end
+
     def coerce_baseline_path(value)
       return nil if value.nil? || value == false
 

data/lib/rigor/effects/definition_context.rb

@@ -58,11 +58,9 @@ module Rigor
         node.is_a?(Prism::SingletonClassNode) || (node.is_a?(Prism::CallNode) && node.block.is_a?(Prism::BlockNode))
       end
 
-      # A class body.
       CLASS_BODY = of(:class, false)
       # A `class << self` body: `self` and the definee are both the singleton class.
       SINGLETON_CLASS_BODY = of(:singleton_class, true)
-      # The body of an instance method of the class.
       INSTANCE_METHOD_BODY = of(:instance, false)
       # The top level, where `self` is `main`, an instance of `Object`, and a `def` defines `Object#m`.
       TOP_LEVEL = INSTANCE_METHOD_BODY

data/lib/rigor/effects/envelope.rb

@@ -8,7 +8,7 @@ module Rigor
     # An author-declared upper bound on one method's effect labels (ADR-103 WD1; normative in
     # `docs/type-specification/effect-labels.md` § Effect envelopes).
     #
-    # Four facts and one seam:
+    # Its facts:
     #
     # - {#owner_key} — the method key the envelope binds (`Class#m` / `Class.m`). A class-level
     #   envelope is read once and {#rebind}ed onto each method of that class discovery knows.

data/lib/rigor/effects/framework_units.rb

@@ -69,7 +69,7 @@ module Rigor
       VALIDATION_TRIGGERS = %w[valid? invalid? validate!].freeze
       SINGLETON_SAVE_TRIGGERS = %w[create create!].freeze
 
-      # `initialize` is not a mailer action, and neither is a method a plugin would want double-counted.
+      # `initialize` is not a mailer action.
       NON_ACTION_METHODS = %w[initialize].to_set.freeze
 
       module_function

data/lib/rigor/effects/mutation_classifier.rb

@@ -32,13 +32,10 @@ module Rigor
       # `foo=`, and deliberately not `==` / `<=` / `!=` / `===`.
       ATTRIBUTE_WRITER = /\A[a-z_][A-Za-z0-9_]*=\z/
 
-      # Every Hash method that mutates its receiver. The widening keeps two tables because they answer two different
-      # questions of a `HashShape` — `MutationWidening::HASH_MUTATORS` changes the pair set,
-      # `HashLookupMutation::MUTATORS` changes what a read of the pairs answers — but either is a write to the
-      # receiver, and that is all this asks: `h.compare_by_identity` raises `FrozenError` on a frozen hash as
-      # `h.clear` does (unless the hash already compares by identity, when it returns before the check), and a
-      # method whose one effect was `@h.compare_by_identity` did not read as mutating while this cited the first
-      # table alone.
+      # Every Hash method that mutates its receiver: the union of two widening tables that answer different
+      # questions of a `HashShape` (the pair set; what a read of the pairs answers). Either is a write to the
+      # receiver, so either counts. `compare_by_identity` lives only in the second, and it raises `FrozenError`
+      # on a frozen hash as `h.clear` does, so a method whose one effect is that call must still read as mutating.
       #
       # `rehash` is in neither table because it changes no read a shape can state: a shape's keys are literals, which
       # a rebuild never merges. It still rebuilds the receiver's table in place, and it is the one name spelt here.

data/lib/rigor/effects/propagator.rb

@@ -363,7 +363,7 @@ module Rigor
         # dispatch target is spelled under a different key, and this is the rewrite: the same ancestor walk
         # {#resolve_owner} performs, on the instance side, for `initialize`.
         #
-        # Three boundaries, and each of them can only narrow:
+        # Four boundaries, and each of them can only narrow:
         #
         # - a project `def self.new` **wins**. It is the definition `Const.new` actually reaches, and a
         #   constructor that overrides `new` is the case where `#initialize` is not the answer. Resolved

data/lib/rigor/effects/registry.rb

@@ -35,8 +35,8 @@ module Rigor
       # without proposing an unrelated label for a genuinely new spelling.
       SUGGESTION_DISTANCE_CAP = 2
 
-      # The shared registry as shipped. Memoised: the YAML parse is a once-per-process cost, and
-      # nothing consumes the registry yet, so it stays lazy rather than paying at `require "rigor"`.
+      # The shared registry as shipped. Memoised: the YAML parse is a once-per-process cost, so it stays
+      # lazy rather than paying at `require "rigor"`.
       def self.default
         @default ||= load_file(DATA_PATH)
       end

data/lib/rigor/effects/snapshot.rb

@@ -55,7 +55,7 @@ module Rigor
       #
       # A count rather than the causes themselves (#434). On redmine the cause renderings were 144,771 of
       # the file's 293,276 bytes, on lines up to 821 characters — simultaneously the half a reviewer
-      # cannot read and the half that churns when an unrelated call moves. This file already makes that
+      # cannot read and the half that churns when an unrelated call moves. {SnapshotDiff} already makes that
       # argument about origins ("a record keyed by them would churn on every refactor"); the causes are
       # the same class of thing and were the one place it was not applied. What a reviewer needs from the
       # record is the stable fact that the row is not exhaustive and by how much, which is what a count

data/lib/rigor/effects/taint_cause.rb

@@ -8,8 +8,6 @@ module Rigor
     # A tainted summary reads "these effects, and possibly more": the cause says which knowledge the
     # analyzer could not have. Taint never produces a finding — diagnostics read the proven lane
     # only — so this enum is a reporting vocabulary, not a diagnostic one.
-    #
-    # Nothing produces causes yet; the collector of #379 is the first writer.
     module TaintCause
       # Closed and ordered by how it arises: dispatch the analyzer could not resolve first, then
       # attribution it had to take on trust, then the collector's own limits.

data/lib/rigor/effects/unit_scan.rb

@@ -586,9 +586,9 @@ module Rigor
       # #1071 widens the answer per `respond_to` arm: a unit that spelled a dispatcher renders one
       # conventional `<action>.<fmt>` template per arm rather than one `<action>.html`, so the row is
       # applied once per arm the walk read, each answered outright (a `responds:` row at the arm's own
-      # top level) or degenerate (`any` / `all`) standing its arm's edge down. The `<action>.html`
-      # answer survives only for a dispatcher the walk could not name arms on, or one nested under a
-      # branch — the plain fall-through still exists on the path that skips it.
+      # top level) or degenerate (`any` / `all`) standing its arm's edge down. The `<action>.html` answer
+      # is kept where no arm was read, and beside the arms when the dispatcher is nested under a branch,
+      # because the plain fall-through still exists on the path that skips it.
       def apply_unit_callees
         return if @responded || @singleton || @non_public
         return if @owner_class.nil? || @method_name.nil?
@@ -811,11 +811,9 @@ module Rigor
       #
       # **Unless the syntax named the class** (#463). The `Dynamic` exclusion exists because a projected
       # receiver class is a guess; a written constant path is not one, and {#catalog_target} already
-      # trusts it for the row lookup. Refusing the posture there made the catalogue's reach a function of
-      # whether the bundled rbs happens to ship a signature for the constant: `Net::HTTP.get` proves
-      # `io.net.http` and `Net::IMAP.new` proved nothing, because rbs ships `net-http` and not
-      # `net-imap`. That is why the `Net::FTP` row has never once fired, and why Redmine's IMAP and POP3
-      # pollers proved no network at all.
+      # trusts it for the row lookup. Refusing the posture there made the catalogue's reach depend on
+      # whether the bundled rbs ships a signature for the constant: `Net::HTTP.get` proved `io.net.http`,
+      # while `Net::IMAP.new` proved nothing, because rbs ships `net-http` and not `net-imap`.
       #
       # The site is then **claimed**, and so discharges, like every other catalogue answer. That is not a
       # softening of the `dynamic-receiver` rule but its premise failing: the taint says the class the
@@ -974,12 +972,10 @@ module Rigor
         positional_arity(node).positive?
       end
 
-      # The class the catalogue would look this call up under, as `[owner, singleton, implicit_self]`.
+      # The class the catalogue would look this call up under, as `[owner, singleton, implicit, named]`.
       # Spelled from the syntax where the syntax settles it and from the typer's receiver otherwise;
-      # `[nil, …]` when neither does.
-      # `[owner, singleton, implicit, named]`. `named` says the owner came from a **constant path the
-      # author wrote**, which is what licenses the posture on a receiver the typer could not resolve
-      # ({#posture_allowed?}).
+      # `[nil, …]` when neither does. `named` says the owner came from a **constant path the author wrote**,
+      # which is what licenses the posture on a receiver the typer could not resolve ({#posture_allowed?}).
       def catalog_target(node, record)
         receiver = node.receiver
         return ["Kernel", false, true, false] if receiver.nil? || receiver.is_a?(Prism::SelfNode)

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -31,7 +31,7 @@ module Rigor
       # The list is hard-coded for the MVP because it tracks rigor's bundled coverage 1:1. When a new gem is
       # vendored under `data/vendored_gem_sigs/` or added to `DEFAULT_LIBRARIES`, add its name here.
       SKIPPED_GEMS_BY_DEFAULT = Set[
-        # DEFAULT_LIBRARIES (lib/rigor/environment.rb)
+        # DEFAULT_LIBRARIES (lib/rigor/environment/default_libraries.rb)
         "pathname", "optparse", "json", "yaml", "fileutils",
         "tempfile", "tmpdir", "stringio", "forwardable",
         "digest", "securerandom", "uri", "logger", "date",
@@ -100,14 +100,10 @@ module Rigor
         expected_dirs = expected_gem_dirs(locked_gems)
         filtered.select do |sig_dir|
           if git_sourced_layout?(sig_dir)
-            # A git install's directory name carries no resolvable version (see above), so the lockfile
-            # filter can only check the gem NAME, not `(name, version)` — but name alone is not enough: a
-            # gem that used to be `git:`-sourced and has since moved to a released version keeps its old
-            # `bundler/gems/<repo>-<sha>/` directory sitting in the bundle tree until a `bundle clean`, and
-            # its NAME is still present in the lockfile (now via the rubygems entry). Matching on name only
-            # would silently readmit that stale git install — this repo's own `vendor/bundle` had exactly
-            # this after `binpacker` moved from `git:` to a released gem. `locked_gems` must say this name is
-            # CURRENTLY git-sourced, not merely present.
+            # A git install's directory carries no version, so the lockfile filter can only check the gem NAME.
+            # Name alone is not enough: a gem that moved from `git:` to a released version keeps its stale
+            # `bundler/gems/` checkout until `bundle clean`, under a name the lockfile still lists. `locked_gems`
+            # must say this name is CURRENTLY git-sourced, not merely present.
             locked = locked_gems[gem_name_from_sig_path(sig_dir)]
             !!locked&.git_source
           else

data/lib/rigor/environment/class_registry.rb

@@ -9,8 +9,8 @@ module Rigor
     # This is the static fast path for built-ins; `Environment` falls through to `RbsLoader` for all other
     # names — the two tiers are complementary.
     #
-    # See docs/internal-spec/inference-engine.md for the binding contract (every entry below MUST always be
-    # recognised).
+    # See docs/internal-spec/inference-engine.md for the binding contract (the classes in
+    # `SLICE_1_BUILT_INS` MUST always be recognised).
     class ClassRegistry
       SLICE_1_BUILT_INS = [
         Integer,
@@ -27,7 +27,7 @@ module Rigor
       # Common Ruby core classes that user code routinely names by constant reference. Adding them to the
       # registry lets `nominal_for_name` resolve `Array`, `Hash`, etc. without each call site re-listing
       # them. The static registry is the cheap fast path; `RbsLoader` extends coverage to all other
-      # RBS-declared names (Slice 4, landed).
+      # RBS-declared names.
       SLICE_2_BUILT_INS = [
         Array,
         Hash,

data/lib/rigor/environment/core_root.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../configuration_error"
+require_relative "../rooted_glob"
+
+module Rigor
+  class Environment
+    # Issue #2517 — a core signature directory chosen IN PLACE OF the `rbs` gem's own `core/` (`core_root:` in
+    # `.rigor.yml`). The caller is a provider such as rbs-shifter, which rewrites upstream core for an older
+    # CRuby (`Array#rfind` gone, `String#strip` without arguments); Rigor accepts the directory and passes it to
+    # `RBS::EnvironmentLoader.new(core_root:)`, so the default core is never loaded beside it.
+    #
+    # An explicit choice is never second-guessed by a fallback: a directory that is missing, unreadable or holds
+    # no signature, and an environment that fails to build from it, raise {CoreRootError} instead of analysing
+    # against the default core or against a degraded `Dynamic[top]` environment. Both would report a project as
+    # clean for the very APIs the selection exists to reject.
+    module CoreRoot
+      module_function
+
+      # @param path — the configured directory, already resolved against the config file's directory.
+      # @return the absolute directory as a frozen String (`Ractor.shareable?`, so a frozen loader stays shareable).
+      # @raise CoreRootError — the directory cannot serve as a core.
+      def validate!(path)
+        absolute = File.expand_path(path.to_s)
+        reason = invalid_reason(absolute)
+        raise CoreRootError, "core_root: #{absolute.inspect} #{reason}" if reason
+
+        absolute.dup.freeze
+      end
+
+      # A selected core inside a signature root, or one containing it, loads its files twice — once as core and once
+      # as project signatures — and every class it declares then fails to build on its duplicated methods.
+      #
+      # @param core_root — a {.validate!}d directory.
+      # @param signature_paths — the project's own signature roots.
+      # @raise CoreRootError — the two overlap.
+      def reject_overlap!(core_root, signature_paths)
+        core = File.join(real_path(core_root), "")
+        Array(signature_paths).each do |path|
+          root = File.join(real_path(path), "")
+          next unless core.start_with?(root) || root.start_with?(core)
+
+          raise CoreRootError, "core_root: #{core_root.inspect} overlaps the signature path #{path.to_s.inspect}, so " \
+                               "its signatures would load twice; move the core outside the project's signature paths"
+        end
+      end
+
+      # Compared resolved, because the project-signature walk does not follow a symlinked directory: a `sig/core`
+      # link to a core kept elsewhere loads once, as core, and must not be rejected. A path that does not exist yet
+      # resolves through its nearest existing ancestor, so the two sides of a comparison are spelled alike.
+      def real_path(path)
+        absolute = File.expand_path(path.to_s)
+        missing = []
+        until File.exist?(absolute) || File.dirname(absolute) == absolute
+          missing.unshift(File.basename(absolute))
+          absolute = File.dirname(absolute)
+        end
+        File.join(File.realpath(absolute), *missing)
+      rescue SystemCallError
+        File.expand_path(path.to_s)
+      end
+
+      def invalid_reason(absolute)
+        return "does not exist" unless File.exist?(absolute)
+        return "is not a directory" unless File.directory?(absolute)
+        return "is not readable" unless File.readable?(absolute)
+
+        "contains no .rbs signature file" if RootedGlob.glob(absolute, "**/*.rbs").empty?
+      end
+    end
+
+    # The selected core cannot be used. A {ConfigurationError}, so the CLI reports it as one `rigor:` line with
+    # the usage exit code rather than as a crash.
+    class CoreRootError < ConfigurationError
+    end
+  end
+end

data/lib/rigor/environment/default_libraries.rb

@@ -2,7 +2,7 @@
 
 module Rigor
   class Environment
-    # Slice A stdlib expansion. Stdlib libraries that `Environment.for_project` loads on top of RBS core
+    # Stdlib libraries that `Environment.for_project` loads on top of RBS core
     # unless the caller passes an explicit `libraries:` array. Each entry MUST be a stdlib library name
     # accepted by `RBS::EnvironmentLoader#has_library?`; unknown libraries MUST fail-soft
     # (`RbsLoader#build_env` already filters through `has_library?`). The default set covers the common