rigortype 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97d286eb15708fc212260925d407b48926a331798f0d2f210321b1d3c66cda55
-  data.tar.gz: 9fadaf2c31394c142dd15b335dbf740774ceabff8ce85b8a79fcd7faa26ea4fa
+  metadata.gz: d38773edf003d6de8ea6ec3de2f19aac4c2d74e404c56f39d1ed9595f388a648
+  data.tar.gz: beb2b7aea30bf74f4cc8d22e66d441d63ecb906689d6a22c6ca647a7a087a719
 SHA512:
-  metadata.gz: 1b800eb64d10fdef9039ed429f5740f672cdf0811de86c1cac1434b6bb5a0c820df68d8d8b01aa03ed0cab518d18a6e51af12d608cf6ad50556e4b653a4d3ed6
-  data.tar.gz: 5bee1c072412f7eac14d0c96314f8efe2473cd46efe9763e238bd3c345605deb29055db3601c52909c430d419d8821fc7befb51fe0f5211b8fbb94e379a5d635
+  metadata.gz: 1c33b18e310c956f9cc9bbd4806228a095bcf95a137efba50affd49ffca17decac9107006e4a7fd350a9783f289e7d9e336ebc99755e7d69ce321d60b21c731b
+  data.tar.gz: c9f7286bc00f3419083ced2e35678062e8508dfe03b6064fe6c9f4cf4ad752479ca8801cce059cb3fc6bc0ee0eaaa216824a9d43cc93332feb7e267ab988253c

data/README.md

@@ -231,9 +231,10 @@ rigor docs --list                 # list every bundled page
 
 ## Status
 
-Current release: **`v0.2.0`** (2026-06-17) — the first
-publicly-announced (general / evaluation) release. It publishes an
-enumerated [compatibility surface](docs/compatibility.md) as a
+Current release: **`v0.2.8`** (2026-07-06) — the latest cut on the
+`0.2.x` evaluation line opened by `v0.2.0`, the first
+publicly-announced (general / evaluation) release. The line publishes
+an enumerated [compatibility surface](docs/compatibility.md) as a
 minor-non-break trial, rehearsing the contract that hard-freezes at
 `v1.0.0`. Rigor analyses real Ruby today: it has been hardened against
 Mastodon, Redmine, and GitLab FOSS, and the deliberately conservative

data/docs/manual/02-cli-reference.md

@@ -452,13 +452,14 @@ The positional slot is a skill *name*; alternative outputs are flags,
 so a skill can never be shadowed by a verb.
 
 ```sh
-rigor skill [<name>] [--path <name>] [--list] [--describe]
+rigor skill [<name>] [--full <name>] [--path <name>] [--list] [--describe]
 ```
 
 | Form | Purpose |
 | --- | --- |
 | (none) / `--list` | Table of every bundled skill (name + absolute path). |
 | `<name>` | Print the `SKILL.md` body to stdout, with a header pointing at the skill's `references/` directory. |
+| `--full <name>` | Print the `SKILL.md` body **followed by every `references/*.md` inline** — the complete, version-current procedure in one call. This is what a skill's "First: load the version-current copy" directive points at, so a copy vendored into a project (e.g. via `npx skills add`) re-fetches its current steps from the installed gem instead of following a frozen copy. |
 | `--path <name>` | Print the single-line absolute `SKILL.md` path, suitable as input to a file-reading tool. |
 | `--describe` | Probe the project's state (config / baseline / `sig/` / CI — presence only, never runs `rigor check`) and recommend the next skill to run. Also spelled `describe`; surfaced top-level as [`rigor describe`](#rigor-describe) below. |
 

data/docs/manual/04-diagnostics.md

@@ -20,16 +20,19 @@ Every rule has a two-segment `family.rule` identifier:
 | `dump` | `dump_type` notices. |
 
 `rigor explain <rule>` prints the full catalogue entry for any
-ID; `rigor explain` with no argument lists them all.
+built-in rule ID; `rigor explain` with no argument lists them all.
 
 ### Catalogue
 
