rigortype 0.2.7 → 0.2.8

data/lib/rigor/cli/type_of_command.rb

@@ -18,14 +18,11 @@ module Rigor
   class CLI
     # Executes the `rigor type-of` command.
     #
-    # The command is a thin probe over `Rigor::Scope#type_of`: it locates the
-    # deepest expression at a `(file, line, column)` triple and prints the
-    # inferred type, RBS erasure, and (optionally) the recorded fail-soft
-    # fallbacks.
+    # The command is a thin probe over `Rigor::Scope#type_of`: it locates the deepest expression at a `(file, line,
+    # column)` triple and prints the inferred type, RBS erasure, and (optionally) the recorded fail-soft fallbacks.
     #
-    # 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
+    # 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
       USAGE = "Usage: rigor type-of [options] FILE:LINE:COL"
@@ -63,11 +60,9 @@ module Rigor
 
       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.
+        # 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.
         physical = buffer ? buffer.resolve(file) : file
         return 1 unless file_exists?(buffer ? physical : file)
 
@@ -83,12 +78,10 @@ module Rigor
         tracer = options[:trace] ? Inference::FallbackTracer.new : nil
         base_scope = Scope.empty(environment: project_environment(file, configuration))
 
-        # 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.
+        # 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]
 
@@ -99,11 +92,9 @@ module Rigor
         0
       end
 
