rigortype 0.3.4 → 0.3.6

data/lib/rigor/cli/effects_report.rb

@@ -7,7 +7,12 @@ module Rigor
     #
     # Rows are sorted by key and every collection inside one is sorted, so two runs over the same tree
     # print byte-identical output whether analysis ran sequentially or across the fork pool.
-    class EffectsReport < Data.define(:rows, :full)
+    class EffectsReport < Data.define(:rows, :full, :totals)
+      # `totals:` defaults so a caller that builds a report by hand keeps working.
+      def initialize(totals: nil, **rest)
+        super
+      end
+
       # One method's line in the report.
       #
       # `effects` is the transitive proven lane — this method's labels joined with every project method it
@@ -20,18 +25,116 @@ module Rigor
       # is printed apart from `effects` and never folded into it, because the two answer different
       # questions: one is proven, the other is asserted. A declared label the proven lane already admits
       # is dropped here, where output is rendered; the table keeps both lanes raw.
-      class Row < Data.define(:key, :effects, :declared, :exhaustive, :causes, :direct)
+      class Row < Data.define(:key, :effects, :declared, :exhaustive, :causes, :direct, :attribution)
+        # `attribution:` defaults so a caller that builds a row by hand keeps working.
+        def initialize(attribution: {}, **rest)
+          super
+        end
+
         def exhaustive?
           exhaustive
         end
+
+        # The reading `--pure` selects and the default report omits: nothing proven beyond what every
+        # envelope tolerates, nothing claimed, and no "possibly more".
+        def pure?
+          exhaustive && declared.empty? && (effects - TRIVIAL).empty?
+        end
+
+        # `mutate.local` is mutation of objects the frame allocated and never let out, which every
+        # envelope tolerates — so a method proving only it is what `%a{pure}` means here.
+        TRIVIAL = ["mutate.local"].freeze
+        private_constant :TRIVIAL
+
+        def carries_label?(labels)
+          labels.any? { |label| (effects + declared).any? { |own| own == label || own.start_with?("#{label}.") } }
+        end
       end
 
+      # The counts the footer prints and the JSON payload carries (#434). The two lanes are counted
+      # **separately** and deliberately: a declared label can never fail a build ([ADR-103](../adr/103-effect-labels.md)
+      # § WD17), and on a Rails application it is most of the mass — 709 `io.db.read` plus 644
+      # `io.db.write` on Redmine's 4,234 rows against zero of either proven. A single total tells a reader
+      # how big the report is; the split tells them which half is a policy surface and which half is a
+      # record whose diff they should be reviewing instead.
+      Totals = Data.define(:units, :printed, :omitted, :unselected, :proven, :declared, :exhaustive,
+                           :truncated)
+
       # Builds a report from an effect table. `full:` keeps the rows the report otherwise omits — an
       # exhaustive method proving nothing beyond `mutate.local`, which is the reading of `%a{pure}`.
