rigortype 0.2.9 → 0.3.1

data/lib/rigor/cli/sig_gen_command.rb

@@ -42,21 +42,43 @@ module Rigor
         paths = @argv.empty? ? configuration.paths : @argv
 
         observations = collect_observations(configuration, options)
-        candidates = SigGen::Generator.new(configuration: configuration, paths: paths,
-                                           observations: observations,
-                                           include_private: options.fetch(:include_private)).run
+        generator = SigGen::Generator.new(configuration: configuration, paths: paths,
+                                          observations: observations,
+                                          include_private: options.fetch(:include_private))
+        candidates = generator.run
         mode = options.fetch(:mode).to_sym
 
-        if mode == :write
-          dispatch_write(candidates, configuration, options)
-        else
-          dispatch_print_or_diff(candidates, mode, options)
-        end
-        0
+        status = if mode == :write
+                   dispatch_write(candidates, configuration, options)
+                 else
+                   dispatch_print_or_diff(candidates, mode, options)
+                   0
+                 end
+        report_unrenderable(generator.unrenderable)
+        status
       end
 
       private
 
+      # A method whose rendered RBS does not parse is a Rigor rendering defect, not a fact about the user's
+      # code — the generator skipped it (so the rest of the signatures are still usable and still valid), but
+      # staying silent would leave the user with a quietly incomplete `sig/` and us with an unreported bug.
+      # Reported on stderr so it never contaminates `--print` output being piped into a file.
+      def report_unrenderable(unrenderable)
+        return if unrenderable.empty?
+
+        @err.puts(
+          "rigor sig-gen: skipped #{unrenderable.size} method(s) whose generated RBS does not parse. " \
+          "This is a bug in Rigor's RBS rendering, not in your code — please report it. " \
+          "The remaining signatures are unaffected."
+        )
+        unrenderable.each do |method|
+          @err.puts("  #{method.path}: #{method.class_name}##{method.method_name}")
+          @err.puts("    rendered: #{method.rbs}")
+          @err.puts("    #{method.error}")
+        end
+      end
+
       def dispatch_print_or_diff(candidates, mode, options)
         SigGen::Renderer.new(out: @out).render(
           candidates: candidates,
@@ -66,6 +88,7 @@ module Rigor
         )
       end
 
+      # @return [Integer] exit status — non-zero when a file the user asked to write could not be written.
       def dispatch_write(candidates, configuration, options)
         layout_index = SigGen::LayoutIndex.new(signature_paths: configuration.signature_paths)
         path_mapper = SigGen::PathMapper.new(configuration: configuration, layout_index: layout_index)
@@ -74,6 +97,10 @@ module Rigor
         results = writer.write_all(candidates)
 
         SigGen::Renderer.new(out: @out).render_write(results: results, format: options.fetch(:format))
+        # An assembled file that does not parse is refused rather than written. The user asked for a write and
+        # did not get one, so the command must not report success — a green `sig-gen --write` in CI would
+        # otherwise mean nothing.
+        results.any? { |result| result.action == :skipped_invalid_rbs } ? 1 : 0
       end
 
       # Slice 3 — collect call-site argument observations when `--params=observed` is set. When `--observe=PATH` is not

data/lib/rigor/cli/skill_command.rb

@@ -36,10 +36,15 @@ module Rigor
     #                                version-coupled guidance is frozen into
     #                                the SKILL. Also spelled `describe`, and
     #                                surfaced top-level as `rigor describe`.
+    # - `rigor skill describe --deep`
+    #                              — the same report, except it runs `rigor
+    #                                check` first and lets the result pick the
+    #                                headline. Opt-in because that is slow and
+    #                                writes the cache; the un-flagged form keeps
+    #                                WD2's presence-only, side-effect-free
+    #                                contract exactly (issue #148).
     #
-    # The pre-v0.3.0 verb spellings `rigor skill list` / `print <name>` / `path <name>` still work but emit a stderr
-    # deprecation notice; they are removed in v0.3.0 (see docs/ROADMAP.md § "Scheduled CLI deprecations"). `describe` is
-    # a no-argument action, not a name-slot verb, so it stays first-class alongside `--describe`.
+    # `describe` is a no-argument action, not a name-slot verb, so it stays first-class alongside `--describe`.
     class SkillCommand < Command
       USAGE = <<~USAGE
         Usage: rigor skill [<name>] [--full <name>] [--path <name>] [--list] [--describe]