-Each rule has a stable per-rule anchor on this page
+Each built-in rule has a stable per-rule anchor on this page
 (`#rule-<family>-<name>`, dots written as dashes) — the
 `documentation_url` field in `--format json` and `rigor explain`'s
 `Documentation:` line both point here. The `Evidence` column is
 Rigor's confidence that a firing is a true positive (see
-[Evidence tier](#evidence-tier) below).
+[Evidence tier](#evidence-tier) below). The one exception is
+`rbs_extended.unsatisfied-conformance`, an `rbs_extended`-family rule
+rather than a built-in: `rigor explain` does not resolve it and it
+carries no `documentation_url`.
 
 | Rule | Fires when | Evidence |
 | --- | --- | --- |
@@ -86,7 +89,7 @@ re-stamps it for the run. Three profiles, set with the
 | --- | --- |
 | `lenient` | Only proven diagnostics are errors; uncertain ones drop to `warning` / `info`. For incremental adoption on legacy code. |
 | `balanced` *(default)* | Most rules `error`; `dump.type` `info`; uncertain rules `warning`. |
-| `strict` | Every rule is an `error`. CI-friendly. |
+| `strict` | Nearly every rule is an `error` — the exceptions are `call.self-undefined-method` (stays `off`, opt-in only) and `flow.unreachable-clause` (`warning`, pending its false-positive gate). CI-friendly. |
 
 For finer control, `severity_overrides:` maps a rule ID or a
 family to one of `error`, `warning`, `info`, or `off`:

data/docs/manual/06-baseline.md

@@ -112,5 +112,8 @@ baseline regenerate` to shrink the file. The
 [`rigor-baseline-reduce` skill](08-skills.md) walks this loop
 interactively.
 
-To make CI fail when the baseline *grows*, add
-`--baseline-strict` to `rigor check`.
+To make CI fail on *any* baseline drift, add `--baseline-strict`
+to `rigor check`. It fails not only when a bucket grows past its
+recorded count (excess drift, which the surfaced diagnostics already
+fail on) but also when the code has *shrunk* below it (deficit drift:
+the baseline is now looser than the code and should be regenerated).

data/docs/manual/08-skills.md

@@ -108,6 +108,7 @@ source checkout. The `rigor skill` command surfaces them:
 rigor skill describe        # probe the project + recommend the next skill (alias: rigor describe)
 rigor skill --list          # name + absolute path for each bundled skill
 rigor skill <name>          # print the SKILL.md body (with a references/ header)
+rigor skill --full <name>   # the body + every references/*.md inline (complete procedure)
 rigor skill --path <name>   # one-line absolute SKILL.md path, for a file-reading tool
 ```
 
@@ -133,6 +134,26 @@ npx skills add rigortype/rigor
 (The contributor-only skills under `.claude/skills/` are marked internal
 and are not installed by a bulk `npx skills add`.)
 
+### Keeping installed skills current
+
+A skill copied into your project this way is **frozen at install time**,
+while Rigor keeps evolving — flags, config keys, and rule ids move release
+to release. To keep that from going stale (陳腐化), every skill opens with
+a **"First: load the version-current copy"** directive: before following
+its steps, an agent re-fetches the authoritative body from the *installed*
+Rigor with
+
+```sh
+rigor skill --full <name>   # the current body + all its references/, in one call
+```
+
+Because the vendored copy is fixed at install time but `rigor skill` always
+reads the gem, the two diverge as you upgrade, and the directive makes the
+agent prefer the gem's current version. You therefore do **not** need to
+re-install the skills after upgrading Rigor — only the thin entry point
+(`rigor-next-steps`) needs to work before Rigor exists; everything
+version-specific is served live by the installed binary.
+
 ## Running a skill
 
 In an agent that supports Agent Skills, invoke the skill by name (in

data/docs/manual/15-type-protection-coverage.md

@@ -181,8 +181,8 @@ entry carries two fields:
 
 - **`dynamic_origin`** — the cause the value became dynamic:
   `external_gem_without_rbs`, `framework_dsl_boundary`,
-  `analyzer_budget_cutoff`, `explicit_untyped`, or
-  `unsupported_syntax`.
+  `analyzer_budget_cutoff`, `explicit_untyped`,
+  `inferred_return_untyped`, or `unsupported_syntax`.
 - **`tractability`** — the action axis derived from that cause:
   - **`add_rbs`** — you can close it with a type: install RBS
     (`rbs collection install`), enable `dependencies.source_inference:`,
@@ -190,8 +190,10 @@ entry carries two fields:
   - **`enable_plugin`** — a framework / DSL boundary; reach for a
     plugin or [`pre_eval:`](03-configuration.md), not a hand-written
     type.
-  - **`engine_gap`** — not closable by a user type (a budget cutoff
-    or a construct Rigor does not yet model); report it.
+  - **`engine_gap`** — not closable by a user type: a budget cutoff,
+    an inference gap (an untyped parameter or an unbound instance
+    variable — `inferred_return_untyped`), or a construct Rigor does
+    not yet model; report it.
 
 The text report prints a one-line `by tractability:` breakdown under
 the "Add a type here" header, and the JSON carries the same totals as

data/lib/rigor/analysis/baseline.rb

@@ -6,9 +6,8 @@ module Rigor
   module Analysis
     # ADR-22 Slice 1 — PHPStan-shaped per-project baseline.
     #
-    # Loads `.rigor-baseline.yml`, filters a current run's
-    # diagnostic stream against the recorded buckets, and emits
-    # an `(surfaced, silenced_count)` pair for the CLI to render.
+    # Loads `.rigor-baseline.yml`, filters a current run's diagnostic stream against the recorded buckets, and
+    # emits an `(surfaced, silenced_count)` pair for the CLI to render.
     #
     # Two row shapes are accepted (WD1):
     #
@@ -27,17 +26,13 @@ module Rigor
     # ## Semantics per (file, rule [, message]) bucket (WD4)
     #
     #   actual <= count    → ALL diagnostics in the bucket are silenced.
-    #   actual >  count    → ALL diagnostics in the bucket surface
-    #                        (not just the excess delta — the bucket
-    #                        has crossed its threshold; the team's
-    #                        review focus shifts from "which N is new"
-    #                        to "what's going on with this rule in
-    #                        this file as a whole").
+    #   actual >  count    → ALL diagnostics in the bucket surface (not just the excess delta — the bucket has
+    #                        crossed its threshold; the team's review focus shifts from "which N is new" to
+    #                        "what's going on with this rule in this file as a whole").
     #
     # ## Filter pipeline position (WD6)
     #
-    # The baseline filter runs LAST among the diagnostic-suppression
-    # layers:
+    # The baseline filter runs LAST among the diagnostic-suppression layers:
     #
     #   emit →  `# rigor:disable` (per-line)
     #        →  `# rigor:disable-file`
@@ -47,41 +42,32 @@ module Rigor
     #
     # ## Loading (WD2 (b))
     #
-    # `Baseline.load` is called by the CLI when it has resolved
-    # an explicit baseline path (from `--baseline=PATH` on the
-    # CLI or `baseline: <path>` in `.rigor.yml`). The presence
-    # of `.rigor-baseline.yml` on disk alone never triggers a
-    # load — that's the CLI / Configuration's job to enforce.
+    # `Baseline.load` is called by the CLI when it has resolved an explicit baseline path (from `--baseline=PATH`
+    # on the CLI or `baseline: <path>` in `.rigor.yml`). The presence of `.rigor-baseline.yml` on disk alone
+    # never triggers a load — that's the CLI / Configuration's job to enforce.
     #
     # ## Path handling
     #
-    # Baselines store file paths **relative to the project root**
-    # (the working directory when `rigor` is run). This makes the
-    # generated `.rigor-baseline.yml` portable across machines and
-    # checkout locations. When filtering a live diagnostic stream,
-    # the instance normalises each diagnostic's absolute path to a
-    # relative one before the bucket lookup.
+    # Baselines store file paths **relative to the project root** (the working directory when `rigor` is run).
+    # This makes the generated `.rigor-baseline.yml` portable across machines and checkout locations. When
+    # filtering a live diagnostic stream, the instance normalises each diagnostic's absolute path to a relative
+    # one before the bucket lookup.
     class Baseline
-      # The bucket key is intentionally tuple-shaped so rule-ID
-      # rows and message-pattern rows can coexist in a single
-      # multimap. `message` is `nil` for rule-ID rows; a Regexp
-      # for message-pattern rows.
-      # `count` shadows Struct#count; intentional — `count` is the
-      # PHPStan-compatible field name and we don't use the
-      # Enumerable-style `Struct#count` on Bucket instances.
+      # The bucket key is intentionally tuple-shaped so rule-ID rows and message-pattern rows can coexist in a
+      # single multimap. `message` is `nil` for rule-ID rows; a Regexp for message-pattern rows.
+      # `count` shadows Struct#count; intentional — `count` is the PHPStan-compatible field name and we don't
+      # use the Enumerable-style `Struct#count` on Bucket instances.
       Bucket = Struct.new(:file, :rule, :message_regex, :count, keyword_init: true) # rubocop:disable Lint/StructNewOverride
 
       CURRENT_VERSION = 1
 
       class << self
-        # Load a baseline file from disk. Returns `nil` when the
-        # path is nil (the caller's "no baseline configured"
-        # state). Raises {LoadError} on malformed content;
-        # callers translate to a user-facing diagnostic.
+        # Load a baseline file from disk. Returns `nil` when the path is nil (the caller's "no baseline
+        # configured" state). Raises {LoadError} on malformed content; callers translate to a user-facing
+        # diagnostic.
         #
-        # `project_root:` is the working directory against which
-        # stored relative paths are resolved during filtering.
-        # Defaults to `Dir.pwd`.
+        # `project_root:` is the working directory against which stored relative paths are resolved during
+        # filtering. Defaults to `Dir.pwd`.
         def load(path, project_root: Dir.pwd)
           return nil if path.nil?
           return new([], project_root: project_root) unless File.exist?(path)
@@ -90,15 +76,12 @@ module Rigor
           parse_loaded(raw, path: path, project_root: project_root)
         end
 
-        # Build a baseline from a current run's diagnostic stream.
-        # `match_mode:` is `:rule` (default) or `:message`. The
-        # message-mode generator passes literal messages through
-        # `Regexp.escape` so generated rows never accidentally
-        # over-match on punctuation.
+        # Build a baseline from a current run's diagnostic stream. `match_mode:` is `:rule` (default) or
+        # `:message`. The message-mode generator passes literal messages through `Regexp.escape` so generated
+        # rows never accidentally over-match on punctuation.
         #
-        # `project_root:` is used to convert absolute diagnostic
-        # paths to relative paths in the generated YAML. Defaults
-        # to `Dir.pwd`.
+        # `project_root:` is used to convert absolute diagnostic paths to relative paths in the generated YAML.
+        # Defaults to `Dir.pwd`.
         def from_diagnostics(diagnostics, match_mode: :rule, project_root: Dir.pwd)
           raise ArgumentError, "match_mode must be :rule or :message" unless %i[rule message].include?(match_mode)
 
@@ -177,11 +160,9 @@ module Rigor
           end
         end
 
-        # Generates a Regexp source string for the baseline row.
-        # The string is `Regexp.escape`d so the YAML round-trip
-        # produces a regex that matches the literal message.
-        # Users hand-editing the row can replace the escaped
-        # form with a pattern.
+        # Generates a Regexp source string for the baseline row. The string is `Regexp.escape`d so the YAML
+        # round-trip produces a regex that matches the literal message. Users hand-editing the row can replace
+        # the escaped form with a pattern.
         def message_pattern_for(message)
           Regexp.new(Regexp.escape(message.to_s))
         end
@@ -203,10 +184,8 @@ module Rigor
         # For each (file, qualified_rule) pair, two arrays:
         # - rule-ID rows (message_regex == nil)
         # - message-pattern rows (message_regex != nil)
-        # The matcher walks message-pattern rows first (tighter
-        # match takes precedence); diagnostics that don't match
-        # any message row fall through to the rule-ID row if
-        # one exists.
+        # The matcher walks message-pattern rows first (tighter match takes precedence); diagnostics that
+        # don't match any message row fall through to the rule-ID row if one exists.
         @by_pair = buckets.group_by { |b| [b.file, b.rule] }.freeze
         freeze
       end
@@ -214,10 +193,8 @@ module Rigor
       # Apply the baseline filter to a diagnostic stream.
       #
       # Returns a 2-tuple:
-      # - `surfaced` — the diagnostics that survived the filter
-      #   (new findings + entire over-threshold buckets).
-      # - `silenced_count` — how many diagnostics the baseline
-      #   suppressed (for the WD7 stderr summary line).
+      # - `surfaced` — the diagnostics that survived the filter (new findings + entire over-threshold buckets).
+      # - `silenced_count` — how many diagnostics the baseline suppressed (for the WD7 stderr summary line).
       def filter(diagnostics)
         return [diagnostics, 0] if buckets.empty?
 
@@ -228,10 +205,8 @@ module Rigor
         grouped.each_value do |entries|
           bucket = entries[:bucket]
           diags = entries[:diagnostics]
-          # No matching bucket → all surface as new findings.
-          # `actual <= count` → all silenced (within threshold,
-          # WD4). `actual >  count` → all surface (over
-          # threshold, WD4).
+          # No matching bucket → all surface as new findings. `actual <= count` → all silenced (within
+          # threshold, WD4). `actual >  count` → all surface (over threshold, WD4).
           if bucket && diags.size <= bucket.count
             silenced_count += diags.size
           else
@@ -239,39 +214,31 @@ module Rigor
           end
         end
 
-        # Diagnostics that lacked a rule or a path bypass the
-        # baseline entirely (the baseline can't address them).
+        # Diagnostics that lacked a rule or a path bypass the baseline entirely (the baseline can't address
+        # them).
         unkeyable = diagnostics.reject { |d| d.qualified_rule && d.path }
         [surfaced + unkeyable, silenced_count]
       end
 
-      # A single bucket's drift state for slice 2 inspection.
-      # `status` is one of:
+      # A single bucket's drift state for slice 2 inspection. `status` is one of:
       #
       # - `:within`    — `actual <= count` (silenced by the filter).
-      # - `:over`      — `actual > count` (over threshold; surfaced
-      #                  in the regular `rigor check` output).
+      # - `:over`      — `actual > count` (over threshold; surfaced in the regular `rigor check` output).
       # - `:cleared`   — `actual == 0` (the bucket can be pruned).
-      # - `:reducible` — `0 < actual < count` (the bucket's count
-      #                  can be tightened; future `regenerate`
-      #                  slice 5 handles this).
+      # - `:reducible` — `0 < actual < count` (the bucket's count can be tightened; future `regenerate` slice 5
+      #                  handles this).
       DriftRow = Struct.new(:bucket, :actual_count, :status, keyword_init: true) do
         def delta
           actual_count - bucket.count
         end
       end
 
-      # Walk the current diagnostic stream and report
-      # bucket-level drift. Each baseline bucket becomes one
-      # DriftRow regardless of whether the current run still
-      # matches it.
+      # Walk the current diagnostic stream and report bucket-level drift. Each baseline bucket becomes one
+      # DriftRow regardless of whether the current run still matches it.
       #
-      # @param diagnostics [Array<Diagnostic>] current run's
-      #   diagnostic stream (PRE-filter — pass the raw
-      #   `result.diagnostics` from `Runner#run`, not the
-      #   post-baseline surface).
-      # @return [Array<DriftRow>] one entry per baseline bucket,
-      #   in baseline-file order.
+      # @param diagnostics [Array<Diagnostic>] current run's diagnostic stream (PRE-filter — pass the raw
+      #   `result.diagnostics` from `Runner#run`, not the post-baseline surface).
+      # @return [Array<DriftRow>] one entry per baseline bucket, in baseline-file order.
       def audit(diagnostics)
         counts = Hash.new(0)
         diagnostics.each do |diag|
@@ -287,18 +254,15 @@ module Rigor
         end
       end
 
-      # Returns a new Baseline with the given buckets dropped.
-      # Used by `rigor baseline prune` (slice 2) to remove
-      # cleared buckets (`actual == 0`) from the on-disk file.
+      # Returns a new Baseline with the given buckets dropped. Used by `rigor baseline prune` (slice 2) to
+      # remove cleared buckets (`actual == 0`) from the on-disk file.
       def without(buckets_to_drop)
         dropset = buckets_to_drop.to_set
         self.class.new(buckets.reject { |b| dropset.include?(b) }, project_root: @project_root)
       end
 
-      # Serialise to a YAML string. The generator path writes
-      # this through `File.write`; the dump format is stable
-      # across versions of this class as long as the bucket
-      # shape is unchanged.
+      # Serialise to a YAML string. The generator path writes this through `File.write`; the dump format is
+      # stable across versions of this class as long as the bucket shape is unchanged.
       def to_yaml
         rows = buckets.map do |bucket|
           row = { "file" => bucket.file, "rule" => bucket.rule }
@@ -311,8 +275,7 @@ module Rigor
         YAML.dump(document)
       end
 
-      # The number of buckets recorded. Useful for the CLI
-      # summary on `generate`.
+      # The number of buckets recorded. Useful for the CLI summary on `generate`.
       def size
         buckets.size
       end
@@ -344,11 +307,9 @@ module Rigor
       end
 
       def group_diagnostics_for_filtering(diagnostics)
-        # First pass: bin each diagnostic into the bucket that
-        # claims it. Message-pattern rows take precedence over
-        # rule-ID rows because they're more specific. A
-        # diagnostic that matches no row goes into a synthetic
-        # "no-bucket" bin keyed by (file, rule).
+        # First pass: bin each diagnostic into the bucket that claims it. Message-pattern rows take precedence
+        # over rule-ID rows because they're more specific. A diagnostic that matches no row goes into a
+        # synthetic "no-bucket" bin keyed by (file, rule).
         bins = {}
         diagnostics.each do |diag|
           next if diag.qualified_rule.nil? || diag.path.nil?
@@ -370,8 +331,7 @@ module Rigor
         candidates = @by_pair[[normalize_path(diagnostic.path), diagnostic.qualified_rule]]
         return nil if candidates.nil? || candidates.empty?
 
-        # Tighter (message-pattern) buckets first, then the
-        # rule-ID bucket as fallback.
+        # Tighter (message-pattern) buckets first, then the rule-ID bucket as fallback.
         message_buckets, rule_buckets = candidates.partition(&:message_regex)
         message_buckets.each do |b|
           return b if b.message_regex.match?(diagnostic.message.to_s)

data/lib/rigor/analysis/buffer_binding.rb

@@ -2,32 +2,25 @@
 
 module Rigor
   module Analysis
-    # Binds one logical project path (the path the user is editing,
-    # e.g. `lib/foo.rb`) to a physical file containing the in-flight
-    # buffer bytes (e.g. `/tmp/9539itfeh2.rb`). When the runner /
-    # workers / pre-passes need to read source for the logical path,
-    # they read from the physical path instead; when they emit a
-    # `Diagnostic`, the path is the logical one so editors highlight
-    # the buffer the user is actually looking at.
+    # Binds one logical project path (the path the user is editing, e.g. `lib/foo.rb`) to a physical file
+    # containing the in-flight buffer bytes (e.g. `/tmp/9539itfeh2.rb`). When the runner / workers / pre-passes
+    # need to read source for the logical path, they read from the physical path instead; when they emit a
+    # `Diagnostic`, the path is the logical one so editors highlight the buffer the user is actually looking at.
     #
-    # See `docs/design/20260516-editor-mode.md` for the design.
-    # The CLI surfaces this through paired `--tmp-file` /
-    # `--instead-of` flags on `rigor check` and `rigor type-of`;
-    # programmatic callers pass a `BufferBinding` to `Runner.new`.
+    # See `docs/design/20260516-editor-mode.md` for the design. The CLI surfaces this through paired
+    # `--tmp-file` / `--instead-of` flags on `rigor check` and `rigor type-of`; programmatic callers pass a
+    # `BufferBinding` to `Runner.new`.
     BufferBinding = Data.define(:logical_path, :physical_path) do
-      # Returns the physical path to read bytes from when the caller
-      # is about to parse `path`. For non-logical paths returns the
-      # input unchanged. Cheap to call on every path; the binding is
-      # singular today (one buffer per run).
+      # Returns the physical path to read bytes from when the caller is about to parse `path`. For non-logical
+      # paths returns the input unchanged. Cheap to call on every path; the binding is singular today (one
+      # buffer per run).
       def resolve(path)
         path == logical_path ? physical_path : path
       end
 
-      # Returns the path the caller should report in user-facing
-      # output (diagnostics, run stats) when it currently holds the
-      # physical path. The inverse of `#resolve`. Non-physical paths
-      # pass through unchanged, so it is safe to stamp every
-      # outgoing path through this helper.
+      # Returns the path the caller should report in user-facing output (diagnostics, run stats) when it
+      # currently holds the physical path. The inverse of `#resolve`. Non-physical paths pass through
+      # unchanged, so it is safe to stamp every outgoing path through this helper.
       def display_path(path)
         path == physical_path ? logical_path : path
       end

data/lib/rigor/analysis/check_rules/always_truthy_condition_collector.rb

@@ -5,44 +5,29 @@ require "prism"
 module Rigor
   module Analysis
     module CheckRules
-      # Walks a parse tree and collects every `IfNode` / `UnlessNode`
-      # whose predicate folds to a `Type::Constant` AND is NOT
-      # disqualified by the rule's conservative envelope.
+      # Walks a parse tree and collects every `IfNode` / `UnlessNode` whose predicate folds to a
+      # `Type::Constant` AND is NOT disqualified by the rule's conservative envelope.
       #
-      # The companion rule (`flow.always-truthy-condition`) is
-      # the inferred-constant counterpart to
-      # `flow.unreachable-branch` (which only fires on syntactic
-      # literals). The literal-only rule was the v0.1.2 first-cut
-      # because Rigor's incomplete loop / mutation / RBS-strictness
-      # modelling produces inferred constants that look real but
-      # are pragmatically false-positives. This collector adds two
-      # surgical skips to bring the inferred-constant case in
-      # without resurfacing those false positives:
+      # The companion rule (`flow.always-truthy-condition`) is the inferred-constant counterpart to
+      # `flow.unreachable-branch` (which only fires on syntactic literals). The literal-only rule was the
+      # v0.1.2 first-cut because Rigor's incomplete loop / mutation / RBS-strictness modelling produces
+      # inferred constants that look real but are pragmatically false-positives. This collector adds two
+      # surgical skips to bring the inferred-constant case in without resurfacing those false positives:
       #
-      # - **Inside a loop / block**: predicates nested inside
-      #   `WhileNode` / `UntilNode` / `ForNode` / `BlockNode`
-      #   ancestors. Mutation tracking through loop bodies is
-      #   incomplete (`shift = 0; loop { shift += 7 }` keeps
-      #   `shift` at `Constant<7>` per the analyzer), so a
-      #   `Constant<bool>` predicate inside the loop body is
-      #   suspect.
-      # - **Defensive predicate calls**: `.nil?` / `.empty?` /
-      #   `.zero?` / `.any?` / `.none?` / `.all?`. These read
-      #   like the user explicitly checking for a runtime
-      #   condition that the type system already proves can't
-      #   happen — Rigor's strict-on-returns RBS often disagrees
-      #   with the user's defensive check (e.g. `Module#name`
-      #   returns `String` per RBS but anonymous classes really
-      #   do return `nil`). Skipping these forms keeps the rule
-      #   useful for genuine logic errors without faulting
-      #   defensive code.
+      # - **Inside a loop / block**: predicates nested inside `WhileNode` / `UntilNode` / `ForNode` /
+      #   `BlockNode` ancestors. Mutation tracking through loop bodies is incomplete (`shift = 0; loop {
+      #   shift += 7 }` keeps `shift` at `Constant<7>` per the analyzer), so a `Constant<bool>` predicate
+      #   inside the loop body is suspect.
+      # - **Defensive predicate calls**: `.nil?` / `.empty?` / `.zero?` / `.any?` / `.none?` / `.all?`. These
+      #   read like the user explicitly checking for a runtime condition that the type system already proves
+      #   can't happen — Rigor's strict-on-returns RBS often disagrees with the user's defensive check (e.g.
+      #   `Module#name` returns `String` per RBS but anonymous classes really do return `nil`). Skipping
+      #   these forms keeps the rule useful for genuine logic errors without faulting defensive code.
       #
-      # Also skipped (so the literal-only `unreachable-branch`
-      # rule doesn't double-fire alongside this one):
+      # Also skipped (so the literal-only `unreachable-branch` rule doesn't double-fire alongside this one):
       #
-      # - Predicates whose direct AST shape is a literal
-      #   (`TrueNode` / `FalseNode` / `NilNode` / numeric / string
-      #   / symbol / regexp).
+      # - Predicates whose direct AST shape is a literal (`TrueNode` / `FalseNode` / `NilNode` / numeric /
+      #   string / symbol / regexp).
       class AlwaysTruthyConditionCollector
         DEFENSIVE_PREDICATES = %i[nil? empty? zero? any? none? all? respond_to?].freeze
         LOOP_OR_BLOCK_NODE_CLASSES = [
@@ -56,34 +41,30 @@ module Rigor
 
         Result = Data.define(:node, :polarity)
 
-        # ADR-53 Track B — the node classes the shared {RuleWalk}
-        # dispatches to this collector, and the context gate under which
-        # the walk suppresses it (loop / block bodies — see the envelope
-        # above). The legacy walk's `!in_loop_or_block` guard is now the
-        # walk's `:loop_or_block` gate, applied before `#visit`.
+        # ADR-53 Track B — the node classes the shared {RuleWalk} dispatches to this collector, and the
+        # context gate under which the walk suppresses it (loop / block bodies — see the envelope above). The
+        # legacy walk's `!in_loop_or_block` guard is now the walk's `:loop_or_block` gate, applied before
+        # `#visit`.
         NODE_CLASSES = [Prism::IfNode, Prism::UnlessNode].freeze
         RULE_WALK_GATES = [:loop_or_block].freeze
 
-        # @return [Array<Result>] one entry per qualifying
-        #   predicate. Empty when the tree carries no firing
+        # @return [Array<Result>] one entry per qualifying predicate. Empty when the tree carries no firing
         #   predicates.
         def initialize(scope_index)
           @scope_index = scope_index
           @results = []
         end
 
-        # Legacy single-collector walk — kept as the oracle the
-        # ADR-53 Track B equivalence harness compares {RuleWalk}
-        # against; deleted when Track B completes.
+        # Legacy single-collector walk — kept as the oracle the ADR-53 Track B equivalence harness compares
+        # {RuleWalk} against; deleted when Track B completes.
         def collect(root)
           walk(root, in_loop_or_block: false)
           @results.freeze
         end
 
-        # {RuleWalk} entry point: the per-node logic of the legacy walk,
-        # invoked under the same traversal contract. The `context` is
-        # unused — the loop / block suppression this collector relied on
-        # is the walk's `:loop_or_block` gate now.
+        # {RuleWalk} entry point: the per-node logic of the legacy walk, invoked under the same traversal
+        # contract. The `context` is unused — the loop / block suppression this collector relied on is the
+        # walk's `:loop_or_block` gate now.
         def visit(node, _context = nil)
           collect_predicate(node)
         end