-      def self.build(table, full: false)
-        rows = table.filter_map { |entry| row_for(entry) unless !full && entry.trivial? }
-        new(rows: rows.freeze, full: full)
+      #
+      # `scope:` selects which units are **printed** and never which are analysed (#439). A path argument
+      # used to narrow the analysis, and a summary is transitive over whatever was analysed, so the
+      # narrowed run answered `[] …?` for a method the whole-project run answered four labels for — with
+      # nothing distinguishing that from a method which genuinely does nothing. `sources:` is
+      # `Runner#effect_sources`, `{ "Class#m" => [path, …] }`, which is how a key is traced back to the
+      # file it was written in.
+      def self.build(table, full: false, sources: nil, scope: [], label: [], pure: false, limit: nil)
+        roots = normalize_scope(scope)
+        in_scope = table.filter_map do |entry|
+          row_for(entry) if roots.empty? || in_scope?(entry.key, sources, roots)
+        end
+        selected = in_scope.select { |row| keep?(row, full: full, label: label, pure: pure) }
+        new(rows: (limit ? selected.first(limit) : selected).freeze, full: full,
+            totals: totals_for(table, in_scope, selected, limit, query: pure || !label.empty?))
+      end
+
+      # What the default report drops, and why each is a separate question:
+      #
+      # - **`full:`** keeps a row the omission rule would drop. Two shapes qualify: a method proving
+      #   nothing beyond `mutate.local` and claiming nothing (the reading of `%a{pure}`), and a row with
+      #   no label in **either** lane, which is 35–38 % of a real application's rows and says literally
+      #   nothing — it exists only to record that something was unresolved, which the footer counts.
+      # - **`pure:`** is the complement of the first: exactly the rows the default omits for being
+      #   provably harmless, which is the set worth annotating and which nothing could ask for (#457).
+      # - **`label:`** is the question chapter 19 opens with. It matches **either** lane, because "which
+      #   controllers reach the network" is a question about the code and not about which lane knows it;
+      #   the row's own rendering keeps the two apart.
+      def self.keep?(row, full:, label:, pure:)
+        return row.pure? if pure
+        return row.carries_label?(label) unless label.empty?
+        return true if full
+
+        !row.pure? && !(row.effects.empty? && row.declared.empty?)
+      end
+      private_class_method :keep?
+
+      # Two ways a row can be missing, and only one of them `--full` answers: the **omission rule** drops
+      # a row that says nothing, and a **filter** — a path, `--label`, `--pure` — drops one that did not
+      # match. Telling a `--label io.net` reader that 4,678 more are behind `--full` would be false, so
+      # the two are counted apart.
+      def self.totals_for(table, in_scope, selected, limit, query:)
+        omitted = query ? 0 : in_scope.length - selected.length
+        Totals.new(
+          units: table.size, printed: limit ? [selected.length, limit].min : selected.length,
+          omitted: omitted, unselected: table.size - selected.length - omitted,
+          proven: selected.count { |row| !row.effects.empty? },
+          declared: selected.count { |row| !row.declared.empty? },
+          exhaustive: selected.count(&:exhaustive?),
+          truncated: limit ? [selected.length - limit, 0].max : 0
+        )
+      end
+      private_class_method :totals_for
+
+      # A path argument may name a file or a directory, and either may be written relative or absolute —
+      # so both sides are expanded and a directory matches by prefix. Deliberately not the `reach:` glob
+      # syntax: this is the argument a shell just tab-completed, and `rigor effects app/models` meaning
+      # "that directory" is the only reading a reader would guess.
+      def self.normalize_scope(scope)
+        Array(scope).map { |path| File.expand_path(path.to_s.chomp("/")) }.freeze
+      end
+      private_class_method :normalize_scope
+
+      def self.in_scope?(key, sources, roots)
+        paths = sources && sources[key]
+        return false if paths.nil? || paths.empty?
+
+        paths.any? do |path|
+          absolute = File.expand_path(path)
+          roots.any? { |root| absolute == root || absolute.start_with?("#{root}/") }
+        end
       end
+      private_class_method :in_scope?
 
       def self.row_for(entry)
         Row.new(
@@ -40,7 +143,14 @@ module Rigor
           declared: entry.rendered_declared.to_a,
           exhaustive: entry.exhaustive?,
           causes: entry.causes,
-          direct: entry.direct.bundles.to_h { |origin, labels| [origin.to_s, labels.to_a] }.freeze
+          direct: entry.direct.bundles.to_h { |origin, labels| [origin.to_s, labels.to_a] }.freeze,
+          # The declared lane's provenance (#434). A *discharging* plugin row leaves no cause line by
+          # design — WD6: a row the engine bundles is trusted, so it does not taint — which is why
+          # `plugin-attribution` appeared zero times in a whole Redmine run while 1,320 rows carried a
+          # `≤` clause. The origins are where the answer actually lives, and this is the direct half; a
+          # label that arrived transitively is `rigor effects explain`'s question.
+          attribution: entry.direct.declared_bundles.to_h { |origin, labels| [origin.to_s, labels.to_a] }
+                            .freeze
         )
       end
       private_class_method :row_for

data/lib/rigor/cli/effects_snapshot_command.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require "did_you_mean"
 require "optionparser"
 
-require_relative "../analysis/runner"
+# ADR-104 — `analysis/runner` is required lazily (in `#analyze`): a warm snapshot verb served by the
+# probe must reach its answer without `rigor/inference` in `$LOADED_FEATURES`.
+require_relative "../analysis/effects_cache_probe"
 require_relative "../cache/store"
 require_relative "../configuration"
 require_relative "../effects/discharge"
+require_relative "../effects/entry_points"
 require_relative "../effects/path_finder"
 require_relative "../effects/snapshot"
 require_relative "../effects/snapshot_diff"
