rigortype 0.3.5 → 0.3.7

data/lib/rigor/cli/type_of_command.rb

@@ -10,6 +10,8 @@ require_relative "../scope"
 require_relative "../source/node_locator"
 require_relative "../inference/fallback_tracer"
 require_relative "../inference/scope_indexer"
+require_relative "../inference/precision_scanner"
+require_relative "../source/node_children"
 require_relative "type_of_renderer"
 require_relative "command"
 require_relative "options"
@@ -26,9 +28,23 @@ module Rigor
     # type-of UX (extra flags, watch mode, streaming output) without bloating the CLI shell. Output formatting is
     # delegated to {TypeOfRenderer}.
     class TypeOfCommand < Command
-      USAGE = "Usage: rigor type-of [options] FILE:LINE:COL"
+      USAGE = "Usage: rigor type-of [options] FILE:LINE[:COL] [FILE:LINE[:COL] ...]"
 
-      Result = Data.define(:file, :line, :column, :node, :type, :tracer)
+      Result = Data.define(:file, :line, :column, :node, :type, :tracer, :enumeration) do
+        def initialize(enumeration: nil, **rest)
+          super
+        end
+      end
+
+      LineEnumeration = Data.define(:total, :shown)
+
+      # One requested position. A nil `column` means "the first 40 expressions starting on this line" — the form that
+      # exists because hand-computing a column is the single most error-prone part of using this command.
+      Target = Data.define(:file, :line, :column)
+
+      # Cap on the expressions one bare `FILE:LINE` prints, so a long line cannot bury the answer.
+      LINE_ENUMERATION_CAP = 40
+      private_constant :LINE_ENUMERATION_CAP
 
       # @return [Integer] CLI exit status.
       def run
@@ -36,10 +52,10 @@ module Rigor
         buffer = Options.resolve_buffer_binding(options, err: @err)
         return CLI::EXIT_USAGE if buffer == :usage_error
 
-        target = parse_position_argument(@argv)
-        return CLI::EXIT_USAGE if target.nil?
+        targets = parse_position_arguments(@argv)
+        return CLI::EXIT_USAGE if targets.nil?
 
-        execute(target: target, options: options, buffer: buffer)
+        execute(targets: targets, options: options, buffer: buffer)
       end
 
       private
@@ -59,38 +75,123 @@ module Rigor
         options
       end
 
-      def execute(target:, options:, buffer: nil)
-        file, line, column = target
-        # Under editor mode the logical `file` may not exist on disk (user editing a new file); the runtime check is
-        # only that the BUFFER is readable, which `resolve_buffer_binding` has already enforced. For non-editor mode
-        # `file` must exist.
+      # One process, N positions. Every invocation used to rebuild the plugin-aware environment and reparse the
+      # file for a single answer, so investigating a chain of expressions cost one process each — the dominant
+      # cost of using this command in anger. The environment is now built once for the whole request and each
+      # file is parsed and scope-indexed once, however many positions land in it.
+      def execute(targets:, options:, buffer: nil)
+        configuration = Configuration.load(options.fetch(:config))
+        environment = project_environment(targets.map(&:file).uniq, configuration)
+        base_scope = Scope.empty(environment: environment)
+
+        results_by_target = Array.new(targets.length)
+        targets.each_with_index.group_by { |target, _index| target.file }.each do |file, indexed_targets|
+          file_results = resolve_file(file, indexed_targets, configuration, base_scope, options, buffer)
+          return file_results if file_results.is_a?(Integer)
+
+          file_results.each { |index, resolved| results_by_target[index] = resolved }
+        end
+        results = results_by_target.compact.flatten(1)
+        return 1 if results.empty?
+
+        TypeOfRenderer.new(out: @out).render(results, format: options.fetch(:format))
+        0
+      end
+
+      # Every result for one file: parsed and indexed once, then each requested position resolved against that
+      # index. Returns an Integer exit status instead when the file itself cannot be probed.
+      def resolve_file(file, indexed_targets, configuration, base_scope, options, buffer)
+        # Under editor mode the logical `file` may not exist on disk (user editing a new file); the runtime check
+        # is only that the BUFFER is readable, which `resolve_buffer_binding` has already enforced.
         physical = buffer ? buffer.resolve(file) : file
         return 1 unless file_exists?(buffer ? physical : file)
 