@@ -53,6 +58,10 @@ module Rigor
           rigor skill --path <name>  Print the absolute path of the SKILL.md file for <name>
           rigor skill --list         List bundled skills (name + absolute path)
           rigor skill --describe     Report project state + recommend the next skill to run
+                                     (presence-only probe — never runs `rigor check`)
+          rigor skill describe --deep
+                                     Same, but run `rigor check` first and route the
+                                     recommendation on its result (slow; writes the cache)
 
         Examples:
           rigor skill
@@ -60,30 +69,15 @@ module Rigor
           rigor skill --full rigor-baseline-reduce
           rigor skill --path rigor-baseline-reduce
           rigor skill --describe        (also: rigor describe)
-
-        Deprecated (removed in v0.3.0) — use the forms above:
-          rigor skill list           ->  rigor skill --list
-          rigor skill print <name>   ->  rigor skill <name>
-          rigor skill path <name>    ->  rigor skill --path <name>
+          rigor skill describe --deep   (also: rigor describe --deep)
       USAGE
 
       # The bundled skills live at `<gem_root>/skills/`. From `lib/rigor/cli/skill_command.rb` that is three directories
       # up.
       SKILLS_ROOT = File.expand_path("../../../skills", __dir__)
 
-      # 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" },
-        "print" => { old: "print <name>", advice: "<name>", flag: "--print" },
-        "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_list
@@ -112,19 +106,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 skill: `#{spec.fetch(:old)}` is deprecated and will be removed in " \
-          "#{LEGACY_VERB_REMOVAL}; use `rigor skill #{spec.fetch(:advice)}` instead."
-        )
-        @argv[0] = spec.fetch(:flag)
-      end
-
       def run_list
         skills = discover_skills
         if skills.empty?
@@ -190,10 +171,18 @@ module Rigor
       # probes the current project's state with cheap presence checks (it never runs `rigor check`), recommends the next
       # skill to run, and prints every bundled skill's current frontmatter description, so the `rigor-next-steps` SKILL
       # can route without copying any version-coupled guidance into itself.
+      #
+      # `--deep` is the one opt-in that breaks the "never runs `rigor check`" guarantee — and only for the invocation
+      # that asks for it (issue #148 / ADR-73 § "Field-trial follow-ups"). It runs a real check and lets the result
+      # pick the headline; the un-flagged command is unchanged, down to loading no analysis code at all.
       def run_describe
+        deep = !@argv.delete("--deep").nil?
+        unknown = @argv.first
+        return usage_error("unknown option for `describe`: #{unknown}") unless unknown.nil?
+
         require_relative "skill_describe"
 
-        @out.puts(SkillDescribe.new(skills: discover_skills).render)
+        @out.puts(SkillDescribe.new(skills: discover_skills, deep: deep).render)
         0
       end
 