@@ -79,8 +83,14 @@ module Rigor
         File.write(path, snapshot.to_yaml)
         @err.puts("rigor: wrote #{path} (#{snapshot.methods.size} method(s), #{snapshot.reach.size} reach entr" \
                   "#{snapshot.reach.size == 1 ? 'y' : 'ies'})")
-        @err.puts("rigor: note — `effects.snapshot.reach:` is empty, so the snapshot records `methods:` only.") if
-          configuration.effects_snapshot_reach.empty?
+        # #436 — the note names what to write, not only what is missing: the same per-project preset
+        # enumeration the unregistered-preset error uses, so the two can never disagree about which
+        # names this project's plugin set makes available.
+        if configuration.effects_snapshot_reach.empty?
+          @err.puts("rigor: note — `effects.snapshot.reach:` is empty, so the snapshot records `methods:` " \
+                    "only — the direct half. Name your entry points to record what they cause: " \
+                    "#{Effects::EntryPoints.availability}. The written file carries the same hint.")
+        end
         0
       end
 
@@ -103,7 +113,8 @@ module Rigor
         )
         return explain(diff, options) if @verb == "explain"
 
-        EffectsDiffRenderer.new(out: @out, path: path).render(diff, format: options.fetch(:format))
+        EffectsDiffRenderer.new(out: @out, path: path, sources: @sources)
+                           .render(diff, format: options.fetch(:format))
         @verb == "check" && diff.drift? ? 1 : 0
       end
 
@@ -126,24 +137,38 @@ module Rigor
 
       def explain(diff, options)
         rows = options.fetch(:symbol) ? rows_for_symbol(options.fetch(:symbol)) : rows_for_changes(diff)
+        return CLI::EXIT_USAGE if rows == :unknown
+
         EffectsExplainRenderer.new(out: @out).render(rows, format: options.fetch(:format))
         0
       end
 
+      # A misspelled `--symbol` used to print `Nothing to explain.` and exit 0, which is exactly what a
+      # method with no effects prints — so a typo and a real answer were indistinguishable, and a script
+      # could not tell them apart at all (#435). It is a usage error now, with the nearest key offered:
+      # the key set is right there, and a method key is long enough to get wrong.
       def rows_for_symbol(symbol)
         entry = @table[symbol]
         if entry.nil?
-          @err.puts("rigor: no effect unit named #{symbol}")
-          return []
+          @err.puts("rigor: no effect unit named #{symbol}#{suggestion(symbol)}")
+          return :unknown
         end
 
         reach_rows(symbol, entry.proven.to_a) + method_rows(symbol, entry.direct.proven.to_a)
       end
 
+      def suggestion(symbol)
+        nearest = ::DidYouMean::SpellChecker.new(dictionary: @table.keys).correct(symbol).first
+        nearest ? " — did you mean #{nearest}?" : ""
+      end
+
       # Every label a change introduced, explained once: a `reach:` change gets its shortest edge path, a
       # `methods:` change gets the origin in the method's own body.
       def rows_for_changes(diff)
         diff.events.flat_map do |event|
+          next exhaustiveness_rows(event) if
+            event.category == Effects::SnapshotDiff::EXHAUSTIVE_LOST
+
           labels = labels_of(event)
           next [] if labels.empty?
 
@@ -159,13 +184,29 @@ module Rigor
         entry ? entry.proven.to_a : []
       end
 
+      # `exhaustive → not` is the drift row a reader is least equipped to interpret, and it was the one
+      # row `explain` could not expand (#435): it carries no label, so {#labels_of} answered with nothing
+      # and the event produced no explanation at all. What explains it is the taint causes — the calls
+      # the analyzer could not follow — which is the detail the snapshot stopped recording per row
+      # (#434). The two halves meet here: the record keeps the stable count, and this names them.
+      def exhaustiveness_rows(event)
+        entry = @table[event.symbol]
+        return [] if entry.nil?
+
+        causes = Effects::Snapshot.render_causes(entry.causes)
+        return [] if causes.empty?
+
+        [EffectsExplainRenderer::Row.new(table: event.table, symbol: event.symbol, label: nil,
+                                         path: [].freeze, origin: nil, causes: causes)]
+      end
+
       def reach_rows(symbol, labels)
         labels.filter_map do |label|
           path = Effects::PathFinder.shortest(@table, symbol: symbol, label: label)
           next if path.nil?
 
           EffectsExplainRenderer::Row.new(table: "reach", symbol: symbol, label: label,
-                                          path: path.to_a, origin: path.origin)
+                                          path: path.to_a, origin: path.origin, causes: [].freeze)
         end
       end
 