-        configuration = Configuration.load(options.fetch(:config))
         source = File.read(physical)
         parse_result = Prism.parse(source, filepath: file, version: configuration.target_ruby)
         return 1 if parse_errors?(parse_result, file)
 
-        node = locate_node(source: source, root: parse_result.value, file: file, line: line, column: column)
-        return CLI::EXIT_USAGE if node == :out_of_range
-        return 1 if node.nil?
+        # Built with no tracer attached — it would otherwise double-record fallback events with the per-node
+        # `type_of` calls below.
+        scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
+        locator = Source::NodeLocator.new(source: source, root: parse_result.value)
+        lines = indexed_targets.filter_map { |target, _index| target.line if target.column.nil? }
+        line_nodes, line_totals = collect_line_nodes(parse_result.value, lines)
 
-        tracer = options[:trace] ? Inference::FallbackTracer.new : nil
-        base_scope = Scope.empty(environment: project_environment(file, configuration))
+        resolve_targets(file: file, indexed_targets: indexed_targets, locator: locator, line_nodes: line_nodes,
+                        line_totals: line_totals, scope_index: scope_index, options: options)
+      end
 
-        # Build a per-node scope index so locals bound earlier in the file flow into the scope used to type the queried
-        # node. We build the index with no tracer attached (it would otherwise double-record fallback events with the
-        # second-pass type_of call below), then look up the scope visible at the queried node and run the actual probe
-        # under it.
-        scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
-        node_scope = scope_index[node]
+      def resolve_targets(file:, indexed_targets:, locator:, line_nodes:, line_totals:, scope_index:, options:)
+        indexed_targets.map do |target, index|
+          if target.column.nil?
+            resolved = enumerate_line(file, target.line, line_nodes.fetch(target.line),
+                                      line_totals.fetch(target.line), scope_index, options)
+            next [index, resolved]
+          end
 
-        type = node_scope.type_of(node, tracer: tracer)
-        result = Result.new(file: file, line: line, column: column, node: node, type: type, tracer: tracer)
+          node = locate_node(locator: locator, file: file, line: target.line, column: target.column)
+          return CLI::EXIT_USAGE if node == :out_of_range
+          next [index, []] if node.nil?
 
-        TypeOfRenderer.new(out: @out).render(result, format: options.fetch(:format))
-        0
+          [index, [type_result(file, target.line, target.column, node, scope_index, options)]]
+        end
+      end
+
+      # Collect every requested line in one full syntax walk. Unlike `Source::NodeWalker`, this deliberately
+      # descends into `defined?`: the probe inventories source expressions, including operands Ruby inspects but
+      # does not evaluate. Candidate storage stays bounded while retaining the first 40 nodes in display order.
+      def collect_line_nodes(root, lines)
+        return [{}, {}] if lines.empty?
+
+        candidates = lines.uniq.to_h { |line| [line, []] }
+        totals = candidates.to_h { |line, _nodes| [line, 0] }
+        walk_syntax(root) do |node|
+          line = node.location.start_line
+          nodes = candidates[line]
+          next if nodes.nil?
+          next if Inference::PrecisionScanner::NON_EXPRESSION_NODE_TYPES.include?(node.class.name)
+
+          totals[line] += 1
+          nodes << node
+          trim_line_nodes(nodes) if nodes.length > LINE_ENUMERATION_CAP * 2
+        end
+        candidates.each_value { |nodes| trim_line_nodes(nodes) }
+        [candidates, totals]
+      end
+
+      def walk_syntax(node, &block)
+        return unless node.is_a?(Prism::Node)
+
+        block.call(node)
+        node.rigor_each_child { |child| walk_syntax(child, &block) }
+      end
+
+      def trim_line_nodes(nodes)
+        nodes.sort_by! { |node| [node.location.start_column, -node.location.length] }
+        nodes.slice!(LINE_ENUMERATION_CAP, nodes.length)
+      end
+
+      # Up to 40 expressions STARTING on `line`, outermost first at each 1-based column. This form removes
+      # the column arithmetic: `rigor type-of file.rb:42` answers "what are the types on line 42" without the user
+      # having to guess which byte the receiver starts at.
+      def enumerate_line(file, line, nodes, total, scope_index, options)
+        if nodes.empty?
+          @err.puts("type-of: no expression found on #{file}:#{line}")
+          return []
+        end
+
+        enumeration = LineEnumeration.new(total: total, shown: nodes.length)
+        nodes.map do |node|
+          type_result(file, line, node.location.start_column + 1, node, scope_index, options,
+                      enumeration: enumeration)
+        end
+      end
+
+      def type_result(file, line, column, node, scope_index, options, enumeration: nil)
+        tracer = options[:trace] ? Inference::FallbackTracer.new : nil
+        type = scope_index[node].type_of(node, tracer: tracer)
+        Result.new(file: file, line: line, column: column, node: node, type: type, tracer: tracer,
+                   enumeration: enumeration)
       end
 
       # Builds the plugin-aware environment relative to the probed file, so the reported type matches what `rigor
