rigortype 0.4.5 → 0.4.7

data/lib/rigor/cli/sig_gen_command.rb

@@ -3,6 +3,7 @@
 require "optionparser"
 
 require_relative "../configuration"
+require_relative "../analysis/path_expansion"
 require_relative "../effects/config_envelopes"
 require_relative "../effects/registry"
 require_relative "options"
@@ -37,7 +38,11 @@ module Rigor
 
       VALID_MODES = %w[print diff write check].freeze
       VALID_PARAM_POLICIES = %w[untyped observed observed-strict].freeze
-      VALID_FORMATS = %w[text json].freeze
+
+      # The per-target outcomes `--write` refuses: the file is left untouched and the run exits 1. `--check` counts
+      # them apart from the targets it would update, since `--write` does not fix a refused file.
+      TARGET_REFUSALS = %i[skipped_invalid_rbs skipped_invalid_encoding skipped_unparseable].freeze
+      private_constant :TARGET_REFUSALS
 
       # The skip reasons {#report_skipped} counts. The four left out each have a report of their own
       # ({#report_unrenderable}, {#report_unresolvable_superclasses}, {#report_inline_declared}, and the refusal
@@ -55,29 +60,43 @@ module Rigor
         configuration = Configuration.load(options.fetch(:config))
         paths = @argv.empty? ? configuration.paths : @argv
 
+        path_errors = path_diagnostics(paths, configuration)
+        report_path_errors(path_errors, options)
+
         observation_roots = observation_roots(configuration, options)
-        observations = collect_observations(configuration, options, observation_roots)
+        observations = collect_observations(configuration, options, observation_roots, paths)
+        mode = options.fetch(:mode).to_sym
         generator = SigGen::Generator.new(configuration: configuration, paths: paths,
                                           observations: observations,
                                           include_private: options.fetch(:include_private),
                                           effect_annotator: effect_annotator(configuration, paths, options),
-                                          overwrite: options.fetch(:overwrite))
+                                          overwrite: options.fetch(:overwrite),
+                                          target_writer: target_writer(configuration, options, mode))
         candidates = generator.run
-        mode = options.fetch(:mode).to_sym
 
         status = case mode
-                 when :write then dispatch_write(candidates, configuration, options)
-                 when :check then dispatch_check(candidates, configuration, options)
+                 when :write then dispatch_write(candidates, configuration, options, generator)
+                 when :check then dispatch_check(candidates, configuration, options, generator)
                  else
-                   dispatch_print_or_diff(candidates, mode, options, observation_roots)
+                   dispatch_print_or_diff(candidates, mode, options, observation_roots, path_errors)
                    0
                  end
+        status = 1 if path_errors.any?(&:error?)
+        report_run_notes(candidates, generator, options)
+        status
+      end
+
+      def report_run_notes(candidates, generator, options)
         report_skipped(candidates, options)
         report_inline_declared(candidates, options)
         report_withheld_annotations(candidates, options)
         report_unrenderable(generator.unrenderable)
-        report_unresolvable_superclasses(generator.unresolvable_superclasses)
-        status
+        report_unresolvable_superclasses(generator.unresolvable_superclasses, generator)
+      end
+
+      # The parser `run` parses with, built without parsing anything (the catalogue reads it, ADR-126 WD3).
+      def option_parser(options = {})
+        build_option_parser(options)
       end
 
       private
@@ -208,41 +227,87 @@ module Rigor
       # declaring it would fail to build and take the class's type coverage with it. Naming the unresolved
       # superclass is the actionable part — it is usually one gem's missing RBS standing between the user
       # and signatures for a whole layer of their app.