data/lib/rigor/cli/skill_deep_probe.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative "check_invocation"
+
+module Rigor
+  class CLI
+    # `rigor skill describe --deep` — the one part of `describe` that runs an analysis (issue #148; ADR-73
+    # § "Field-trial follow-ups", the "headline check-awareness" open decision, shape (b)).
+    #
+    # **The boundary is this file.** ADR-73 WD2 makes `describe` presence-only and side-effect-free, and that
+    # guardrail binds the *un-flagged* command exactly as before: {SkillDescribe} requires this file only when
+    # `--deep` was passed, so a default `rigor skill describe` never loads the inference engine, never opens a
+    # project source file, and writes nothing. `--deep` is the opt-in that trades that purity away: it runs a real
+    # `rigor check` over the configured paths using the configured cache and worker count, so it is as slow as
+    # `rigor check` on a cold cache and it WRITES `.rigor/cache` just like `rigor check` does.
+    #
+    # The routing vocabulary is deliberately the one `describe`'s "For the agent" section already teaches (errors →
+    # `rigor-baseline-reduce`, a proven monkey-patch cluster → `rigor-monkeypatch-resolve`, an empty RBS environment
+    # or a `configuration-error` → `rigor-doctor`). `--deep` makes the headline compute the call the agent would
+    # otherwise make from the same evidence; it does not introduce a second taxonomy.
+    class SkillDeepProbe
+      # Diagnostics the engine emits when the *setup* is broken rather than the code — the `rigor-doctor` signal.
+      CONFIGURATION_ERROR_RULE = "configuration-error"
+
+      # The share of a run's errors that must be proven monkey-patches before the headline routes to
+      # `rigor-monkeypatch-resolve` rather than `rigor-baseline-reduce`. The agent-prompt vocabulary this reuses says
+      # "a monkey-patch *cluster*", and a cluster is what makes the workflow the right one: `pre_eval:` clears those
+      # sites wholesale, so it is the shortest path only when clearing them materially changes the count. One proven
+      # site beside four hundred unrelated errors is a true finding pointing at the wrong workflow — the report says
+      # so in the reason line either way, so nothing is lost by leaving the headline on the bigger problem.
+      MONKEY_PATCH_CLUSTER_SHARE = Rational(1, 3)
+
+      # What the deep check concluded.
+      #
+      # - `status` — `:skipped` (no config to check), `:error` (the check could not run), `:analyzed` (it ran).
+      # - `detail` — the human line printed under "## Deep check"; on `:error` it says so outright, because a check
+      #   that could not run is NOT a clean check and the report must never let it read as one.
+      # - `route` / `reason` — the headline override, or nil to leave the presence-only recommendation standing.
+      Report = Data.define(:status, :detail, :route, :reason) do
+        # @return [Boolean] true when the check did not complete — the caller must then say so rather than let the
+        #   fallback recommendation read as an all-clear.
+        def failed?
+          status == :error
+        end
+      end
+
+      # @param config [String, nil] the config filename the presence probe found, relative to `root`.
+      # @param root [String] project root (the analysis itself resolves paths against the process cwd, as
+      #   `rigor check` does).
+      def initialize(config:, root: Dir.pwd)
+        @config = config
+        @root = root
+      end
+
+      # @return [Report] never raises — every failure degrades to a `:error`/`:skipped` report whose `route` is nil,
+      #   leaving the presence-only headline in charge.
+      def run
+        if @config.nil?
+          return Report.new(
+            status: :skipped, route: nil, reason: nil,
+            detail: "skipped — this project has no Rigor configuration, so there is nothing to check yet."
+          )
+        end
+
+        outcome = CheckInvocation.attempt(config_path: File.join(@root, @config))
+        return failed(outcome.error) unless outcome.ran?
+
+        classify(outcome.result)
+      end
+
+      private
+
+      # A check that could not run at all. Reported as a failure, not as a clean result, and with the raw error text
+      # so the user can act on it — the un-run check is itself a finding, but not one precise enough to route on.
+      def failed(error)
+        Report.new(
+          status: :error, route: nil, reason: nil,
+          detail: "the check could NOT run: #{error}. This is not a clean result — the recommendation below " \
+                  "falls back to the presence-only probe. Run `rigor check` (or `rigor doctor`) to see what failed."
+        )
+      end
+
+      def classify(result)
+        sites = monkey_patch_diagnostics(result)
+        if broken_environment?(result)
+          doctor_report(result)
+        elsif monkey_patch_cluster?(result, sites)
+          monkeypatch_report(result, sites)
+        elsif result.error_count.positive?
+          baseline_report(result, sites)
+        else
+          Report.new(
+            status: :analyzed, route: nil, reason: nil,
+            detail: "the check ran clean — 0 error diagnostics. The recommendation below is the presence-only one."
+          )
+        end
+      end
+
+      # The `rigor-doctor` signal, read exactly as `rigor doctor` itself reads it: an RBS environment that built to
+      # zero classes (analysis is hollow, so every other count is meaningless), or a `configuration-error` the run
+      # already emitted. Checked first — with a broken setup the remaining diagnostics are not evidence of anything.
+      def broken_environment?(result)
+        result.stats&.rbs_classes_total&.zero? ||
+          result.diagnostics.any? { |diagnostic| diagnostic.rule == CONFIGURATION_ERROR_RULE }
+      end
+
+      # ADR-17 / the `project-monkey-patch-known` triage recogniser: `call.undefined-method` sets
+      # `project_definition_site` when the project itself defines the called method on the receiver class somewhere
+      # in the analysed file set. That is engine-proven evidence, not a spread heuristic, which is why it routes with
+      # no count threshold — and why the *unproven* shapes (a bare `call.unresolved-toplevel` count, "framework calls
+      # typing as Dynamic") are deliberately not routed on here. Guessing a workflow from a weak signal is worse than
+      # leaving the generic recommendation standing.
+      def monkey_patch_diagnostics(result)
+        result.diagnostics.select(&:project_definition_site)
+      end
+
+      # Whether the proven sites dominate the run enough for `pre_eval:` to be the shortest path. Any proven site is
+      # real evidence — `project_definition_site` is engine-proven, not a spread heuristic — but evidence of a *site*
+      # is not evidence that clearing it is the next thing to do. Below the share, `baseline_report` still names the
+      # sites, so the finding survives even when the headline does not follow it.
+      def monkey_patch_cluster?(result, sites)
+        return false if sites.empty?
+        return true unless result.error_count.positive?
+
+        Rational(sites.size, result.error_count) >= MONKEY_PATCH_CLUSTER_SHARE
+      end
+
+      def doctor_report(result)
+        classes = result.stats&.rbs_classes_total
+        cause = if classes&.zero?
+                  "the RBS environment built to 0 classes"
+                else
+                  "the run emitted a `#{CONFIGURATION_ERROR_RULE}` diagnostic"
+                end
+        Report.new(
+          status: :analyzed, route: "rigor-doctor",
+          reason: "a `--deep` check found a broken setup (#{cause}) — the analysis is hollow until that is fixed, " \
+                  "so no other finding is trustworthy yet.",
+          detail: "the check found a broken setup — #{cause}."
+        )
+      end
+
+      def monkeypatch_report(result, sites)
+        files = sites.filter_map { |d| d.project_definition_site&.sub(/:\d+\z/, "") }.uniq.sort
+        Report.new(
+          status: :analyzed, route: "rigor-monkeypatch-resolve",
+          reason: "a `--deep` check found #{sites.size} call site(s) that resolve to the project's own definitions " \
+                  "in #{files.first(3).join(', ')} — reopened classes Rigor does not apply cross-file. Listing " \
+                  "them in `pre_eval:` clears them wholesale.",
+          detail: "the check reported #{result.error_count} error diagnostic(s), #{sites.size} of them proven " \
+                  "project monkey-patches (#{files.size} file(s))."
+        )
+      end
+
+      def baseline_report(result, sites = [])
+        aside = if sites.empty?
+                  ""
+                else
+                  " #{sites.size} of them are proven project monkey-patches — too small a share to make `pre_eval:` " \
+                    "the shortest path, but `rigor-monkeypatch-resolve` clears them if you want them gone first."
+                end
+        Report.new(
+          status: :analyzed, route: "rigor-baseline-reduce",
+          reason: "a `--deep` check reported #{result.error_count} error diagnostic(s) — work them down (or record " \
+                  "them in a baseline) before adding more surface.#{aside}",
+          detail: "the check reported #{result.error_count} error diagnostic(s), " \
+                  "#{sites.empty? ? 'none' : sites.size} of them proven project monkey-patches."
+        )
+      end
+    end
+  end
+end