-      # Builds a project-aware environment relative to the probed file.
-      # Project-RBS auto-detection roots at CWD today; future work will
-      # walk parent directories to find the enclosing `Gemfile`/`*.gemspec`
-      # so probes against files outside the current process's CWD still
-      # see the right `sig/` tree.
+      # Builds a project-aware environment relative to the probed file. Project-RBS auto-detection roots at CWD today;
+      # future work will walk parent directories to find the enclosing `Gemfile`/`*.gemspec` so probes against files
+      # outside the current process's CWD still see the right `sig/` tree.
       def project_environment(_file, configuration)
         Environment.for_project(
           libraries: configuration.libraries,

data/lib/rigor/cli/type_of_renderer.rb

@@ -7,12 +7,10 @@ require_relative "renderable"
 
 module Rigor
   class CLI
-    # Renders a `TypeOfCommand::Result` as either human-readable text or a
-    # machine-readable JSON document.
+    # Renders a `TypeOfCommand::Result` as either human-readable text or a machine-readable JSON document.
     #
-    # The renderer is a separate concern from the command itself so that future
-    # output formats (sexp, lsp-style hover payloads, color decoration) can
-    # plug in without disturbing argument parsing or the inference call site.
+    # The renderer is a separate concern from the command itself so that future output formats (sexp, lsp-style hover
+    # payloads, color decoration) can plug in without disturbing argument parsing or the inference call site.
     class TypeOfRenderer
       include Renderable
 

data/lib/rigor/cli/type_scan_command.rb

@@ -16,11 +16,9 @@ module Rigor
   class CLI
     # Executes the `rigor type-scan` command.
     #
-    # The command walks every Prism node in one or more files, runs
-    # `Rigor::Scope#type_of` on each, and reports per-node-class coverage of
-    # the inference engine's directly recognized classes. It is the project's
-    # primary CI gate for tracking how much of an input source the engine can
-    # name without falling back to `Dynamic[Top]`.
+    # The command walks every Prism node in one or more files, runs `Rigor::Scope#type_of` on each, and reports
+    # per-node-class coverage of the inference engine's directly recognized classes. It is the project's primary CI gate
+    # for tracking how much of an input source the engine can name without falling back to `Dynamic[Top]`.
     class TypeScanCommand < Command
       USAGE = "Usage: rigor type-scan [options] PATH..."
 
@@ -78,9 +76,8 @@ module Rigor
         accumulator.to_report(paths, options)
       end
 
-      # Builds a project-aware environment that auto-detects `<cwd>/sig`
-      # by default and honours the configuration's `libraries:` /
-      # `signature_paths:` keys when present.
+      # Builds a project-aware environment that auto-detects `<cwd>/sig` by default and honours the configuration's
+      # `libraries:` / `signature_paths:` keys when present.
       def project_environment(configuration)
         Environment.for_project(
           libraries: configuration.libraries,
@@ -108,8 +105,7 @@ module Rigor
         report.unrecognized_ratio > threshold ? 1 : 0
       end
 
-      # Internal helper that accumulates per-file scan results into the
-      # totals carried by `Report`.
+      # Internal helper that accumulates per-file scan results into the totals carried by `Report`.
       class ScanAccumulator
         def initialize
           @visits = Hash.new(0)

data/lib/rigor/cli/type_scan_renderer.rb

@@ -7,11 +7,9 @@ require_relative "renderable"
 
 module Rigor
   class CLI
-    # Renders a `TypeScanCommand::Report` as either a terminal-friendly text
-    # summary or a JSON document suitable for CI ingestion. Text and JSON
-    # branches share a single source of truth (the `Report` value object) so
-    # the two formats stay in lockstep; that pairing is why this class is a
-    # bit longer than the default class-length budget.
+    # Renders a `TypeScanCommand::Report` as either a terminal-friendly text summary or a JSON document suitable for CI
+    # ingestion. Text and JSON branches share a single source of truth (the `Report` value object) so the two formats
+    # stay in lockstep; that pairing is why this class is a bit longer than the default class-length budget.
     class TypeScanRenderer
       include Renderable
 

data/lib/rigor/cli/type_scan_report.rb

@@ -2,9 +2,8 @@
 
 module Rigor
   class CLI
-    # Aggregated report assembled by `TypeScanCommand` and consumed by
-    # `TypeScanRenderer`. The struct holds per-file paths, accumulated
-    # per-class counts, located fallback events, and any parse errors.
+    # Aggregated report assembled by `TypeScanCommand` and consumed by `TypeScanRenderer`. The struct holds per-file
+    # paths, accumulated per-class counts, located fallback events, and any parse errors.
     class Report < Data.define(
       :files,
       :parse_errors,

data/lib/rigor/cli/upgrade_command.rb

@@ -6,9 +6,8 @@ module Rigor
   class CLI
     # `rigor upgrade` — the ADR-50 WD7 migration command skeleton.
     #
-    # The real body lands when a concrete backwards-compatibility break
-    # gives it a target (e.g. re-running `baseline regenerate` against a
-    # strengthened default profile, surfacing renamed suppression ids,
+    # The real body lands when a concrete backwards-compatibility break gives it a target (e.g. re-running `baseline
+    # regenerate` against a strengthened default profile, surfacing renamed suppression ids,
     # reporting `bleeding_edge:` graduations).  Until then it prints the
     # current version and notes that upgrade is queued.
     class UpgradeCommand < Command

data/lib/rigor/cli.rb

@@ -14,11 +14,9 @@ require_relative "cli/diagnostic_formats"
 require_relative "cli/ci_detector"
 
 module Rigor
-  # The CLI class is a dispatcher: each `run_*` method delegates to a
-  # command-specific class once the command grows beyond a few lines (see
-  # {CLI::TypeOfCommand} and {CLI::CheckCommand}). It necessarily grows by
-  # one delegator + one help line per command, so — like the command
-  # classes it fans out to — it carries an explicit ClassLength exemption.
+  # The CLI class is a dispatcher: each `run_*` method delegates to a command-specific class once the command grows
+  # beyond a few lines (see {CLI::TypeOfCommand} and {CLI::CheckCommand}). It necessarily grows by one delegator + one
+  # help line per command, so — like the command classes it fans out to — it carries an explicit ClassLength exemption.
   class CLI # rubocop:disable Metrics/ClassLength
     EXIT_USAGE = 64
 
@@ -94,11 +92,9 @@ module Rigor
     end
 
     def run_init
-      # Default destination is `.rigor.dist.yml` — the
-      # project-default config that gets committed. Developers
-      # who want a personal override layer create `.rigor.yml`
-      # alongside it (auto-discovery prefers `.rigor.yml` when
-      # both are present; no implicit merge).
+      # Default destination is `.rigor.dist.yml` — the project-default config that gets committed. Developers who want a
+      # personal override layer create `.rigor.yml` alongside it (auto-discovery prefers `.rigor.yml` when both are
+      # present; no implicit merge).
       options = {
         force: false,
         path: ".rigor.dist.yml"
@@ -123,16 +119,11 @@ module Rigor
       0
     end
 
-    # `rigor init`'s template ships empty `plugins:` so a fresh
-    # init has nothing to validate — but the moment the user adds
-    # any plugin entry, the activation-failure surfaces enumerated
-    # in `rigor plugins`'s docstring become real. Point them at
-    # the verification command + the canonical readiness flow so
-    # silent failures (the cwd / Gemfile / signature_paths
-    # mismatches that surfaced during the Mastodon trial) get
-    # caught the first time the user wires a plugin, not the first
-    # time `rigor check` reports false positives that should have
-    # been covered.
+    # `rigor init`'s template ships empty `plugins:` so a fresh init has nothing to validate — but the moment the user
+    # adds any plugin entry, the activation-failure surfaces enumerated in `rigor plugins`'s docstring become real.
+    # Point them at the verification command + the canonical readiness flow so silent failures (the cwd / Gemfile /
+    # signature_paths mismatches that surfaced during the Mastodon trial) get caught the first time the user wires a
+    # plugin, not the first time `rigor check` reports false positives that should have been covered.
     def print_init_next_steps(path)
       @out.puts ""
       @out.puts "Next steps:"
@@ -142,10 +133,8 @@ module Rigor
       @out.puts "  3. Run `rigor check` to analyse your code."
     end
 
-    # Renders the starter `.rigor.yml` body. The template
-    # serialises `Configuration::DEFAULTS` (so the on-disk file
-    # round-trips through `Configuration.load`) and prepends a
-    # short header that points the user at the keys they are
+    # Renders the starter `.rigor.yml` body. The template serialises `Configuration::DEFAULTS` (so the on-disk file
+    # round-trips through `Configuration.load`) and prepends a short header that points the user at the keys they are
     # most likely to want to edit.
     def init_template
       <<~YAML
@@ -291,10 +280,9 @@ module Rigor
       CLI::SkillCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
-    # `rigor describe` — a top-level alias for `rigor skill describe`,
-    # the entry point most users reach for first. Surfaced because a
-    # bare `rigor describe` is the intuitive guess (the onboarding field
-    # trial saw it tried and met "Unknown command").
+    # `rigor describe` — a top-level alias for `rigor skill describe`, the entry point most users reach for first.
+    # Surfaced because a bare `rigor describe` is the intuitive guess (the onboarding field trial saw it tried and met
+    # "Unknown command").
     def run_describe
       require_relative "cli/skill_command"
 

data/lib/rigor/config_audit.rb

@@ -4,30 +4,26 @@ require_relative "signature_path_audit"
 require_relative "analysis/check_rules"
 
 module Rigor
-  # Audits a loaded {Configuration} for the class of mistake where a
-  # configured value silently resolves to nothing — a typo'd or moved
-  # path, an unknown library name, an inert rule id. The shared failure
-  # mode is that the loader filters the bad entry without a word, so the
-  # only symptom is downstream and confusing: missing signatures turn
-  # every call into the types they were meant to cover into a
-  # high-confidence `call.undefined-method`, and an unrecognised
-  # suppression token leaves the rule firing as if the `disable:` line
-  # were never written. This module surfaces each such entry up front so
-  # the cause is visible instead of inferred.
+  # Audits a loaded {Configuration} for the class of mistake where a configured value
+  # silently resolves to nothing — a typo'd or moved path, an unknown library name, an inert
+  # rule id. The shared failure mode is that the loader filters the bad entry without a word,
+  # so the only symptom is downstream and confusing: missing signatures turn every call into
+  # the types they were meant to cover into a high-confidence `call.undefined-method`, and an
+  # unrecognised suppression token leaves the rule firing as if the `disable:` line were
+  # never written. This module surfaces each such entry up front so the cause is visible
+  # instead of inferred.
   #
-  # Every check is held to the same bar that {SignaturePathAudit} set:
-  # it mirrors the loader's own acceptance test, so a warning means the
-  # loader really did load nothing, and it never fires on a setup that
-  # works. In particular the rule-token check only flags a token under a
-  # built-in family (`call`, `flow`, …) — a plugin- or `rbs_extended.*`
-  # rule id (whose family Rigor cannot statically enumerate, since a
-  # `node_rule` block emits any `rule:` string it likes) is left alone, so
-  # disabling a plugin rule is never mistaken for a typo.
+  # Every check is held to the same bar that {SignaturePathAudit} set: it mirrors the
+  # loader's own acceptance test, so a warning means the loader really did load nothing, and
+  # it never fires on a setup that works. In particular the rule-token check only flags a
+  # token under a built-in family (`call`, `flow`, …) — a plugin- or `rbs_extended.*` rule id
+  # (whose family Rigor cannot statically enumerate, since a `node_rule` block emits any
+  # `rule:` string it likes) is left alone, so disabling a plugin rule is never mistaken for
+  # a typo.
   module ConfigAudit
-    # One config-level finding. `kind` discriminates the source key
-    # (`:signature_path`, `:library`, `:disabled_rule`,
-    # `:severity_override`, `:bundler_bundle_path`, `:bundler_lockfile`,
-    # `:rbs_collection_lockfile`); `fields` carries the kind-specific
+    # One config-level finding. `kind` discriminates the source key (`:signature_path`,
+    # `:library`, `:disabled_rule`, `:severity_override`, `:bundler_bundle_path`,
+    # `:bundler_lockfile`, `:rbs_collection_lockfile`); `fields` carries the kind-specific
     # structured data merged into {#to_h} for JSON consumers.
     Warning = Data.define(:kind, :message, :fields) do
       def to_h
@@ -36,9 +32,8 @@ module Rigor
     end
 
     # @param configuration [Rigor::Configuration]
-    # @param project_root [String] the directory the run's relative
-    #   bundler / collection paths resolve against (the CLI's CWD), used
-    #   only by the explicit-path checks.
+    # @param project_root [String] the directory the run's relative bundler / collection
+    #   paths resolve against (the CLI's CWD), used only by the explicit-path checks.
     # @return [Array<Warning>]
     def self.warnings(configuration, project_root: Dir.pwd)
       signature_path_warnings(configuration) +
@@ -47,9 +42,8 @@ module Rigor
         explicit_path_warnings(configuration, project_root)
     end
 
-    # `signature_paths:` entries that resolve to nothing — delegated to
-    # {SignaturePathAudit}, which mirrors the loader's `directory?` +
-    # recursive `**/*.rbs` acceptance test.
+    # `signature_paths:` entries that resolve to nothing — delegated to {SignaturePathAudit},
+    # which mirrors the loader's `directory?` + recursive `**/*.rbs` acceptance test.
     def self.signature_path_warnings(configuration)
       SignaturePathAudit.warnings(configuration.signature_paths).map do |entry|
         Warning.new(
@@ -61,10 +55,9 @@ module Rigor
     end
 
     # `libraries:` entries RBS does not recognise. Uses the same
-    # `RBS::EnvironmentLoader#has_library?` guard the loader filters
-    # through ({Environment::RbsLoader} `build_env_for`), so a flagged
-    # name is exactly one the loader skipped. Fails soft: if RBS itself
-    # raises, no warning rather than a crash.
+    # `RBS::EnvironmentLoader#has_library?` guard the loader filters through
+    # ({Environment::RbsLoader} `build_env_for`), so a flagged name is exactly one the loader
+    # skipped. Fails soft: if RBS itself raises, no warning rather than a crash.
     def self.library_warnings(configuration)
       configured = Array(configuration.libraries)
       return [] if configured.empty?
@@ -81,9 +74,9 @@ module Rigor
       []
     end
 
-    # `disable:` tokens and `severity_overrides:` keys that name no rule.
-    # Restricted to tokens under a built-in family so a plugin rule id is
-    # never mis-flagged (see the module docstring).
+    # `disable:` tokens and `severity_overrides:` keys that name no rule. Restricted to
+    # tokens under a built-in family so a plugin rule id is never mis-flagged (see the module
+    # docstring).
     def self.rule_token_warnings(configuration)
       disable = Array(configuration.disabled_rules).filter_map do |token|
         next unless inert_builtin_token?(token.to_s)
@@ -106,11 +99,10 @@ module Rigor
       disable + overrides
     end
 
-    # True when `token` looks like a built-in rule id but matches none —
-    # its first segment is a built-in family yet it is neither a bare
-    # family wildcard nor a known canonical id. A token whose family is
-    # not built-in (a plugin / `rbs_extended.*` rule, or a bare legacy
-    # alias) is deliberately NOT flagged: it may resolve at run time, so
+    # True when `token` looks like a built-in rule id but matches none — its first segment
+    # is a built-in family yet it is neither a bare family wildcard nor a known canonical id.
+    # A token whose family is not built-in (a plugin / `rbs_extended.*` rule, or a bare
+    # legacy alias) is deliberately NOT flagged: it may resolve at run time, so
     # under-warning is the FP-safe choice.
     def self.inert_builtin_token?(token)
       family = token.split(".").first
@@ -121,10 +113,9 @@ module Rigor
       true
     end
 
-    # Explicitly-configured bundler / rbs-collection paths that do not
-    # exist. Only the explicit form is audited (a nil value means
-    # auto-detection, which finding nothing is normal); messages stay
-    # factual about the path rather than guessing the fallback.
+    # Explicitly-configured bundler / rbs-collection paths that do not exist. Only the
+    # explicit form is audited (a nil value means auto-detection, which finding nothing is
+    # normal); messages stay factual about the path rather than guessing the fallback.
     def self.explicit_path_warnings(configuration, project_root)
       warnings = []
       add_missing_dir(warnings, configuration.bundler_bundle_path, project_root,

data/lib/rigor/configuration/dependencies.rb

@@ -3,62 +3,47 @@
 module Rigor
   class Configuration
     # Parsed `dependencies:` section of `.rigor.yml`. Per
-    # [ADR-10](../../../docs/adr/10-dependency-source-inference.md),
-    # the only nested key today is `source_inference:`, listing
-    # gems whose Ruby implementation Rigor MAY walk during
-    # inference instead of degrading to `Dynamic[top]` at the
-    # dependency boundary.
+    # [ADR-10](../../../docs/adr/10-dependency-source-inference.md), the only nested key today is
+    # `source_inference:`, listing gems whose Ruby implementation Rigor MAY walk during inference instead of
+    # degrading to `Dynamic[top]` at the dependency boundary.
     #
-    # Parser for the `dependencies:` YAML section; consumed by
-    # `Analysis::DependencySourceInference` (ADR-10).
+    # Parser for the `dependencies:` YAML section; consumed by `Analysis::DependencySourceInference` (ADR-10).
     class Dependencies
-      # Walking modes per
-      # [ADR-10 § "Decision"](../../../docs/adr/10-dependency-source-inference.md#decision).
+      # Walking modes per [ADR-10 §
+      # "Decision"](../../../docs/adr/10-dependency-source-inference.md#decision).
       VALID_MODES = %i[disabled when_missing full].freeze
 
-      # Default `roots:` for an entry that does not supply one.
-      # The hard-excluded directories (`spec/` / `test/` / `bin/`
-      # / C extensions) are enforced by the walker, not the
-      # parser — see ADR-10 § "Hard exclusions".
+      # Default `roots:` for an entry that does not supply one. The hard-excluded directories (`spec/` /
+      # `test/` / `bin/` / C extensions) are enforced by the walker, not the parser — see ADR-10 § "Hard
+      # exclusions".
       DEFAULT_ROOTS = %w[lib].freeze
 
-      # Default per-gem catalog cap. ADR-10 slice 4 picks
-      # 5000 method definitions: it covers Rack (~1500),
-      # Faraday (~500), Sidekiq (~800) and other realistic
-      # opt-in targets, while still surfacing a diagnostic for
-      # ActiveSupport-class libraries (~10 000+ methods) where
-      # the user should ship RBS or de-list the gem instead.
+      # Default per-gem catalog cap. ADR-10 slice 4 picks 5000 method definitions: it covers Rack (~1500),
+      # Faraday (~500), Sidekiq (~800) and other realistic opt-in targets, while still surfacing a diagnostic
+      # for ActiveSupport-class libraries (~10 000+ methods) where the user should ship RBS or de-list the gem
+      # instead.
       DEFAULT_BUDGET_PER_GEM = 5000
 
-      # Range bounds per ADR-10 § "Budget interaction"
-      # ("range 0.25× – 4×"). Configured against the default,
+      # Range bounds per ADR-10 § "Budget interaction" ("range 0.25× – 4×"). Configured against the default,
       # this lands at 1250 – 20 000.
       MIN_BUDGET_PER_GEM = (DEFAULT_BUDGET_PER_GEM * 0.25).to_i
       MAX_BUDGET_PER_GEM = (DEFAULT_BUDGET_PER_GEM * 4).to_i
 
       # ADR-10 5b — budget-overrun strategy enum.
       #
-      # - `:walker_cap` (default): the (α) semantics. The
-      #   walker stops harvesting at the cap; methods past the
-      #   cap fall through to the existing user-class fallback
-      #   path. Existing v0.1.3 behaviour.
-      # - `:dependency_silence`: the (β) semantics. Same
-      #   walker behaviour, but the dispatcher additionally
-      #   consults `Index#class_to_gem` after a catalog miss.
-      #   When the receiver's class belongs to a budget-
-      #   exceeded gem, the call resolves to `Dynamic[top]`
-      #   rather than falling through to user-class fallback.
-      #   This silences `call.undefined-method` for unrecorded
-      #   methods at the cost of weaker static checking on
-      #   that gem's surface.
+      # - `:walker_cap` (default): the (α) semantics. The walker stops harvesting at the cap; methods past
+      #   the cap fall through to the existing user-class fallback path. Existing v0.1.3 behaviour.
+      # - `:dependency_silence`: the (β) semantics. Same walker behaviour, but the dispatcher additionally
+      #   consults `Index#class_to_gem` after a catalog miss. When the receiver's class belongs to a
+      #   budget-exceeded gem, the call resolves to `Dynamic[top]` rather than falling through to user-class
+      #   fallback. This silences `call.undefined-method` for unrecorded methods at the cost of weaker static
+      #   checking on that gem's surface.
       VALID_BUDGET_OVERRUN_STRATEGIES = %i[walker_cap dependency_silence].freeze
       DEFAULT_BUDGET_OVERRUN_STRATEGY = :walker_cap
 
-      # Frozen value object describing a single per-gem opt-in.
-      # `gem:` is the gem name (matched against the bundle at
-      # walk time); `mode:` is one of {VALID_MODES}; `roots:` is
-      # the list of subdirectories within the gem's installation
-      # directory to walk (defaults to `["lib"]`).
+      # Frozen value object describing a single per-gem opt-in. `gem:` is the gem name (matched against the
+      # bundle at walk time); `mode:` is one of {VALID_MODES}; `roots:` is the list of subdirectories within
+      # the gem's installation directory to walk (defaults to `["lib"]`).
       class Entry < Data.define(:gem, :mode, :roots)
         def disabled? = mode == :disabled
         def when_missing? = mode == :when_missing
@@ -67,10 +52,8 @@ module Rigor
 
       attr_reader :source_inference, :budget_per_gem, :budget_overrun_strategy, :warnings
 
-      # Parse the YAML-shaped `dependencies:` value into a
-      # frozen {Dependencies}. Accepts `nil` / `{}` / a Hash with
-      # `source_inference:` and / or `budget_per_gem:` /
-      # `budget_overrun_strategy:` present.
+      # Parse the YAML-shaped `dependencies:` value into a frozen {Dependencies}. Accepts `nil` / `{}` / a
+      # Hash with `source_inference:` and / or `budget_per_gem:` / `budget_overrun_strategy:` present.
       def self.from_h(data)
         return new([]) if data.nil?
         raise ArgumentError, "dependencies: must be a Hash, got #{data.inspect}" unless data.is_a?(Hash)
@@ -110,25 +93,17 @@ module Rigor
       def empty? = @source_inference.empty?
 
       class << self
-        # ADR-10 § "config-conflict diagnostic" — merges a
-        # potentially-duplicated entry list (the `includes:`
-        # chain produces concatenated arrays via
-        # `Configuration.deep_merge`'s special-case for
-        # `dependencies.source_inference`) into a single
-        # canonical entry per gem name. The merge rules:
+        # ADR-10 § "config-conflict diagnostic" — merges a potentially-duplicated entry list (the `includes:`
+        # chain produces concatenated arrays via `Configuration.deep_merge`'s special-case for
+        # `dependencies.source_inference`) into a single canonical entry per gem name. The merge rules:
         #
-        # - Same gem, same all fields → idempotent collapse
-        #   (no warning).
-        # - Same gem, different `mode:` → keep the LAST entry
-        #   (matches existing right-wins semantics elsewhere)
-        #   AND emit a `:warning` so the user knows their
-        #   `includes:` chain is ambiguous.
-        # - Same gem, different `roots:` → union the roots
-        #   silently (no warning). The walker is happy to
+        # - Same gem, same all fields → idempotent collapse (no warning).
+        # - Same gem, different `mode:` → keep the LAST entry (matches existing right-wins semantics
+        #   elsewhere) AND emit a `:warning` so the user knows their `includes:` chain is ambiguous.
+        # - Same gem, different `roots:` → union the roots silently (no warning). The walker is happy to
         #   visit the union.
         #
-        # Returns `[entries, warnings]` so the caller can
-        # plumb the warning list through to the Runner for
+        # Returns `[entries, warnings]` so the caller can plumb the warning list through to the Runner for
         # diagnostic emission.
         def dedupe_entries(entries)
           warnings = []
@@ -156,11 +131,10 @@ module Rigor
 
         private
 
-        # `source_inference:` is a list of per-gem entries, or `false` /
-        # omitted to disable it (the default). Guard the Ruby
-        # `Array(false) == [false]` quirk that would otherwise feed `false`
-        # straight into coerce_entry and crash the whole run on a perfectly
-        # reasonable "off" config (`dependencies: { source_inference: false }`).
+        # `source_inference:` is a list of per-gem entries, or `false` / omitted to disable it (the default).
+        # Guard the Ruby `Array(false) == [false]` quirk that would otherwise feed `false` straight into
+        # coerce_entry and crash the whole run on a perfectly reasonable "off" config
+        # (`dependencies: { source_inference: false }`).
         def coerce_source_inference(value)
           return [] if value.nil? || value == false
 
@@ -222,12 +196,9 @@ module Rigor
                 "#{VALID_BUDGET_OVERRUN_STRATEGIES.inspect}, got #{value.inspect}"
         end
 
-        # ADR-10 slice 4. Per-gem catalog cap is mandatory
-        # (the parser supplies the default before this is
-        # called, so `nil` only reaches here on an explicit
-        # `budget_per_gem: ~`). Range bounds match
-        # MIN_BUDGET_PER_GEM .. MAX_BUDGET_PER_GEM
-        # (i.e. 0.25× – 4× of the default).
+        # ADR-10 slice 4. Per-gem catalog cap is mandatory (the parser supplies the default before this is
+        # called, so `nil` only reaches here on an explicit `budget_per_gem: ~`). Range bounds match
+        # MIN_BUDGET_PER_GEM .. MAX_BUDGET_PER_GEM (i.e. 0.25× – 4× of the default).
         def coerce_budget_per_gem(value)
           unless value.is_a?(Integer)
             raise ArgumentError,