@@ -99,8 +200,8 @@ module Rigor
       # 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])
+      def project_environment(files, configuration)
+        ProbeEnvironment.build(configuration: configuration, source_files: files)
       end
 
       def file_exists?(file)
@@ -117,8 +218,8 @@ module Rigor
         true
       end
 
-      def locate_node(source:, root:, file:, line:, column:)
-        node = Source::NodeLocator.at_position(source: source, root: root, line: line, column: column)
+      def locate_node(locator:, file:, line:, column:)
+        node = locator.at_position(line: line, column: column)
         @err.puts("type-of: no expression found at #{file}:#{line}:#{column}") if node.nil?
         node
       rescue Source::NodeLocator::OutOfRangeError => e
@@ -126,19 +227,66 @@ module Rigor
         :out_of_range
       end
 
-      def parse_position_argument(argv)
-        case argv.size
-        when 1
-          parse_colon_form(argv[0])
-        when 3
-          decode_position(*argv)
-        else
-          @err.puts("type-of: expected FILE:LINE:COL or FILE LINE COL")
+      def parse_position_arguments(argv)
+        if argv.empty?
+          @err.puts("type-of: expected FILE:LINE[:COL] or FILE LINE COL")
           @err.puts(USAGE)
-          nil
+          return nil
         end
+
+        colon = argv.map { |arg| try_colon_form(arg) }
+        return colon if colon.all?
+        return legacy_triple(argv) if argv.size == 3 && colon.none?
+        # A single unparseable argument keeps its old, specific diagnosis ("must be integers", "expected
+        # FILE:LINE:COL") rather than the generic multi-position complaint below.
+        return single_colon_form(argv[0]) if argv.size == 1
+
+        @err.puts("type-of: expected FILE:LINE[:COL] (repeatable) or FILE LINE COL, got #{argv.inspect}")
+        @err.puts(USAGE)
+        nil
+      end
+
+      # `FILE:LINE:COL` or `FILE:LINE`, or nil when the argument is not in either form. Silent: the caller
+      # decides whether a nil means "try the three-argument form" or "report a usage error", and a probe should
+      # not print a complaint about a shape it is about to accept under a different reading.
+      def try_colon_form(arg)
+        parts = arg.split(":")
+        return nil if parts.size < 2 || !integer_literal?(parts[-1])
+
+        # Three or more segments is the `FILE:LINE:COL` reading; if its LINE is not a number the argument is a
+        # typo, not a column-less position, and must reach the specific "must be integers" diagnosis.
+        if parts.size >= 3
+          return nil unless integer_literal?(parts[-2])
+
+          Target.new(file: parts[0..-3].join(":"), line: Integer(parts[-2], 10), column: Integer(parts[-1], 10))
+        else
+          Target.new(file: parts[0], line: Integer(parts[-1], 10), column: nil)
+        end
+      end
+
+      def integer_literal?(value)
+        value.match?(/\A\d+\z/)
+      end
+
+      # The pre-batch single-argument path, kept for its error messages. Returns nil after printing one.
+      def single_colon_form(arg)
+        position = parse_colon_form(arg)
+        return nil if position.nil?
+
+        file, line, column = position
+        [Target.new(file: file, line: line, column: column)]
+      end
+
+      def legacy_triple(argv)
+        position = decode_position(*argv)
+        return nil if position.nil?
+
+        file, line, column = position
+        [Target.new(file: file, line: line, column: column)]
       end
 