data/lib/rigor/cli/skill_describe.rb

@@ -142,27 +142,43 @@ module Rigor
 
       # @param skills [Array<Hash>] discovered skills, each `{name:, path:}`.
       # @param root [String] project root to probe (defaults to the cwd).
-      def initialize(skills:, root: Dir.pwd)
+      # @param deep [Boolean] opt into `--deep`: run a real `rigor check` and let its result pick the headline. Off by
+      #   default, and off is ADR-73 WD2's contract — see {SkillDeepProbe} for why the whole analysis path lives
+      #   behind this one flag and in its own file.
+      def initialize(skills:, root: Dir.pwd, deep: false)
         @skills = skills
         @root = root
+        @deep = deep
       end
 
       # @return [String] the full describe report.
       def render
         catalog = catalog_skills
         state = ProjectStateProbe.new(@root).to_h
-        recommendation = recommend(state, catalog)
+        deep = deep_report(state)
+        recommendation = recommend(state, catalog, deep)
         [
           title,
           state_section(state),
+          deep_section(deep),
           recommendation_section(recommendation),
           catalog_section(catalog),
-          agent_prompt(recommendation)
-        ].join("\n")
+          agent_prompt(recommendation, deep)
+        ].compact.join("\n")
       end
 
       private
 
+      # The `--deep` analysis, or nil when the flag was not given. `require` sits here rather than at the top of the
+      # file so the default, presence-only path never even loads the check-invocation plumbing — WD2's "runs no
+      # analysis" guarantee is enforced by what gets loaded, not only by what gets called.
+      def deep_report(state)
+        return nil unless @deep
+
+        require_relative "skill_deep_probe"
+        SkillDeepProbe.new(config: state.fetch(:config), root: @root).run
+      end
+
       # The skills offered as "what to do next", in adoption-journey order. The entry-point skill is excluded, and
       # unknown skills sort after the known journey, alphabetically.
       def catalog_skills