-      def report_unresolvable_superclasses(unresolvable)
-        return if unresolvable.empty?
+      #
+      # Issue #2437 — a superclass the project declares in source but this run wrote nothing for gets different
+      # advice: no gem RBS is missing; the superclass's own methods could not be typed, or were not written.
+      def report_unresolvable_superclasses(unresolvable, generator)
+        reports = unresolvable.map { |name, superclass| [name, *generator.unresolvable_superclass_report(superclass)] }
+        project, external = reports.partition { |_name, kind, _root| kind == :project }
+                                   .map { |rows| rows.to_h { |name, _kind, root| [name, root] } }
+        report_unwritten_project_superclasses(project)
+        return if external.empty?
 
         @err.puts(
-          "rigor sig-gen: skipped #{unresolvable.size} class(es) whose superclass no loaded RBS declares. " \
+          "rigor sig-gen: skipped #{external.size} class(es) whose superclass no loaded RBS declares. " \
           "A signature for them would fail to build (`RBS::NoSuperclassFoundError`) and would leave the " \
           "class LESS typed than it is now. Provide RBS for the superclass — `rbs collection install`, the " \
           "gem's own `sig/`, or a `signature_paths:` entry — and re-run."
         )
-        unresolvable.sort.each { |class_name, superclass| @err.puts("  #{class_name} < #{superclass}") }
+        external.sort.each { |class_name, superclass| @err.puts("  #{class_name} < #{superclass}") }
+      end
+
+      def report_unwritten_project_superclasses(project)
+        return if project.empty?
+
+        @err.puts(
+          "rigor sig-gen: skipped #{project.size} class(es) whose superclass this run wrote no signature for. " \
+          "The superclass is declared in the project's source, but its own methods could not be typed, or its " \
+          "`sig/` file could not be written, so a signature for these subclasses would fail to build " \
+          "(`RBS::NoSuperclassFoundError`). Annotate or type the superclass's methods, fix its `sig/` file, or " \
+          "hand-write its declaration, and re-run."
+        )
+        project.sort.each { |class_name, superclass| @err.puts("  #{class_name} < #{superclass}") }
       end
 
-      def dispatch_print_or_diff(candidates, mode, options, observation_roots)
+      # #1991 — the path errors `rigor check` reports for the arguments: a path that is neither a directory nor a
+      # `.rb` file. Warned about beside files that will be read, an error when nothing will be, as `check` grades it.
+      def path_diagnostics(paths, configuration)
+        bad = Analysis::PathExpansion.unusable(paths)
+        return [] if bad.empty?
+
+        any_files = !Analysis::PathExpansion.ruby_files(paths, configuration.exclude_patterns,
+                                                        base: configuration.exclude_base).empty?
+        Analysis::PathExpansion.diagnostics(bad, any_files: any_files)
+      end
+
+      # Without this a missing path was read as empty, so the run said "No candidates" and exited 0 (#1991). JSON
+      # print/diff carries the errors in its payload (see {#path_errors_in_payload?}); every other form says them on
+      # stderr, as `rigor check` does.
+      def report_path_errors(path_errors, options)
+        return if path_errors_in_payload?(options)
+
+        path_errors.each { |diagnostic| @err.puts(diagnostic.to_s) }
+      end
+
+      def path_errors_in_payload?(options)
+        options.fetch(:format) == "json" && %w[print diff].include?(options.fetch(:mode))
+      end
+
+      def dispatch_print_or_diff(candidates, mode, options, observation_roots, path_errors)
         SigGen::Renderer.new(out: @out).render(
           candidates: candidates,
           mode: mode,
           format: options.fetch(:format),
           selection: options.fetch(:selection),
-          observation: observation_report(observation_roots, options)
+          observation: observation_report(observation_roots, options),
+          diagnostics: path_errors_in_payload?(options) ? path_errors : []
         )
       end
 
       # @return exit status — non-zero when a file the user asked to write could not be written.
-      def dispatch_write(candidates, configuration, options)
-        results = build_writer(configuration, options).write_all(candidates)
+      def dispatch_write(candidates, configuration, options, generator)
+        writer = build_writer(configuration, options)
+        results = writer.write_all(candidates, header_spelling: generator.method(:generic_header_spelling))
 
         refused = refused_candidates(candidates)