+      # The strict `FILE:LINE:COL` reading, used only to produce the specific error for a single unparseable
+      # argument. The permissive reading (which also accepts `FILE:LINE`) is {try_colon_form}.
       def parse_colon_form(arg)
         parts = arg.split(":")
         if parts.size < 3
@@ -149,8 +297,7 @@ module Rigor
 
         column = parts.pop
         line = parts.pop
-        file = parts.join(":")
-        decode_position(file, line, column)
+        decode_position(parts.join(":"), line, column)
       end
 
       def decode_position(file, line, column)

data/lib/rigor/cli/type_of_renderer.rb

@@ -20,7 +20,55 @@ module Rigor
 
       private
 
-      def render_text(result)
+      # Takes the whole result list: one invocation can now answer several positions, and a bare `FILE:LINE`
+      # answers up to 40 expressions on that line. A single exact result renders byte-identically to before.
+      def render_text(results)
+        list = Array(results)
+        index = 0
+        first = true
+        while index < list.length
+          @out.puts("") unless first
+          result = list[index]
+          enumeration = result.enumeration
+          if enumeration
+            finish = index + 1
+            finish += 1 while finish < list.length && list[finish].enumeration.equal?(enumeration)
+            render_enumeration(list[index...finish], enumeration)
+            index = finish
+          else
+            render_one_text(result)
+            index += 1
+          end
+          first = false
+        end
+      end
+
+      # A bare `FILE:LINE` asks "what are the types on this line", and the answer is a table: one row per
+      # expression, outermost first at each column, so a method chain reads top to bottom.
+      def render_enumeration(results, enumeration)
+        @out.puts("#{results.first.file}:#{results.first.line}")
+        render_enumeration_rows(results)
+        if enumeration.total > results.length
+          omitted = enumeration.total - results.length
+          @out.puts("  ... #{omitted} additional expressions omitted (limit #{results.length})")
+        end
+        # After the table, never interleaved with it: a `--trace` fallback list between two rows would break the
+        # column alignment the whole form exists for.
+        results.each { |result| render_text_fallbacks(result) }
+      end
+
+      def render_enumeration_rows(results)
+        width = results.map { |result| node_label(result).length }.max
+        results.each do |result|
+          @out.puts(format("  %4d  %-#{width}s  %s", result.column, node_label(result), result.type.describe))
+        end
+      end
+
+      def node_label(result)
+        result.node.class.name.to_s.delete_prefix("Prism::")
+      end
+
+      def render_one_text(result)
         @out.puts("#{result.file}:#{result.line}:#{result.column}")
         @out.puts("node:    #{result.node.class}")
         @out.puts("type:    #{result.type.describe}")
@@ -40,7 +88,28 @@ module Rigor
         end
       end
 
-      def render_json(result)
+      # A single result keeps the flat object it has always emitted, so existing consumers are untouched; a
+      # multi-position request wraps them in `results` rather than printing several documents to one stream.
+      def render_json(results)
+        list = Array(results)
+        payload = list.size == 1 ? result_to_h(list.first) : { results: list.map { |r| result_to_h(r) } }
+        enumerations = line_enumerations(list)
+        payload[:line_enumerations] = enumerations unless enumerations.empty?
+        @out.puts(JSON.pretty_generate(payload))
+      end
+
+      def line_enumerations(results)
+        seen = {}.compare_by_identity
+        results.filter_map do |result|
+          enumeration = result.enumeration
+          next if enumeration.nil? || seen.key?(enumeration)
+
+          seen[enumeration] = true
+          { file: result.file, line: result.line, shown: enumeration.shown, total: enumeration.total }
+        end
+      end
+
+      def result_to_h(result)
         payload = {
           file: result.file,
           line: result.line,
@@ -50,7 +119,7 @@ module Rigor
           erased: result.type.erase_to_rbs
         }
         payload[:fallbacks] = result.tracer.map { |event| fallback_to_h(event) } if result.tracer
-        @out.puts(JSON.pretty_generate(payload))
+        payload
       end
 
       def format_fallback_text(event, file)

data/lib/rigor/cli/type_scan_command.rb