@@ -173,8 +189,12 @@ module Rigor
 
       # The decision tree (ADR-73 WD2). Returns `{ skill:, reason: }` for the recommended next step, or nil when no
       # catalogue skill matches.
-      def recommend(state, catalog)
-        name, reason = recommended_name_and_reason(state)
+      #
+      # A `--deep` report overrides the presence-only tree only when it actually routed: a check that was skipped,
+      # could not run, or ran clean leaves the tree's answer standing untouched. So the un-flagged behaviour is
+      # literally the `deep == nil` branch of this one method.
+      def recommend(state, catalog, deep = nil)
+        name, reason = deep&.route ? [deep.route, deep.reason] : recommended_name_and_reason(state)
         skill = catalog.find { |candidate| candidate.fetch(:name) == name }
         skill.nil? ? nil : { skill: skill, reason: reason }
       end
@@ -248,6 +268,18 @@ module Rigor
         STATE
       end
 
+      # Printed only under `--deep`, so the un-flagged report is byte-identical to what it has always been.
+      def deep_section(deep)
+        return nil if deep.nil?
+
+        <<~DEEP
+          ## Deep check (--deep)
+          A real `rigor check` was run for this recommendation — unlike the probe above it
+          is slow and it writes `.rigor/cache`, exactly as `rigor check` does.
+          - Result: #{deep.detail}
+        DEEP
+      end
+
       def recommendation_section(recommendation)
         return "## Recommended next step\n- (no bundled skill matched the current state)\n" if recommendation.nil?
 
@@ -267,7 +299,7 @@ module Rigor
         "## All skills you can run next\n#{lines.join("\n")}\n"
       end
 
-      def agent_prompt(recommendation)
+      def agent_prompt(recommendation, deep = nil)
         opener =
           if recommendation.nil?
             "Ask the user what they would like to do next"
@@ -279,6 +311,33 @@ module Rigor
           #{opener}, then run `rigor skill <name>` for the chosen skill and
           follow its body top to bottom.
 