-        SigGen::Renderer.new(out: @out).render_write(results: results, format: options.fetch(:format), refused: refused)
+        SigGen::Renderer.new(out: @out).render_write(results: results, format: options.fetch(:format), refused: refused,
+                                                     left_bare: writer.left_bare)
         SigGen::Renderer.refusal_lines(refused).each { |line| @err.puts(line) }
-        # A refused write (an assembled file that does not parse, an existing target that is not valid UTF-8,
-        # or a method whose inline and `sig/` declarations disagree without `--overwrite`) means 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.
-        refusals = %i[skipped_invalid_rbs skipped_invalid_encoding]
-        results.any? { |result| refusals.include?(result.action) } || !refused.empty? ? 1 : 0
+        # A refused write (an assembled file that does not parse, an existing target that is not valid UTF-8 or
+        # does not parse, or a method whose inline and `sig/` declarations disagree without `--overwrite`) means 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| TARGET_REFUSALS.include?(result.action) } || !refused.empty? ? 1 : 0
       end
 
       # ADR-112 WD4 — the methods whose inline and `sig/` declarations disagree, refused because the run did not
@@ -258,11 +323,15 @@ module Rigor
       # --overwrite` would apply it.
       #
       # @return 1 when `sig/` is out of date (or a write would be refused), 0 when it is current.
-      def dispatch_check(candidates, configuration, options)
-        results = build_writer(configuration, options, dry_run: true).write_all(candidates)
+      #
+      # A generic header held back from the repair (#2605) is reported, but does not fail the check: `--write`
+      # cannot change it, and it was failing the project's env build before the run as well.
+      def dispatch_check(candidates, configuration, options, generator)
+        writer = build_writer(configuration, options, dry_run: true)
+        results = writer.write_all(candidates, header_spelling: generator.method(:generic_header_spelling))
         refused = refused_candidates(candidates)
         SigGen::Renderer.new(out: @out).render_check(results: results, format: options.fetch(:format),
-                                                     refused: refused)
+                                                     refused: refused, left_bare: writer.left_bare)
         stale = SigGen::Renderer.out_of_date(results)
         return 0 if stale.empty? && refused.empty?
 
@@ -271,16 +340,40 @@ module Rigor
       end
 
       def report_check_failure(stale, refused)