@@ -178,7 +219,7 @@ module Rigor
           next if origin.nil?
 
           EffectsExplainRenderer::Row.new(table: "methods", symbol: symbol, label: label,
-                                          path: [].freeze, origin: origin.to_s)
+                                          path: [].freeze, origin: origin.to_s, causes: [].freeze)
         end
       end
 
@@ -188,7 +229,20 @@ module Rigor
       # the ADR-45 whole-run result cache like `rigor check` — the diagnostics entry plus the #382 effects
       # sidecar keyed beside it, so `rigor effects check` after `rigor check` under a configured `effects:`
       # block is a warm hit plus the fixpoint.
+      # ADR-104 — a snapshot is built from the table, the sources and the vocabulary, all three of which
+      # the #482 summary entry (plus the plugins' own declarations) carries, so a warm run takes the
+      # probe and never loads the engine. A decline is the runner path below, unchanged.
       def build_snapshot(configuration, full:)
+        served = Analysis::EffectsCacheProbe.new(
+          configuration: configuration, cache_root: configuration.cache_path
+        ).serve(configuration.paths)
+        return snapshot_from(configuration, full, served) if served
+
+        snapshot_from(configuration, full, analyze(configuration))
+      end
+
+      def analyze(configuration)
+        require_relative "../analysis/runner"
         runner = Analysis::Runner.new(
           configuration: configuration,
           cache_store: Cache::Store.new(root: configuration.cache_path),
@@ -196,14 +250,24 @@ module Rigor
           workers: 0
         )
         runner.run(configuration.paths)
-        @table = runner.effect_table
-        Effects::Snapshot.build(
-          table: @table, configuration: configuration, sources: runner.effect_sources, full: full,
+        Analysis::EffectsCacheProbe::Served.new(
+          table: runner.effect_table, sources: runner.effect_sources, plugin_facts: nil,
           registry: Effects::Registry.for_configuration(configuration,
                                                         plugin_facts: runner.effect_plugin_facts)
         )
       end
 
+      # WD3 — one build, whichever lane produced the inputs, so a served snapshot and an analysed one
+      # cannot drift in how they are assembled.
+      def snapshot_from(configuration, full, served)
+        @table = served.table
+        @sources = served.sources
+        Effects::Snapshot.build(
+          table: @table, configuration: configuration, sources: served.sources, full: full,
+          registry: served.registry
+        )
+      end
+
       # ---- options ------------------------------------------------
 
       def parse_options

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

@@ -84,19 +84,43 @@ module Rigor
     rescue OptionParser::ParseError => e
       @err.puts(e.message)
       EXIT_USAGE
+    rescue ConfigurationError => e
+      # #433 — a mistake in `.rigor.yml` is the same kind of event as a bad flag, and belongs in the same
+      # shape: one `rigor:` line naming the key, and the conventional usage exit code. It used to escape
+      # as an uncaught exception with a ~30-frame backtrace naming a file inside `lib/rigor/`, which reads
+      # as a crash even though the message it carried said exactly which key to fix.
+      #
+      # Caught here rather than per command because every command loads a configuration, and the ones
+      # that resolve a key later (`effects update` expanding `snapshot.reach:` once the plugins that
+      # register presets have loaded) would each need their own rescue at their own point.
+      @err.puts("rigor: #{e.message}")
+      EXIT_USAGE
     end
 
     private
 
     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"
 
@@ -160,7 +184,7 @@ module Rigor
         # - paths:       directories scanned by `rigor check` and
         #                `rigor type-scan` when no path is given.
         # - plugins:     opt-in list of plugin gem names to load.
-        #                See https://github.com/rigortype/rigor/tree/main/plugins
+        #                See https://github.com/rigortype/rigor/tree/master/plugins
         #                for production plugins (rigor-activerecord, rigor-sorbet, …).
         # - disable:     list of `rigor check` rule identifiers to
         #                silence project-wide. The shipped rules are
@@ -356,13 +380,13 @@ module Rigor
           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)
@@ -370,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