+          #{check_awareness(deep)}
+
+          Re-run `rigor skill describe` whenever you need the next step — it always
+          reflects the project's current state.
+        PROMPT
+      end
+
+      # The check-aware routing block. Without `--deep` it teaches the agent to make the call itself from a check it
+      # has already run (the 2026-06-20 field-trial fix, unchanged); with `--deep` the headline already made that
+      # call, so the block reports what happened instead of re-teaching it. The routing vocabulary is one taxonomy
+      # shared by both branches and by {SkillDeepProbe}.
+      def check_awareness(deep)
+        return presence_only_check_awareness if deep.nil?
+        return deep_failure_check_awareness if deep.failed?
+
+        <<~DEEP.chomp
+          The recommendation above already factors in the `--deep` check result, using the
+          same routing this command teaches without `--deep`: proven project monkey-patches
+          → rigor-monkeypatch-resolve; `RBS classes available: 0` or a `configuration-error`
+          → rigor-doctor; remaining error diagnostics → rigor-baseline-reduce. It does not
+          route on weaker signals (framework calls typing as Dynamic → rigor-plugin-tune is
+          still yours to judge from the check output).
+        DEEP
+      end
+
+      def presence_only_check_awareness
+        <<~PROMPT.chomp
           The recommendation above is from a presence-only probe — it does not run
           `rigor check`. If you have run (or now run) `rigor check`, let its findings
           refine the choice:
@@ -287,9 +346,16 @@ module Rigor
           - framework calls (ActiveRecord, routes, i18n …) typing as Dynamic with no
             matching plugins enabled → rigor-plugin-tune
           - `RBS classes available: 0` or a `configuration-error` diagnostic → rigor-doctor
+          (`rigor skill describe --deep` runs that check for you and applies this routing
+          to the headline itself — at the cost of a full analysis.)
+        PROMPT
+      end
 
-          Re-run `rigor skill describe` whenever you need the next step — it always
-          reflects the project's current state.
+      def deep_failure_check_awareness
+        <<~PROMPT.chomp
+          The `--deep` check did NOT complete, so the recommendation above is the
+          presence-only one. Do not treat the project as clean: run `rigor doctor`
+          (or `rigor check`) and fix what it reports before trusting any routing.
         PROMPT
       end
 

data/lib/rigor/cli/trace_command.rb

@@ -12,6 +12,7 @@ require_relative "../inference/flow_tracer"
 require_relative "../inference/scope_indexer"
 require_relative "command"
 require_relative "trace_renderer"
+require_relative "probe_environment"
 
 module Rigor
   class CLI
@@ -90,13 +91,11 @@ module Rigor
         0
       end
 
-      # Mirrors the single-file path `rigor type-of` takes: a project-aware environment, an empty seed scope, one
-      # statement-level evaluation of the whole program — but recorded under the FlowTracer.
+      # Mirrors the single-file path `rigor type-of` takes: the plugin-aware environment (so a trace replays the
+      # same dispatch `rigor check` would, including plugin-synthesized RBS — see {ProbeEnvironment}), an empty
+      # seed scope, one statement-level evaluation of the whole program — but recorded under the FlowTracer.
       def record_events(root, file, configuration)
-        environment = Environment.for_project(
-          libraries: configuration.libraries,
-          signature_paths: configuration.signature_paths
-        )
+        environment = ProbeEnvironment.build(configuration: configuration, source_files: [file])
         scope = Scope.empty(environment: environment, source_path: file)
         Inference::FlowTracer.record { scope.evaluate(root) }
       end

data/lib/rigor/cli/type_of_command.rb

@@ -13,6 +13,7 @@ require_relative "../inference/scope_indexer"
 require_relative "type_of_renderer"
 require_relative "command"
 require_relative "options"
+require_relative "probe_environment"
 
 module Rigor
   class CLI
@@ -92,14 +93,14 @@ module Rigor
         0
       end
 
-      # Builds a project-aware environment relative to the probed file. Project-RBS auto-detection roots at CWD today;
-      # future work will walk parent directories to find the enclosing `Gemfile`/`*.gemspec` so probes against files
-      # outside the current process's CWD still see the right `sig/` tree.
-      def project_environment(_file, configuration)
-        Environment.for_project(
-          libraries: configuration.libraries,
-          signature_paths: configuration.signature_paths
-        )
+      # Builds the plugin-aware environment relative to the probed file, so the reported type matches what `rigor
+      # check` computes for the same position — including types synthesized from inline RBS annotations by the
+      # ADR-93 auto-wired `rigor-rbs-inline` plugin (see {ProbeEnvironment} for the #162 misattribution this
+      # closes). The probed file is threaded as the synthesizer's `source_files:`. Project-RBS auto-detection
+      # roots at CWD today; future work will walk parent directories to find the enclosing `Gemfile`/`*.gemspec`
+      # so probes against files outside the current process's CWD still see the right `sig/` tree.
+      def project_environment(file, configuration)
+        ProbeEnvironment.build(configuration: configuration, source_files: [file])
       end
 
       def file_exists?(file)