@@ -12,6 +12,7 @@ require_relative "type_scan_renderer"
 require_relative "type_scan_report"
 require_relative "command"
 require_relative "probe_environment"
+require_relative "coverage_scan"
 
 module Rigor
   class CLI
@@ -70,7 +71,15 @@ module Rigor
 
       def scan_paths(paths, options)
         configuration = Configuration.load(options.fetch(:config))
-        scope = Scope.empty(environment: project_environment(configuration, paths))
+        # Same seed set as `rigor coverage` and `coverage --protection` (#502). Without it a cross-file class
+        # constant reads `Dynamic` and is counted as an unrecognised node, so the scan reports the engine as
+        # blinder than it is — on Mastodon that alone was most of a 14.7% unrecognised rate.
+        scope = CoverageScan.discovery_seeded_scope(
+          files: paths,
+          configuration: configuration,
+          environment: project_environment(configuration, paths),
+          parameter_inference: configuration.parameter_inference
+        )
         scanner = Inference::CoverageScanner.new(scope: scope)
         accumulator = ScanAccumulator.new
         paths.each { |path| scan_one(path, scanner, accumulator, configuration) }

data/lib/rigor/cli/unused_command.rb

@@ -6,10 +6,12 @@ require "json"
 require_relative "../configuration"
 require_relative "../analysis/path_expansion"
 require_relative "../analysis/reachability/scan"
+require_relative "../analysis/reachability/scan_cache"
 require_relative "../analysis/reachability/graph"
 require_relative "../analysis/reachability/plugin_roots"
 require_relative "../analysis/reachability/signature_scan"
 require_relative "../analysis/reachability/project_files"
+require_relative "../cache/store"
 require_relative "options"
 require_relative "command"
 require_relative "probe_environment"
@@ -22,7 +24,11 @@ module Rigor
     # measured precision of this signal is 7.0% on an adjudicated corpus target
     # (`docs/notes/20260813-unused-constant-fp-baseline.md`), so its output is a review queue, not a defect
     # list, and it never enters `rigor check`'s stream at any severity (WD1). Exits 0 whatever it finds.
-    class UnusedCommand < Command
+    #
+    # Like {CheckCommand}, it aggregates one command's concerns — the two scans, the graph, and both
+    # render formats — that read clearer together than split across micro-classes, so it carries the
+    # same ClassLength exemption.
+    class UnusedCommand < Command # rubocop:disable Metrics/ClassLength
       USAGE = "Usage: rigor unused [options] [paths]"
 
       # WD7 — the REFERENCE corpus is wider than the ANALYSIS corpus. `.rake` files sit inside `paths:` and
@@ -43,23 +49,32 @@ module Rigor
 
         configuration = Configuration.load(options.fetch(:config))
         paths = @argv.empty? ? configuration.paths : @argv
-        declarations, references, dynamic_uses = scan(paths, configuration)
+        scan_cache = Analysis::Reachability::ScanCache.open(configuration.cache_path,
+                                                            target_ruby: configuration.target_ruby)
+        declarations, references, dynamic_uses = scan(paths, configuration, scan_cache)
         references.concat(signature_references(configuration))
-        dynamic_uses.concat(template_mentions(declarations))
+        dynamic_uses.concat(template_mentions(declarations, scan_cache))
 
-        contribution = Analysis::Reachability::PluginRoots.collect(configuration: configuration)
+        contribution = Analysis::Reachability::PluginRoots.collect(configuration: configuration,
+                                                                   cache_store: cache_store(configuration))
         references.concat(plugin_references(contribution.references))
-        graph = Analysis::Reachability::Graph.new(
-          declarations: declarations, references: references, dynamic_uses: dynamic_uses,
-          root_fqns: root_fqns(declarations, options.fetch(:entry_points)) + contribution.roots,
-          foreign: foreign_predicate(configuration)
-        )
+        graph = build_graph(configuration, options, contribution,
+                            declarations: declarations, references: references, dynamic_uses: dynamic_uses)
         emit(graph.report, options, supply: root_supply(contribution.roots, declarations))
+        scan_cache.save
         0
       end
 
       private
 