-        unless stale.empty?
-          @err.puts("rigor sig-gen --check: #{stale.size} signature file(s) out of date; " \
+        pending, refusals = stale.partition { |result| !TARGET_REFUSALS.include?(result.action) }
+        unless pending.empty?
+          @err.puts("rigor sig-gen --check: #{pending.size} signature file(s) out of date; " \
                     "run `rigor sig-gen --write` with the same options to update them.")
         end
+        @err.puts(refused_targets_line(refusals)) unless refusals.empty?
         return if refused.empty?
 
         @err.puts("rigor sig-gen --check: #{refused.size} method(s) whose inline declaration and sig/ copy " \
                   "disagree; make them agree, or pass --overwrite to replace the sig/ member.")
       end
 
+      # A target `--write` refuses is not one it would update: it is counted apart from the out-of-date targets. Where
+      # the existing file is the user's to repair (encoding, parse), it is named for a hand fix. An invalid generated
+      # file is a Rigor rendering bug (its REFUSED line says so), so it is counted but never listed as a hand fix.
+      def refused_targets_line(results)
+        by_hand = results.reject { |result| result.action == :skipped_invalid_rbs }
+                         .map { |result| result.target_path.to_s }
+        head = "rigor sig-gen --check: #{results.size} signature file(s) refused; `--write` does not update them"
+        if by_hand.empty?
+          return "#{head}. The generated RBS did not parse: a Rigor bug, see its REFUSED line on stdout."
+        end
+
+        "#{head}. Repair by hand: #{by_hand.join(', ')}."
+      end
+
+      # #2461 — only a run that writes or compares files asks whether the writer will accept each target: where a
+      # target lands depends on the working directory, and print, diff and JSON output must not.
+      def target_writer(configuration, options, mode)
+        return nil unless %i[write check].include?(mode)
+
+        build_writer(configuration, options, dry_run: true)
+      end
+
       def build_writer(configuration, options, dry_run: false)
         layout_index = SigGen::LayoutIndex.new(signature_paths: configuration.signature_paths)
         path_mapper = SigGen::PathMapper.new(configuration: configuration, layout_index: layout_index)
@@ -291,7 +384,11 @@ module Rigor
       # specified, observe the project's test roots: `test_paths:`, or whichever of `spec/` and `test/` exist. With no
       # root at all the run still succeeds, but says so — otherwise every parameter stays `untyped` with nothing
       # naming the reason.
-      def collect_observations(configuration, options, observe_paths)
+      #
+      # The collector pre-indexes the classes of the paths the run generates for as well as the configured ones, so
+      # a call site on a class named only on the command line (`sig-gen ../lib` from a subdirectory, where no
+      # config file is discovered and the default `paths:` resolve under the subdirectory) attaches (#2078).
+      def collect_observations(configuration, options, observe_paths, paths)
         return {} if options.fetch(:params) != "observed"
 
         if observe_paths.empty?
@@ -299,7 +396,8 @@ module Rigor
         else
           warn_missing_test_roots(observe_paths)
         end
-        SigGen::ObservationCollector.new(configuration: configuration, paths: observe_paths).collect
+        SigGen::ObservationCollector.new(configuration: configuration, paths: observe_paths,
+                                         source_paths: (configuration.paths + paths).uniq).collect
       end
 
       # The roots `--params=observed` reads: `--observe=PATH...` when given, else the project's test roots.
@@ -387,7 +485,7 @@ module Rigor
           opts.on("--no-cache", "Do not read or write the analysis cache (effect collection only)") do
             options[:no_cache] = true
           end
-          opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
+          Options.add_format(opts, options, "Output format: text or json")
           opts.on("--params=POLICY", "Parameter policy: untyped (default), observed, observed-strict") do |value|
             options[:params] = value
           end
@@ -417,11 +515,9 @@ module Rigor
 
       def validation_error(options)
         mode = options.fetch(:mode)
-        format = options.fetch(:format)
         params = options.fetch(:params)
 
         return "--print, --diff, --write, and --check are mutually exclusive flags; pick one" if mode == "conflict"
-        return "unsupported --format=#{format}" unless VALID_FORMATS.include?(format)
         return "unsupported --params=#{params}" unless VALID_PARAM_POLICIES.include?(params)
         if params == "observed-strict"
           return "--params=observed-strict is reserved until the capability-role catalog ships"

data/lib/rigor/cli/skill_command.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "optparse"
+
 require_relative "command"
 require_relative "../rooted_glob"
 
@@ -77,6 +79,28 @@ module Rigor
       # up.
       SKILLS_ROOT = File.expand_path("../../../skills", __dir__).freeze
 
+      # The parser of `rigor skill`, built without parsing anything: the catalogue reads its flags from it (ADR-126
+      # WD3). The positional grammar is read by hand in {#run}, so this describes the switches and parses nothing.
+      def option_parser(options = {})
+        OptionParser.new do |opts|
+          opts.banner = USAGE.lines.first.chomp
+          opts.on("--full NAME", "Print the SKILL.md body and its references/ inline") { |v| options[:full] = v }
+          opts.on("--path NAME", "Print the absolute path of the SKILL.md file") { |v| options[:path] = v }
+          opts.on("--list", "List bundled skills (name + absolute path)") { options[:list] = true }
+          opts.on("--describe", "Report project state and recommend the next skill") { options[:describe] = true }
+        end
+      end
+
+      # The parser of `rigor skill describe` and `rigor describe`; `banner` is the usage line of the spelling used.
+      def self.describe_option_parser(banner = "Usage: rigor skill describe [--deep]", options = {})
+        OptionParser.new do |opts|
+          opts.banner = banner
+          opts.on("--deep", "Run `rigor check` first and route the recommendation on its result") do
+            options[:deep] = true
+          end
+        end
+      end
+
       # @return CLI exit status.
       def run
         case @argv.first
@@ -87,7 +111,7 @@ module Rigor
           0
         when "describe", "--describe"
           @argv.shift
-          run_describe
+          run_describe("Usage: rigor skill describe [--deep]")
         when "--list"
           @argv.shift
           run_list
@@ -176,7 +200,12 @@ module Rigor
       # `--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
+      def run_describe(usage)
+        if @argv.intersect?(%w[-h --help])
+          @out.puts(usage)
+          return 0
+        end
+
         deep = !@argv.delete("--deep").nil?
         unknown = @argv.first
         return usage_error("unknown option for `describe`: #{unknown}") unless unknown.nil?
@@ -222,7 +251,7 @@ module Rigor
         discover_skills.find { |s| s.fetch(:name) == name }
       end
 
-      # The `references/*.md` files bundled alongside a skill, sorted so the `NN-` prefixes drive read order.
+      # The `references/*.md` files bundled alongside a skill.
       def reference_files(skill)
         dir = File.join(File.dirname(skill.fetch(:path)), "references")
         return [] unless File.directory?(dir)

data/lib/rigor/cli/skill_deep_probe.rb

@@ -96,7 +96,7 @@ module Rigor
         end
       end
 
-      # The `rigor-doctor` signal, read exactly as `rigor doctor` itself reads it: an RBS environment that built to
+      # The `rigor-doctor` signal: 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)

data/lib/rigor/cli/skill_describe.rb

@@ -361,7 +361,7 @@ module Rigor
       end
 
       # The one-line essence of a skill's frontmatter `description`, read live from the SKILL.md so the catalogue can
-      # never go stale relative to the shipped skill. Drops the `Triggers:` / `NOT for` tail and caps the length.
+      # never go stale relative to the shipped skill. Drops the `Triggers:` tail and caps the length.
       def catalog_blurb(path)
         text = frontmatter(path).fetch("description", "").to_s.strip.tr("\n", " ").squeeze(" ")
         head = text.split(/\s*Triggers?:/, 2).first.to_s.strip

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 "json_document"
 require_relative "../project_environment"
 
 module Rigor
@@ -43,15 +44,12 @@ module Rigor
         execute(file: file, options: options)
       end
 
-      private
-
-      def parse_options
-        options = { format: "text", delay: nil, verbose: false, line: nil, config: nil }
-        parser = OptionParser.new do |opts|
+      # The parser this command parses with, built without parsing anything: the catalogue reads the
+      # flags and formats from it (ADR-126 WD3). `options` is only written by the switches' blocks.
+      def option_parser(options = {})
+        OptionParser.new do |opts|
           opts.banner = USAGE
-          opts.on("--format=FORMAT", "Output format: text (animation) or json (raw event stream)") do |value|
-            options[:format] = value
-          end
+          Options.add_format(opts, options, "Output format: text (animation) or json (raw event stream)")
           opts.on("--delay=SECONDS", Float,
                   "Autoplay with SECONDS between frames (default: step on key press)") do |value|
             options[:delay] = value
@@ -62,7 +60,13 @@ module Rigor
           opts.on("--verbose", "Include every expression enter/result frame") { options[:verbose] = true }
           Options.add_config(opts, options)
         end
-        parser.parse!(@argv)
+      end
+
+      private
+
+      def parse_options
+        options = { format: "text", delay: nil, verbose: false, line: nil, config: nil }
+        option_parser(options).parse!(@argv)
         options
       end
 
@@ -82,6 +86,7 @@ module Rigor
 
         if options.fetch(:format) == "json"
           @out.puts(JSON.pretty_generate(frames.map { |event| event_to_h(event) }))
+          @err.puts(JsonDocument::SHAPE_NOTICES.fetch(:trace))
           return 0
         end
 

data/lib/rigor/cli/triage_command.rb

@@ -36,14 +36,13 @@ module Rigor
         0
       end
 
-      private
-
-      def parse_options
-        options = { config: nil, format: "text", top: 10, sections: DEFAULT_SECTIONS, include_info: false }
+      # The parser this command parses with, built without parsing anything: the catalogue reads the
+      # flags and formats from it (ADR-126 WD3). `options` is only written by the switches' blocks.
+      def option_parser(options = {})
         OptionParser.new do |opts|
           opts.banner = USAGE
           Options.add_config(opts, options)
-          opts.on("--format=FORMAT", "Output format: text (default) or json") { |v| options[:format] = v }
+          Options.add_format(opts, options, "Output format: text (default) or json")
           opts.on("--top=N", Integer, "Hotspot-file count (default 10)") { |v| options[:top] = v }
           opts.on("--include-info",
                   "Route info diagnostics into distribution / selectors / hotspots " \
@@ -57,15 +56,15 @@ module Rigor
           opts.on("--selectors-only", "Print only the class/method selectors section") do
             options[:sections] = %i[selectors]
           end
-        end.parse!(@argv)
-        validate!(options)
-        options
+        end
       end
 
-      def validate!(options)
-        return if %w[text json].include?(options.fetch(:format))
+      private
 
-        raise OptionParser::InvalidArgument, "unsupported format: #{options.fetch(:format)}"
+      def parse_options
+        options = { config: nil, format: "text", top: 10, sections: DEFAULT_SECTIONS, include_info: false }
+        option_parser(options).parse!(@argv)
+        options
       end
 
       # Sequential, cache-backed, no run-stats: triage only needs the diagnostic stream, and sequential keeps the rule

data/lib/rigor/cli/triage_renderer.rb

@@ -3,6 +3,7 @@
 require "json"
 
 require_relative "../triage"
+require_relative "json_document"
 
 module Rigor
   class CLI
@@ -17,7 +18,7 @@ module Rigor
       end
 
       def json
-        JSON.pretty_generate(Triage.report_to_h(@report))
+        JSON.pretty_generate(JsonDocument.stamp(Triage.report_to_h(@report)))
       end
 
       def text

data/lib/rigor/cli/type_of_command.rb

@@ -13,10 +13,12 @@ require_relative "../inference/scope_indexer"
 require_relative "../inference/precision_scanner"
 require_relative "../source/node_children"
 require_relative "type_of_renderer"
+require_relative "json_document"
 require_relative "type_of_template_probe"
 require_relative "command"
 require_relative "options"
 require_relative "../project_environment"
+require_relative "type_of_project_scope"
 
 module Rigor
   class CLI
@@ -28,7 +30,7 @@ module Rigor
     # Encapsulating the command in its own class keeps `Rigor::CLI` focused on dispatching and lets us evolve the
     # type-of UX (extra flags, watch mode, streaming output) without bloating the CLI shell. Output formatting is
     # delegated to {TypeOfRenderer}.
-    class TypeOfCommand < Command
+    class TypeOfCommand < Command # rubocop:disable Metrics/ClassLength
       include TypeOfTemplateProbe
 
       USAGE = "Usage: rigor type-of [options] FILE:LINE[:COL] [FILE:LINE[:COL] ...]"
@@ -64,19 +66,24 @@ module Rigor
         execute(targets: targets, options: options, buffer: buffer)
       end
 
-      private
-
-      def parse_options
-        options = { format: "text", trace: false, config: nil, tmp_file: nil, instead_of: nil }
-
-        parser = OptionParser.new do |opts|
+      # The parser this command parses with, built without parsing anything: the catalogue reads the
+      # flags and formats from it (ADR-126 WD3). `options` is only written by the switches' blocks.
+      def option_parser(options = {})
+        OptionParser.new do |opts|
           opts.banner = USAGE
-          opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
+          Options.add_format(opts, options, "Output format: text or json")
           opts.on("--trace", "Record fail-soft fallbacks via FallbackTracer") { options[:trace] = true }
           Options.add_config(opts, options)
           Options.add_editor_mode(opts, options)
         end
-        parser.parse!(@argv)
+      end
+
+      private
+
+      def parse_options
+        options = { format: "text", trace: false, config: nil, tmp_file: nil, instead_of: nil }
+
+        option_parser(options).parse!(@argv)
 
         options
       end
@@ -88,7 +95,7 @@ module Rigor
       def execute(targets:, options:, buffer: nil)
         configuration = Configuration.load(options.fetch(:config))
         environment = project_environment(targets.map(&:file).uniq, configuration, buffer)
-        base_scope = Scope.empty(environment: environment)
+        base_scope = TypeOfProjectScope.build(environment: environment, configuration: configuration, buffer: buffer)
 
         results_by_target = Array.new(targets.length)
         targets.each_with_index.group_by { |target, _index| target.file }.each do |file, indexed_targets|
@@ -100,7 +107,7 @@ module Rigor
         results = results_by_target.compact.flatten(1)
         return 1 if results.empty?
 
-        TypeOfRenderer.new(out: @out).render(results, format: options.fetch(:format))
+        TypeOfRenderer.new(out: @out, err: @err).render(results, format: options.fetch(:format))
         0
       end
 
@@ -205,7 +212,6 @@ module Rigor
         end
       end
 
-      # `presentation` is the Result's optional `enumeration:` / `location_mapper:`.
       def type_result(file, line, column, node, scope_index, options, **presentation)
         tracer = options[:trace] ? Inference::FallbackTracer.new : nil
         type = scope_index[node].type_of(node, tracer: tracer)

data/lib/rigor/cli/type_of_project_scope.rb

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

data/lib/rigor/cli/type_of_renderer.rb

@@ -4,6 +4,7 @@ require "json"
 require "optionparser"
 
 require_relative "renderable"
+require_relative "json_document"
 
 module Rigor
   class CLI
@@ -14,8 +15,9 @@ module Rigor
     class TypeOfRenderer
       include Renderable
 
-      def initialize(out:)
+      def initialize(out:, err: nil)
         @out = out
+        @err = err
       end
 
       private
@@ -96,6 +98,7 @@ module Rigor
         enumerations = line_enumerations(list)
         payload[:line_enumerations] = enumerations unless enumerations.empty?
         @out.puts(JSON.pretty_generate(payload))
+        @err&.puts(JsonDocument::SHAPE_NOTICES.fetch(:type_of))
       end
 
       def line_enumerations(results)

data/lib/rigor/cli/type_scan_command.rb

@@ -38,15 +38,12 @@ module Rigor
         determine_exit(report, options)
       end
 
-      private
-
-      def parse_options
-        options = { format: "text", limit: 10, show_recognized: false, threshold: nil,
-                    config: nil }
-
-        parser = OptionParser.new do |opts|
+      # The parser this command parses with, built without parsing anything: the catalogue reads the
+      # flags and formats from it (ADR-126 WD3). `options` is only written by the switches' blocks.
+      def option_parser(options = {})
+        OptionParser.new do |opts|
           opts.banner = USAGE
-          opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
+          Options.add_format(opts, options, "Output format: text or json")
           Options.add_config(opts, options)
           opts.on("--limit=N", Integer, "Max example events to print (text only)") do |value|
             options[:limit] = value
@@ -58,7 +55,15 @@ module Rigor
             options[:threshold] = value
           end
         end
-        parser.parse!(@argv)
+      end
+
+      private
+
+      def parse_options
+        options = { format: "text", limit: 10, show_recognized: false, threshold: nil,
+                    config: nil }
+
+        option_parser(options).parse!(@argv)
 
         options
       end