data/lib/rigor/cli/type_scan_command.rb

@@ -11,6 +11,7 @@ require_relative "../scope"
 require_relative "type_scan_renderer"
 require_relative "type_scan_report"
 require_relative "command"
+require_relative "probe_environment"
 
 module Rigor
   class CLI
@@ -69,20 +70,19 @@ module Rigor
 
       def scan_paths(paths, options)
         configuration = Configuration.load(options.fetch(:config))
-        scope = Scope.empty(environment: project_environment(configuration))
+        scope = Scope.empty(environment: project_environment(configuration, paths))
         scanner = Inference::CoverageScanner.new(scope: scope)
         accumulator = ScanAccumulator.new
         paths.each { |path| scan_one(path, scanner, accumulator, configuration) }
         accumulator.to_report(paths, options)
       end
 
-      # Builds a project-aware environment that auto-detects `<cwd>/sig` by default and honours the configuration's
-      # `libraries:` / `signature_paths:` keys when present.
-      def project_environment(configuration)
-        Environment.for_project(
-          libraries: configuration.libraries,
-          signature_paths: configuration.signature_paths
-        )
+      # Builds the plugin-aware environment that auto-detects `<cwd>/sig` by default and honours the
+      # configuration's `libraries:` / `signature_paths:` keys when present. The scanned `paths` are threaded as
+      # the plugin `source_rbs_synthesizer` inputs so coverage reflects the same synthesized RBS `rigor check`
+      # sees (see {ProbeEnvironment}).
+      def project_environment(configuration, source_files)
+        ProbeEnvironment.build(configuration: configuration, source_files: source_files)
       end
 
       def scan_one(path, scanner, accumulator, configuration)

data/lib/rigor/cli.rb

@@ -11,7 +11,7 @@ require_relative "analysis/diagnostic"
 require_relative "analysis/result"
 require_relative "cli/options"
 require_relative "cli/diagnostic_formats"
-require_relative "cli/ci_detector"
+require_relative "ci_detector"
 
 module Rigor
   # The CLI class is a dispatcher: each `run_*` method delegates to a command-specific class once the command grows
@@ -20,6 +20,16 @@ module Rigor
   class CLI # rubocop:disable Metrics/ClassLength
     EXIT_USAGE = 64
 
+    # The published location of `schemas/rigor-config.schema.json`, written into the `.rigor.yml` that
+    # `rigor init` generates so an editor validates the file as the user types.
+    #
+    # This MUST equal the schema's own `$id`, and it MUST resolve. Both are gated
+    # (`spec/rigor/config_schema_spec.rb`) because neither failure has a symptom: an unreachable schema
+    # is indistinguishable from a schema with no complaints, so a stale URL here silently disables
+    # validation for every project that ran `rigor init`. It pointed at a nonexistent org until
+    # 2026-07-17 and nothing noticed. See `docs/internal-spec/config.md`.
+    CONFIG_SCHEMA_URL = "https://github.com/rigortype/rigor/raw/master/schemas/rigor-config.schema.json"
+
     HANDLERS = {
       "check" => :run_check,
       "init" => :run_init,
@@ -138,9 +148,10 @@ module Rigor
     # most likely to want to edit.
     def init_template
       <<~YAML
-        # yaml-language-server: $schema=https://github.com/zenwerk/rigor/raw/master/schemas/rigor-config.schema.json
-        # Rigor configuration. See docs/CURRENT_WORK.md for the
-        # full set of features the analyzer ships in this preview.
+        # yaml-language-server: $schema=#{CONFIG_SCHEMA_URL}
+        # Rigor configuration. The full key reference is
+        # https://github.com/rigortype/rigor/blob/master/docs/manual/03-configuration.md
+        # (or run `rigor docs configuration`).
         #
         # Keys you may want to edit:
         # - target_ruby: minimum Ruby version your project targets.