+      def build_graph(configuration, options, contribution, declarations:, references:, dynamic_uses:)
+        Analysis::Reachability::Graph.new(
+          declarations: declarations, references: references, dynamic_uses: dynamic_uses,
+          root_fqns: root_fqns(declarations, options.fetch(:entry_points)) + contribution.roots,
+          foreign: foreign_predicate(configuration)
+        )
+      end
+
       def parse_options
         options = { config: nil, format: "text", entry_points: [], limit: nil }
         parser = OptionParser.new do |opts|
@@ -91,13 +106,15 @@ module Rigor
       end
 
       # Declarations come from the analysed paths; references additionally from the wider corpus (WD7).
-      def scan(paths, configuration)
+      # Every file is consulted every run — an unchanged one contributes its cached scan, so the
+      # whole-project completeness the `--incremental` refusal protects is unaffected.
+      def scan(paths, configuration, cache)
         declaration_files = Analysis::PathExpansion.ruby_files(paths, configuration.exclude_patterns).to_set
         declarations = []
         references = []
         dynamic_uses = []
         (declaration_files + reference_files(paths, configuration)).sort.each do |file|
-          result = read_and_scan(file, configuration)
+          result = cache.serve(:scan, file) { read_and_scan(file, configuration) }
           next if result.nil?
 
           declarations.concat(result.declarations) if declaration_files.include?(file)
@@ -155,24 +172,38 @@ module Rigor
         end
       end
 
-      def template_mentions(declarations)
+      def template_mentions(declarations, cache)
         names = declarations.map(&:fqn)
         return [] if names.empty?
 
         Analysis::Reachability::ProjectFiles.own(Dir.glob(TEMPLATE_GLOB, base: Dir.pwd), Dir.pwd).flat_map do |rel|
-          text = File.read(File.expand_path(rel)).scrub
+          absolute = File.expand_path(rel)
+          haystack = cache.serve(:runs, absolute) { constant_bearing_text(File.read(absolute).scrub) }
           names.filter_map do |fqn|
-            next unless text.include?(fqn)
+            next unless haystack.include?(fqn)
 
             Analysis::Reachability::Scan::DynamicUse.new(name: nil, prefix: fqn, site: nil,
                                                          reason: "named as a string in #{rel}",
-                                                         path: rel, line: 1)
+                                                         path: rel, line: 1, scope: :exact)
           end
         rescue SystemCallError, ArgumentError
           []
         end
       end
 
+      # A maximal run of constant-path characters carrying at least one capital — the only substrings a
+      # declaration FQN can occur inside, since an FQN starts with a capital and uses this charset alone.
+      # An occurrence cannot cross a non-charset character, so `include?` over the de-duplicated runs
+      # (joined by a character outside the charset) answers exactly what `include?` over the whole text
+      # did, on a fraction of the bytes: a locale YAML or fixture JSON is almost entirely lowercase prose,
+      # and scanning 21 MB of it per declaration name was 81% of this command's wall time on mastodon.
+      CONSTANT_BEARING_RUN = /[A-Za-z0-9_:]*[A-Z][A-Za-z0-9_:]*/
+      private_constant :CONSTANT_BEARING_RUN
+
+      def constant_bearing_text(text)
+        text.scan(CONSTANT_BEARING_RUN).uniq.join("\n")
+      end
+
       def root_fqns(declarations, globs)
         return [] if globs.empty?
 
@@ -188,13 +219,31 @@ module Rigor
       # declaration, which produced three of redmine's artifacts from a single initializer. A name the bundled
       # (non-project) environment already knows is not ours to call unused. The project's own `sig/` is
       # deliberately excluded from this environment, so a project class that ships a signature stays owned.
+      #
+      # The cache store makes the environment a Marshal restore instead of a cold RBS build on every
+      # invocation — the same ADR-54 slot `rigor check` reads, keyed apart by this environment's own
+      # (sig-less) descriptor. The report only ever asks "is this name known", which the cached
+      # environment answers identically: the one thing the cache degrades is `RBS::Location`, and no
+      # location is read here.
       def foreign_predicate(configuration)
-        env = Environment.for_project(libraries: configuration.libraries, signature_paths: [])
+        env = Environment.for_project(libraries: configuration.libraries, signature_paths: [],
+                                      cache_store: cache_store(configuration))
         ->(fqn) { !env.singleton_for_name(fqn).nil? }
       rescue StandardError
         ->(_fqn) { false }
       end
 
+      # One store per run, shared by the environment build and the plugin-roots collection. Nil when the
+      # store cannot be opened — both consumers already treat a nil store as "recompute", which was this
+      # command's only mode before it had a cache at all.
+      def cache_store(configuration)
+        return @cache_store if defined?(@cache_store)
+
+        @cache_store = Cache::Store.new(root: configuration.cache_path)
+      rescue StandardError
+        @cache_store = nil
+      end
+
       # ADR-102 § Consequences — "a root source that OVER-supplies silently hides real dead code, which is
       # worse than one that under-supplies, so each plugin's contribution needs its own corpus check". A
       # supplied root naming a constant the project does not declare is inert in the graph, but it is the

data/lib/rigor/cli.rb

@@ -101,13 +101,26 @@ module Rigor
 
     def dispatch(command)
       handler = HANDLERS[command]
-      return send(handler) if handler
+      return arm_jit_deadline { send(handler) } if handler
 
       @err.puts("Unknown command: #{command}")
       @err.puts(help)
       EXIT_USAGE
     end
 
+    # Deferred YJIT for EVERY dispatched command, not just `check` / `coverage` where PR #75 first
+    # calibrated it. The deadline makes the decision command-independent: a run that finishes inside
+    # the window never pays JIT compile, and a run that outlasts it JITs its dominant tail — measured
+    # on `rigor effects` cold over Mastodon, which ran its whole 21 s interpreted while the same
+    # analysis under `check` took 14.8 s (forcing YJIT on the effects run: 15.9 s; disabling it on
+    # check: 21.1 s). `lsp` / `mcp` still call `Runtime::Jit.enable_now` at boot, which makes the
+    # deadline thread armed here a no-op when it later fires.
+    def arm_jit_deadline
+      require_relative "runtime/jit"
+      Runtime::Jit.enable_after(Runtime::Jit.deadline_seconds)
+      yield
+    end
+
     def run_check
       require_relative "cli/check_command"
 
@@ -363,17 +376,17 @@ module Rigor
           check      Analyze Ruby source files
           init       Create a starter .rigor.yml
           annotate   Print FILE with each line's last-expression type
-          type-of    Print the inferred type at FILE:LINE:COL
+          type-of    Print inferred types at FILE:LINE[:COL] positions
           trace      Replay how the engine typed FILE as a terminal animation
           type-scan  Report Scope#type_of coverage across PATHs
           effects    Report each method's effect labels, and the committed effect snapshot
-                     (ADR-103, opt-in; effects update/check/diff/explain)
+                     (opt-in; effects update/check/diff/explain)
           explain    Print the description of one or all CheckRules
           diff       Compare current diagnostics to a saved baseline JSON
-          sig-gen    Emit RBS skeletons inferred from .rb sources (ADR-14)
+          sig-gen    Emit RBS skeletons inferred from .rb sources
           lsp        Run the Rigor Language Server (LSP) over stdio
-          mcp        Run the Rigor MCP server over stdio (ADR-33)
-          triage     Summarise diagnostics: distribution, hotspots, hints (ADR-23)
+          mcp        Run the Rigor MCP server over stdio
+          triage     Summarise diagnostics: distribution, hotspots, hints
           coverage   Report type-precision coverage (precise vs Dynamic ratio)
           plugins    Report activation status of every configured plugin
           plugin     Browse bundled plugin source as worked examples (list/path/print/root)
@@ -381,9 +394,9 @@ module Rigor
           describe   Recommend the next skill for this project (alias for `skill describe`)
           skill      Recommend the next skill + list/print bundled Agent Skills (skill describe, skill <name>)
           docs       Print the bundled docs offline (docs <name>, docs --list)
-          show-bleedingedge  Show the bleeding-edge overlay + what your config adopts (ADR-50)
-          doctor     Classify setup problems vs clean run with routed next actions (ADR-77)
-          upgrade    Migration command skeleton (ADR-50 WD7, queued)
+          show-bleedingedge  Show the bleeding-edge overlay + what your config adopts
+          doctor     Classify setup problems vs clean run with routed next actions
+          upgrade    Migration command skeleton (queued)
           version    Print the Rigor version
           help       Print this help
       HELP