rigortype 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc7f03a32a104c1c3ed00374974fc9af408c84e1c4d19dbb9ad8dc863f0ea0c4
-  data.tar.gz: 6c7f1fd0b81526c436731ac6c4710c0937bd00043570b6db5e9d59d6973f7872
+  metadata.gz: b2709c0d68fc616109c3300013f08fda3702484c6ca01ff67b4ccf9d0f354ad0
+  data.tar.gz: 77486c048ef9cd94a725b5ebb09ae4e161003b37f67919c769845ed36f6c60bf
 SHA512:
-  metadata.gz: 492d3d04d9bce6672ad46885d2eda1234d4f4a30f41b3168244f794754f37fa1a3d0edfc88e425fc2b0582dd09b5f45afee312189c2099c8101140db798eec0a
-  data.tar.gz: 8fd06bd7e9af340ba29019c84bd913934c77b094987e5c52be131351bc60c52e1a8a28d777d4a417ac96480a42cf110236346a1a4f62aa5d54f4a5f50d0c8e5b
+  metadata.gz: 15a406b49bcd62e9efc2c1c143903a85157dbaf165ccca5defdf4abd69949d0c0d0107afd55469e5a0b27fa667e3c59a0ec58de854af503cad0a9e3952568a6e
+  data.tar.gz: fa429f47f4ed13b53fa07c7078510524bd6d3b304f7ffa48916b3cfab0e954b42167bda011b413946448dbdaeb63e78dfeaf444ec86a68cf928cefcf3fd70813

data/README.md

@@ -1,7 +1,7 @@
 # Rigor
 
 [![Gem Version](https://badge.fury.io/rb/rigortype.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/rigortype)
-[![GitHub License](https://img.shields.io/github/license/rigortype/rigor)](https://github.com/rigortype/rigor/blob/master/LICENSE)
+[![GitHub License](https://img.shields.io/github/license/rigortype/rigor)](LICENSE)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/rigortype/rigor)
 
 **Type-aware bug finding for Ruby — no annotations required, and a
@@ -47,7 +47,7 @@ s.lenght
 
 ```shell-session
 $ rigor check demo.rb
-demo.rb:7:3: error: undefined method `lenght' for "hello-world"
+demo.rb:7:3: error: undefined method `lenght' for "hello-world" [call.undefined-method]
 ```
 
 Note what the error says: not ``undefined method `lenght' for String``
@@ -185,9 +185,9 @@ plugins:
 
 The full catalogue is in [`plugins/README.md`](plugins/README.md); the
 `rigor-project-init` Skill picks the right set for you. To teach Rigor
-your own DSL, the [`rigor-plugin-author`](skills/rigor-plugin-author/)
+your own DSL, the [`rigor-plugin-author`](skills/rigor-plugin-author)
 Skill authors a plugin step-by-step, and
-[`rigor-baseline-reduce`](skills/rigor-baseline-reduce/) drives the
+[`rigor-baseline-reduce`](skills/rigor-baseline-reduce) drives the
 baseline down once you are running.
 
 ## Going deeper
@@ -231,7 +231,7 @@ rigor docs --list                 # list every bundled page
 
 ## Status
 
-Current release: **`v0.3.5`** (2026-08-25) — on the
+Current release: **`v0.3.6`** (2026-08-30) — on the
 `0.3.x` line, continuing the evaluation era opened by `v0.2.0`, the first
 publicly-announced (general / evaluation) release. The line publishes
 an enumerated [compatibility surface](docs/compatibility.md) as a

data/data/gem_overlay/activesupport/core_ext.rbs

@@ -65,6 +65,9 @@ class Object
   # `acts_like?(:string)` / `acts_like?(:date)` / `acts_like?(:time)`
   # is ActiveSupport's "duck-typing helper" predicate.
   def acts_like?: (Symbol | String) -> bool
+
+  # `core_ext/object/inclusion` — `x.in?([a, b])` / `x.in?(1..10)`.
+  def in?: (untyped) -> bool
 end
 
 # `nil.blank?` / `nil.present?` / `nil.try` are the most frequent
@@ -108,6 +111,9 @@ class String
   def pluralize: (?Integer count, ?Symbol locale) -> String
   def singularize: (?Symbol locale) -> String
   def humanize: (?capitalize: bool, ?keep_id_suffix: bool) -> String
+  def titlecase: () -> String
+  def dasherize: () -> String
+  def upcase_first: () -> String
 
   # `core_ext/string/filters`
   def squish: () -> String
@@ -115,6 +121,8 @@ class String
   def truncate: (Integer truncate_at, ?omission: String, ?separator: String | Regexp | nil) -> String
   def truncate_bytes: (Integer truncate_at, ?omission: String) -> String
   def truncate_words: (Integer words_count, ?omission: String, ?separator: String | Regexp | nil) -> String
+  def remove: (*Regexp | String patterns) -> String
+  def remove!: (*Regexp | String patterns) -> String
 
   # `core_ext/string/output_safety` — `html_safe` returns an
   # `ActiveSupport::SafeBuffer` (a String subclass). The closest
@@ -282,6 +290,8 @@ class Time
   # Re-declaring it raised `RBS::DuplicatedMethodDefinitionError` and took the WHOLE `Time` definition
   # down with it (every `Time` call degraded to `Dynamic[top]`). This overlay only ADDS what
   # ActiveSupport adds.
+  def advance: (untyped options) -> Time
+  def all_day: () -> Range[Time]
   def acts_like_time?: () -> true
 end
 
@@ -323,6 +333,17 @@ class Date
   def at_beginning_of_day: () -> Time
   def end_of_day: () -> Time
   def at_end_of_day: () -> Time
+  def advance: (untyped options) -> Date
+  def all_day: () -> Range[Time]
+
+  # `Date#to_time` is an OVERLOAD CONTINUATION (`| ...`), not a plain declaration: stdlib `date`
+  # already types `to_time: () -> Time`, and re-declaring it raises
+  # `RBS::DuplicatedMethodDefinitionError`, which collapses `Date` to `Dynamic[top]` for every project
+  # this overlay reaches — the failure the `Time#utc?` note above records, and the one #437 hit on the
+  # plugin. The row cannot simply be omitted either: ActiveSupport genuinely widens the arity, so
+  # without it `date.to_time(:utc)` — correct Rails code — draws an arity diagnostic (#449). `| ...`
+  # appends this overload ahead of the stdlib one, so both arities resolve.
+  def to_time: (?Symbol form) -> Time | ...
 end
 
 # ---------------------------------------------------------------
@@ -475,3 +496,15 @@ class DateTime
   def end_of_minute: () -> DateTime
   def acts_like_time?: () -> true
 end
+
+# ---------------------------------------------------------------
+# ERB::Util — ActionView extends it with `html_escape_once`
+# ---------------------------------------------------------------
+
+# `ERB` is a CLASS in Ruby / RBS (not a module), so reopen it as a class — a `module ERB` wrapper
+# collides with upstream `class ERB` once the `erb` stdlib is in scope. `ERB::Util` itself is a module.
+class ERB
+  module Util
+    def self.html_escape_once: (untyped) -> String
+  end
+end

data/docs/handbook/02-everyday-types.md

@@ -113,7 +113,7 @@ String, Symbol, Array, and Hash. The list is not in this
 handbook (it would fill several pages); see
 [`docs/types.md`](../types.md) and the per-class catalogues
 under
-[`data/builtins/ruby_core/`](../../data/builtins/ruby_core/).
+[`data/builtins/ruby_core/`](../../data/builtins/ruby_core).
 
 When folding is **not** safe (because a method has side
 effects, depends on the environment, or is not in a

data/docs/handbook/04-tuples-and-shapes.md

@@ -275,7 +275,7 @@ the underlying RBS sig advertises.
 
 If you prefer the TS spellings (`Pick<T, K>` etc.) in
 directives, opt into the
-[`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types/)
+[`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types)
 plugin. The plugin registers a `Plugin::TypeNodeResolver` that
 translates each TS name onto the canonical projection:
 

data/docs/handbook/08-understanding-errors.md

@@ -236,6 +236,6 @@ deprecations, …). Most projects will never write one; the
 chapter exists so you know the option is there.
 [Chapter 10 — Coexisting with Sorbet](10-sorbet.md) is for
 projects arriving from a Sorbet codebase: the
-[`rigor-sorbet`](../../plugins/rigor-sorbet/) adapter reads
+[`rigor-sorbet`](../../plugins/rigor-sorbet) adapter reads
 `sig { ... }` blocks, RBI files, and `T.let` / `T.cast` /
 `T.must` / `T.unsafe` assertions as type sources.

data/docs/handbook/09-plugins.md

@@ -122,7 +122,7 @@ Reach for a plugin only when:
 
 If those are true, [`examples/README.md`](../../examples/README.md)
 is your starting point. The
-[`rigor-deprecations`](../../examples/rigor-deprecations/)
+[`rigor-deprecations`](../../examples/rigor-deprecations)
 example is the smallest fully-shaped plugin — manifest +
 single per-file walk + a couple of diagnostic emissions —
 and is the recommended template for "I want to author my
@@ -146,7 +146,7 @@ From here:
   to deeper material in
   [`docs/type-specification/`](../type-specification/README.md),
   [`docs/internal-spec/`](../internal-spec/README.md), and
-  [`docs/adr/`](../adr/).
+  [`docs/adr/`](../adr).
 - The [`CHANGELOG.md`](../../CHANGELOG.md) is the per-release
   truth for what shipped when.
 

data/docs/handbook/10-sorbet.md

@@ -1,7 +1,7 @@
 # Coexisting with Sorbet
 
 If your project already uses [Sorbet](https://sorbet.org/),
-the [`rigor-sorbet`](../../plugins/rigor-sorbet/) plugin
+the [`rigor-sorbet`](../../plugins/rigor-sorbet) plugin
 lets Rigor read your existing `sig` blocks, RBI files, and
 `T.let` / `T.cast` / `T.must` / `T.unsafe` assertions as type
 sources. You do not have to rewrite anything in RBS to start

data/docs/handbook/README.md

@@ -66,7 +66,7 @@ up the flag, key, or command that *acts* on it.
    landing page.
 10. [**Coexisting with Sorbet**](10-sorbet.md) — for users
     arriving from a Sorbet-using project: the
-    [`rigor-sorbet`](../../plugins/rigor-sorbet/) adapter
+    [`rigor-sorbet`](../../plugins/rigor-sorbet) adapter
     reads `sig { ... }` blocks, RBI files, and
     `T.let` / `T.cast` / `T.must` / `T.unsafe` assertions
     as type sources without rewriting in RBS.
@@ -255,7 +255,7 @@ ADRs:
 - [`docs/internal-spec/`](../internal-spec/README.md) —
   analyzer-internal contracts (engine surface, type-object
   public API).
-- [`docs/adr/`](../adr/) — architecture decision records.
+- [`docs/adr/`](../adr) — architecture decision records.
 
 ## Non-goals
 

data/docs/handbook/appendix-go.md

@@ -105,7 +105,7 @@ type switches. Rigor has direct analogues.
 | `if x != nil` | `if x` (strips `nil`), or `unless x.nil?` |
 | `v, ok := x.(string)` (comma-ok assertion) | `x.is_a?(String)` narrowing in an `if` |
 | `switch v := x.(type) { case string: … }` | `case x; in String => v` |
-| `x.(T)` (assertion, panics on fail) | (no panicking assertion) — `is_a?` guard, or `T.cast` via [`rigor-sorbet`](../../plugins/rigor-sorbet/) |
+| `x.(T)` (assertion, panics on fail) | (no panicking assertion) — `is_a?` guard, or `T.cast` via [`rigor-sorbet`](../../plugins/rigor-sorbet) |
 | user func returning `bool` | `%a{rigor:v1:predicate-if-true x is Foo}` directive |
 
 Go's type switch is *not* exhaustive — you can omit cases and

data/docs/handbook/appendix-java-csharp.md

@@ -58,7 +58,7 @@ advisor that only speaks when it is sure.
 | `Set<T>` | `HashSet<T>` / `ISet<T>` | `Set[T]` | |
 | `record Point(int x, int y)` | `record Point(int X, int Y)` | `Point = Data.define(:x, :y)` | See [Records ↔ Data.define](#records--datadefine). |
 | `Optional<T>` | `T?` (nullable reference type) | `T?` (i.e. `T \| nil`) | Java models it as a *container*; C# as a *type modifier*. See [Nullability](#nullability). |
-| `enum Color { RED, GREEN }` | `enum Color { Red, Green }` | `Constant<:red> \| Constant<:green>` (Symbol union) | Ruby has no native enum; the [`rigor-mangrove`](../../plugins/) plugin types richer enum DSLs. |
+| `enum Color { RED, GREEN }` | `enum Color { Red, Green }` | `Constant<:red> \| Constant<:green>` (Symbol union) | Ruby has no native enum; the [`rigor-mangrove`](../../plugins) plugin types richer enum DSLs. |
 | `sealed interface Shape permits …` | `abstract` base + sealed hierarchy | union of the subtypes | See [Sealed types & exhaustiveness](#sealed-types-and-exhaustiveness). |
 | `<T>` (generic) | `<T>` (generic) | RBS `[T]` type parameter | |
 | `? extends T` (use-site) | `out T` (declaration-site) | covariant type parameter | See [Generics & variance](#generics-and-variance). |
@@ -124,7 +124,7 @@ behaviour matches.
 | `x instanceof String` | `x is string` | `x.is_a?(String)` |
 | `x instanceof String s` (binding) | `x is string s` (binding) | `case x; in String => s` |
 | `switch (x) { case Foo f -> … }` | `switch (x) { case Foo f => … }` | `case x; in Foo => f` |
-| `(Foo) x` (cast) | `(Foo)x` (cast) | (no in-source cast) — `is_a?` guard, or `T.cast` via [`rigor-sorbet`](../../plugins/rigor-sorbet/) |
+| `(Foo) x` (cast) | `(Foo)x` (cast) | (no in-source cast) — `is_a?` guard, or `T.cast` via [`rigor-sorbet`](../../plugins/rigor-sorbet) |
 | `Objects.requireNonNull(x)` | `x!` (null-forgiving) | (no in-source assertion) — `unless x.nil?`, or `T.must` via `rigor-sorbet` |
 | user method returning `boolean` | user method returning `bool` | `%a{rigor:v1:predicate-if-true x is Foo}` directive on the predicate |
 

data/docs/handbook/appendix-mypy.md

@@ -296,7 +296,7 @@ draws the distinction in full.
   Pyright's "type alias narrowing" and mypy's overload stacks
   cover some cases; Rigor's plugin contract gives you full
   Ruby code at the dispatch point. The
-  [`rigor-lisp-eval`](../../examples/rigor-lisp-eval/) example
+  [`rigor-lisp-eval`](../../examples/rigor-lisp-eval) example
   is the canonical demo — `Lisp.eval([:+, 1, 2])` returns
   `Integer`, `Lisp.eval([:<, 1, 2])` returns `bool`.
 

data/docs/handbook/appendix-protocols-and-structural-typing.md

@@ -228,8 +228,8 @@ author):
 - The `missing-protocol-method` / `protocol-return-mismatch`
   diagnostics are **plugin diagnostics**, emitted under the
   plugin's `plugin.<id>.` provenance — not core Rigor rules. The
-  worked references are [`examples/rigor-web/`](../../examples/rigor-web/)
-  (the minimal tutorial) and [`plugins/rigor-hanami/`](../../plugins/rigor-hanami/)
+  worked references are [`examples/rigor-web/`](../../examples/rigor-web)
+  (the minimal tutorial) and [`plugins/rigor-hanami/`](../../plugins/rigor-hanami)
   (production Hanami 2 actions).
 
 ## Interface vs protocol contract

data/docs/handbook/appendix-rust.md

@@ -91,7 +91,7 @@ The reflex to drop is `unwrap()`. In Rust you reach for
 `.unwrap()` / `.expect()` when you *know* it is `Some`. Rigor
 has no in-source assertion that lies to the checker; the
 equivalents are a `nil?` guard (checked, not asserted) or
-`T.must` via the [`rigor-sorbet`](../../plugins/rigor-sorbet/)
+`T.must` via the [`rigor-sorbet`](../../plugins/rigor-sorbet)
 plugin (see [Chapter 10](10-sorbet.md)).
 
 **`Result<T, E>` ↔ exceptions.** Here the models diverge. Ruby

data/docs/handbook/appendix-type-theory.md

@@ -709,7 +709,7 @@ Rigor maps onto this as:
 | Dynamic type `?` | **`Dynamic[T]`** — a carrier that *wraps* a "best-guess" type `T` while marking the value as not-statically-verified. `Dynamic[top]` is the maximally-dynamic form. |
 | Consistency `~` | The `maybe` arm of the trinary certainty — `Dynamic[T] ~ U` holds whenever `T ~ U` does. |
 | Static/dynamic boundary | Per-method, per-file, per-plugin contribution — Rigor records *why* a value became `Dynamic[T]` in its dynamic-origin algebra. |
-| Casts | No in-source cast operator. The opt-in [`rigor-sorbet`](../../plugins/rigor-sorbet/) plugin reads `T.let` / `T.cast` / `T.must` as cast forms; `RBS::Extended` `assert_type` directives serve the same role from `.rbs`. |
+| Casts | No in-source cast operator. The opt-in [`rigor-sorbet`](../../plugins/rigor-sorbet) plugin reads `T.let` / `T.cast` / `T.must` as cast forms; `RBS::Extended` `assert_type` directives serve the same role from `.rbs`. |
 
 Two Rigor-specific extensions matter:
 
@@ -794,7 +794,7 @@ against:
 ### What Rigor explicitly does NOT do
 
 - **Runtime contract insertion at the static / dynamic boundary.**
-  The opt-in [`rigor-sorbet`](../../plugins/rigor-sorbet/) plugin
+  The opt-in [`rigor-sorbet`](../../plugins/rigor-sorbet) plugin
   reads Sorbet's `T.let` / `T.cast` / `T.must` as cast forms, but
   the contract *enforcement* is `sorbet-runtime`'s job, not
   Rigor's. Rigor's static analysis uses the cast as a hint, not

data/docs/handbook/appendix-typescript.md

@@ -51,7 +51,7 @@ inference cannot see further).
 | `{ name: string; age: number }` | `HashShape{name: String, age: Integer}` | Same per-key model; Ruby uses Symbol keys idiomatically. |
 | `Array<T>` / `T[]` | `Array[T]` | Same. |
 | `Record<K, V>` | `Hash[K, V]` | Same. |
-| `Readonly<T>` | `readonly_of[T]` (via opt-in [`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types/) plugin) | View-level read-only marker on every entry of a `HashShape`. Does NOT prove the underlying object is frozen — ADR-13 § "Readonly". |
+| `Readonly<T>` | `readonly_of[T]` (via opt-in [`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types) plugin) | View-level read-only marker on every entry of a `HashShape`. Does NOT prove the underlying object is frozen — ADR-13 § "Readonly". |
 | `Partial<T>` / `Required<T>` | `partial_of[T]` / `required_of[T]` (same plugin) | Flips every entry's required-ness on a `HashShape`. `Partial` does NOT widen value types to `nil` — Rigor's `HashShape` distinguishes "key absent" from "key present with nil value" (ADR-13 WD on required-ness flips). |
 | `Pick<T, K>` / `Omit<T, K>` | `pick_of[T, K]` / `omit_of[T, K]` (same plugin) | Restrict / remove `HashShape` entries by literal-key union; Tuple receivers project by integer index. Non-shape carriers degrade conservatively and surface `dynamic.shape.lossy-projection`. |
 | Conditional types `T extends U ? A : B` | (none in core; plugin contributions) | A plugin can vary return type by argument shape. |
@@ -159,7 +159,7 @@ inferred call-site instantiation as routinely as TypeScript.
 | `Array<T>` | `Array[T]` |
 | `Map<K, V>` | `Hash[K, V]` |
 | `Promise<T>` | (no analogue — Ruby has no built-in Promise) |
-| `Pick<T, K>` / `Omit<T, K>` / `Partial<T>` / `Required<T>` / `Readonly<T>` | Opt-in [`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types/) plugin maps each onto `pick_of` / `omit_of` / `partial_of` / `required_of` / `readonly_of` over `HashShape` (and `pick_of` / `omit_of` over `Tuple`). |
+| `Pick<T, K>` / `Omit<T, K>` / `Partial<T>` / `Required<T>` / `Readonly<T>` | Opt-in [`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types) plugin maps each onto `pick_of` / `omit_of` / `partial_of` / `required_of` / `readonly_of` over `HashShape` (and `pick_of` / `omit_of` over `Tuple`). |
 | Conditional types | (no analogue — would need a plugin) |
 
 Rigor reads RBS generics through its dispatcher and instantiates
@@ -214,7 +214,7 @@ Be honest about what you give up:
   variation, not type-level expressions.
 - **Mapped types.** `Pick`, `Omit`, `Partial`, `Required`, and
   `Readonly` ship as opt-in plugin-supplied vocabulary via
-  [`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types/),
+  [`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types),
   which maps them onto the Rigor-canonical `pick_of` / `omit_of`
   / `partial_of` / `required_of` / `readonly_of` shape-projection
   type functions on `HashShape` (and `pick_of` / `omit_of` on
@@ -294,7 +294,7 @@ def pick: [K, V] (Hash[K, V] obj, Array[K] keys) -> Hash[K, V]
 
 The RBS sig stays generic. If you want `Pick<T, K>`'s exact-
 key-set tracking back, opt into the
-[`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types/)
+[`rigor-typescript-utility-types`](../../plugins/rigor-typescript-utility-types)
 plugin and annotate the return type with the `Pick` spelling:
 
 ```rbs

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

@@ -38,7 +38,7 @@ the `paths:` list from the configuration file.
 | `--incremental` | Re-analyse only the files changed since the last run plus the files that depend on them, serving the rest from a cross-process disk snapshot (ADR-46). Diagnostics are identical to a full run; a config / gem / version change (or a file added or removed) transparently forces a full re-analysis. See [Caching](12-caching.md). |
 | `--verify-incremental` | Acceptance gate: run the incremental analyzer against a full `--no-cache` run and assert the diagnostics are byte-identical, then exit (0 on match, 1 with the differing diagnostics on mismatch). Used in CI to guarantee `--incremental` never serves a stale result. |
 | `--clear-cache` | Delete the cache directory before running. |
-| `--cache-stats` | Print the on-disk cache inventory when finished. |
+| `--cache-stats` | Print the on-disk cache inventory when finished — on stdout under `--format text`, on stderr under every other format, so machine-readable output stays a parseable document. `--clear-cache`'s and `--verify-incremental`'s notes follow the same rule. |
 | `--[no-]stats` | Print a run summary (files, classes, memory, wall time) to stderr. Default on. |
 | `--coverage` | Add a type-precision coverage block to the output (`coverage` object under `--format json`; a one-line summary in text mode). Off by default — it is a second precision pass over the analyzed files, the same scan [`rigor coverage`](#rigor-coverage) runs, so it is opt-in. |
 | `--workers=N` | Dispatch analysis across `N` parallel worker processes (fork-based pool today; ADR-15). Default `0` (sequential). Applies to `--incremental` re-checks as well as full runs. |
@@ -304,8 +304,8 @@ supposed to fan out — the fan-out is the blast radius.
 
 ```yaml
 # .rigor-effects.yml — generated by `rigor effects update`. Commit it; review its diff.
-schema: 1
-rigor: "0.3.3"
+schema: 2
+rigor: "0.3.5"
 vocabulary: 1
 config_digest: "9ec82bfc…"
 methods:
@@ -314,7 +314,7 @@ methods:
   "Reports::Nightly#perform":
     effects: ["io.db.read"]
     exhaustive: false
-    unresolved: ["dynamic-send"]
+    unresolved: 1
 reach:
   "OrdersController#create":
     effects: ["io.db.read", "io.net.http", "job.enqueue"]
@@ -376,14 +376,17 @@ spelled out:
 Effect drift against .rigor-effects.yml:
 
 methods:
-  PaymentGateway#charge  + io.net.http
+  PaymentGateway#charge  + io.net.http  (app/services/payment_gateway.rb:18)
 
 reach:
-  OrdersController#create  + io.net.http
+  OrdersController#create  + io.net.http  (app/controllers/orders_controller.rb:7)
 
-Run `rigor effects update` and commit the result if this change is intended.
+Run `rigor effects explain` to see what caused this, and `rigor effects update` to accept it.
 ```
 
+Each row names where the method is defined, so the reviewer reads the report
+rather than searching for the method.
+
 The author runs `rigor effects explain` to see the route —
 
 ```
@@ -556,7 +559,7 @@ hand-adjudicated corpus target only **7% of the rows were genuinely
 unused**; the rest were reachable by means static analysis cannot
 see. That is why this is a separate command and never a `rigor check`
 diagnostic — see
-[ADR-102](https://github.com/rigortype/rigor/blob/master/docs/adr/102-unused-code-reachability-report.md).
+[ADR-102](../adr/102-unused-code-reachability-report.md).
 
 Reachability is computed from **roots**, not by counting references,
 so a cluster of classes that only reference each other is still
@@ -1092,9 +1095,10 @@ operational knobs read the environment instead.
 | `RIGOR_CI_DETECT=0` | Turn off CI auto-detection — the same as `--no-ci-detect`. See [Running Rigor in CI § auto-detection](11-ci.md). |
 | `RIGOR_RACTOR_WORKERS=N` | Worker count for parallel analysis. Sits between the CLI flag and the config key in precedence: `--workers=N` > `RIGOR_RACTOR_WORKERS` > `parallel.workers:` > `0` (sequential). |
 | `RIGOR_POOL_BACKEND=ractor` | Opt back into the (off-by-default) Ractor worker pool instead of the active fork-based pool ([ADR-15](../adr/15-ractor-concurrency.md)). Only relevant with a non-zero worker count; the fork pool is the supported backend. |
+| `RIGOR_LSP_POOL_MIN_BATCH=N` | Fewest buffers an [`rigor lsp`](#rigor-lsp) batch must carry before analysis is dispatched across the worker pool rather than run in-process (default `16`). Lower it if your project's per-file analysis is expensive enough that pooling pays off sooner. |
 | `RIGOR_PLUGIN_ISOLATION=none\|process\|ruby_box` | How a plugin's direct calls into its target library are isolated. Default `process`. See [Using plugins § Isolation strategy](07-plugins.md). `RIGOR_BOX` is a legacy alias for `ruby_box`. |
 | `RIGOR_STRICT_VALIDATION=1` | Force full-content cache validation for one run (the same as `cache.validation: digest`, and winning over it) — re-hash every file's content instead of trusting its stat metadata. Use it if a filesystem's timestamps or inode numbers cannot be trusted. See [Caching § How a file is checked for changes](12-caching.md#how-a-file-is-checked-for-changes). |
-| `RIGOR_DISABLE_YJIT=1` | Opt out of Rigor's deferred YJIT enablement. Rigor turns YJIT on partway through a long `check` / `coverage` run so short runs never pay the JIT warm-up; this variable leaves it off entirely. Diagnostics and allocations are identical either way — the effect is wall-time only. |
+| `RIGOR_DISABLE_YJIT=1` | Opt out of Rigor's deferred YJIT enablement. Rigor turns YJIT on partway through any long run so short runs never pay the JIT warm-up; this variable leaves it off entirely. Diagnostics and allocations are identical either way — the effect is wall-time only. |
 | `RIGOR_YJIT_DEADLINE=<seconds>` | Advanced: tune how long a run must last before deferred YJIT enables (default `5.0`). Lower it if your runs are long and you want the JIT sooner; raise it to protect short runs. Ignored when `RIGOR_DISABLE_YJIT=1` is set or YJIT is unavailable. |
 
 Three further variables (`RIGOR_BUDGET_TRACE`,

data/docs/manual/03-configuration.md

@@ -251,7 +251,7 @@ stanza it broke:
 ```
 app/presenters/user_presenter.rb:14:1: warning: Method Presenters::User#render performs io.fs.read
   (File.read), but is declared effect: [] at .rigor.yml effects.envelopes[0], so io.fs.read exceeds
-  the envelope.
+  the envelope. [effect.envelope-exceeded]
 ```
 
 When one method is a deliberate exception, write the narrower envelope on it in RBS — nearest wins,

data/docs/manual/04-diagnostics.md

@@ -19,6 +19,18 @@ Every rule has a two-segment `family.rule` identifier:
 | `assert` | `assert_type` checks. |
 | `dump` | `dump_type` notices. |
 
+Every diagnostic carries its identifier in brackets at the end of the
+line, so the ID you need for `# rigor:disable`, for `disable:` and for
+`severity_profile:` is the one you are already looking at:
+
+```text
+app/user.rb:11:3: error: undefined method `lenght' for "hello" [call.undefined-method]
+```
+
+A diagnostic no rule produced — a parse error, a path error, an
+internal analyzer error — has nothing to suppress and carries no
+bracket.
+
 `rigor explain <rule>` prints the full catalogue entry for any
 built-in rule ID; `rigor explain` with no argument lists them all.
 

data/docs/manual/08-skills.md

@@ -2,7 +2,7 @@
 
 Rigor bundles a set of **Agent Skills** — structured workflows an AI
 coding agent (Claude Code and compatible tools) can run on your behalf.
-They live in [`skills/`](../../skills/) and are auto-discovered when an
+They live in [`skills/`](../../skills) and are auto-discovered when an
 agent works inside a project that has Rigor available.
 
 Skills are optional. Everything they do, you can do by hand with the

data/docs/manual/11-ci.md

@@ -73,7 +73,7 @@ platform reads to annotate the diff directly, instead of leaving them in
 the job log ([ADR-51](../adr/51-ci-diagnostic-output-formats.md)). These
 layer on the generic `--format json` stream; they add no new diagnostics,
 only a platform-native rendering. Ready-to-copy template files live under
-[`ci-templates/`](ci-templates/).
+[`ci-templates/`](ci-templates).
 
 ### GitHub — inline annotations (the default)
 

data/docs/manual/12-caching.md

@@ -137,7 +137,7 @@ CI detection that `auto` relies on.
 | --- | --- |
 | `rigor check --no-cache` | Run without reading or writing the persistent cache. |
 | `rigor check --clear-cache` | Delete the cache directory, then run. |
-| `rigor check --cache-stats` | Print the on-disk cache inventory when the run finishes. |
+| `rigor check --cache-stats` | Print the on-disk cache inventory when the run finishes (on stderr under every `--format` but `text`, so the document on stdout stays parseable). |
 | `rigor check --incremental` | Re-analyse only what changed; serve the rest from the incremental snapshot (see below). |
 
 There is no config key to disable caching permanently — the

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

@@ -333,7 +333,7 @@ ones a type actually catches.
 > [Configuration](03-configuration.md)). A project whose gems live in
 > the active Ruby's default gem home — the common `rbenv` / `mise`
 > case with no `--path` set — is invisible to the isolated analyzer by
-> design ([ADR-27](https://github.com/rigortype/rigor/blob/master/docs/adr/27-tool-distribution-model.md)):
+> design ([ADR-27](../adr/27-tool-distribution-model.md)):
 > point Rigor at it with `bundler.bundle_path:`. Until you do, these
 > holes keep the generic `engine_gap` cause instead of `add_rbs` —
 > the label is missing, never wrong.

data/docs/manual/18-removing-dead-code.md

@@ -140,7 +140,7 @@ Four sections, needing four different decisions:
 
 | Section | What it means | What to do |
 | --- | --- | --- |
-| **Reachable only from test code** | Live test, no production caller | Work these first |
+| **Reachable only from test code** | Live test, no production caller Rigor can see or suspect | Work these first |
 | **Candidates** | Nothing reachable names it | Adjudicate — most are still live |
 | **Cannot decide** | Something can name it at runtime | Read the reason; do not delete from here |
 | **Namespace-only** | A module wrapping live code | Excluded from candidates; count only |
@@ -209,14 +209,23 @@ skip most of a list quickly:
 
 ### Cannot decide: read the reason, do not delete
 
-These were demoted out of `candidates` because something can name the
-class at runtime. Each row says what:
+These were demoted because something can name the class at runtime —
+out of `candidates`, or out of **reachable only from test code**. Each
+row says what:
 
 ```
   1  Handlers::Alpha                     lib/handlers.rb:2
        constantize on an interpolated string (lib/dispatch.rb:14)
 ```
 
+A row demoted out of the test-only section is the second kind, and it
+is the one worth knowing about: a class your specs reference and a
+data file also names — a job in `config/recurring.yml`, a class named
+from a YAML setting — is not a dead production path, because the
+configuration may well be what drives it. The test-only section makes
+a claim about production, so a row Rigor holds evidence against
+belongs here instead, with the file named.
+
 `"Foo".constantize` names `Foo` exactly, so it counts as an ordinary
 reference and never reaches this section. `"Foo::#{key}".constantize`
 can only bound the namespace, so everything under `Foo` is demoted. A
@@ -322,5 +331,5 @@ Running it as a **reporting** job is fine, and is the intended way to
 notice the drift described above: run it on a schedule, publish the
 JSON, and let a person read the trend.
 
-[adr-102]: https://github.com/rigortype/rigor/blob/master/docs/adr/102-unused-code-reachability-report.md
+[adr-102]: ../adr/102-unused-code-reachability-report.md
 [issue-363]: https://github.com/rigortype/rigor/issues/363

data/docs/manual/19-effect-labels.md

@@ -313,8 +313,8 @@ digest of your `effects:` block, so an upgrade or a policy edit shows up as a
 
 ```yaml
 # .rigor-effects.yml — generated by `rigor effects update`. Commit it; review its diff.
-schema: 1
-rigor: "0.3.4"
+schema: 2
+rigor: "0.3.5"
 vocabulary: 1
 config_digest: "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a"
 methods:
@@ -324,10 +324,12 @@ methods:
 
 Two notes on reading the file:
 
-- **Do not read the `unresolved:` arrays.** They are inference-quality metadata,
-  they are what makes half the file's bytes, and they churn on Rigor upgrades
-  and on unrelated edits. They exist so `check` can print
-  `exhaustive → not`. The lines a reviewer reads are `effects:` and `declared:`.
+- **`unresolved:` is a count, not a list.** It says how many calls the analyzer
+  could not follow, which is why `exhaustive:` is false. The causes themselves
+  are not recorded — they are inference-quality metadata that churns on Rigor
+  upgrades and on unrelated edits — so ask for them when you need them:
+  `rigor effects explain` names them, including for an `exhaustive → not` row.
+  The lines a reviewer reads are `effects:` and `declared:`.
 - Trivial and synthesised entries are left out, as in the report. `--full`
   records everything, and produces a much larger and much noisier file.
 
@@ -398,11 +400,11 @@ CI runs `rigor effects check` and fails, exit 1:
 Effect drift against .rigor-effects.yml:
 
 methods:
-  Change#init_path  + io.fs.write
-  Change#init_path  + nondet.time
-  Change#init_path  exhaustive → not
+  Change#init_path  + io.fs.write  (app/models/change.rb:41)
+  Change#init_path  + nondet.time  (app/models/change.rb:41)
+  Change#init_path  exhaustive → not  (app/models/change.rb:41)
 
-Run `rigor effects update` and commit the result if this change is intended.
+Run `rigor effects explain` to see what caused this, and `rigor effects update` to accept it.
 ```
 
 `+ label` and `- label` are the proven lane; `≤+` / `≤-` the declared one;
@@ -410,6 +412,11 @@ Run `rigor effects update` and commit the result if this change is intended.
 someone introduced a call Rigor cannot follow; `+symbol` / `-symbol` are methods
 that appeared or vanished, and a rename is one of each.
 
+The parenthetical is where the method is defined — the file, and the `def`'s own
+line when the file has one. A method defined by a reopening spans several files
+and the row names them all; a `-symbol` row carries no position, because a method
+this run no longer sees is one it cannot locate.
+
 Before regenerating, ask why:
 
 ```sh
@@ -518,7 +525,7 @@ A method that exceeds its bound gets one diagnostic per (method, label) pair, at
 its `def`, naming the route:
 
 ```
-app/helpers/application_helper.rb:59:1: warning: Method ApplicationHelper#link_to_principal performs io.fs.read (Dir.glob via IconsHelper#principal_icon → IconsHelper#sprite_icon → IconsHelper#sprite_source → Redmine::Themes::Helper#current_theme → Redmine::Themes.theme → Redmine::Themes.themes → Redmine::Themes.scan_themes), but is declared effect: [] at .rigor.yml effects.envelopes[0], so io.fs.read exceeds the envelope.
+app/helpers/application_helper.rb:59:1: warning: Method ApplicationHelper#link_to_principal performs io.fs.read (Dir.glob via IconsHelper#principal_icon → IconsHelper#sprite_icon → IconsHelper#sprite_source → Redmine::Themes::Helper#current_theme → Redmine::Themes.theme → Redmine::Themes.themes → Redmine::Themes.scan_themes), but is declared effect: [] at .rigor.yml effects.envelopes[0], so io.fs.read exceeds the envelope. [effect.envelope-exceeded]
 ```
 
 **Budget for a big first number.** That one stanza, on Redmine, is **343
@@ -608,7 +615,7 @@ app/serializers/rest/v1/instance_serializer.rb:89:1: warning: Method
   REST::V1::InstanceSerializer#invites_enabled performs mutate.self
   (receiver-mutation via UserRole.everyone → UserRole.create! → UserRole#set_position),
   but is declared effect: [] at .rigor.yml effects.envelopes[0], so mutate.self
-  exceeds the envelope.
+  exceeds the envelope. [effect.envelope-exceeded]
 ```
 
 Rigor walked *through* the database write and reported the ivar assignment beyond

data/docs/manual/README.md

@@ -80,7 +80,7 @@ flag, key, or command that *acts* on it.
     Cline, …) via `rigor mcp`.
 11. [Running Rigor in CI](11-ci.md) — a clean CI job, inline
     PR/MR diagnostics (SARIF / GitHub Actions / GitLab Code
-    Quality), copy-paste [templates](ci-templates/), and
+    Quality), copy-paste [templates](ci-templates), and
     version pinning.
 12. [Caching](12-caching.md) — where the cache lives, what
     invalidates it, and how to clear it.
@@ -94,4 +94,4 @@ flag, key, or command that *acts* on it.
 - [`docs/types.md`](../types.md) — one-page type-system guide.
 - [`docs/type-specification/`](../type-specification/README.md)
   — the normative spec corpus.
-- [`docs/adr/`](../adr/) — architecture decision records.
+- [`docs/adr/`](../adr) — architecture decision records.

data/docs/manual/plugins/rigor-actionmailer.md

@@ -17,10 +17,10 @@ plugins:
 ## What it checks
 
 ```text
-demo.rb:7:1:  info:  `UserMailer.welcome` matches mailer action (arity 1..2)
-errors_demo.rb:7:1:  error: `UserMailer.welcome` expects 1..2 argument(s), got 0
-errors_demo.rb:15:1: error: `UserMailer.does_not_exist` is not a defined mailer action (known actions: digest, reset_password, welcome)
-app/mailers/user_mailer.rb:14:7: warning: `UserMailer#digest` has no view template under `app/views/user_mailer/`
+demo.rb:7:1: info: `UserMailer.welcome` matches mailer action (arity 1..2) [plugin.actionmailer.mailer-call]
+errors_demo.rb:10:1: error: `UserMailer.welcome` expects 1..2 argument(s), got 0 [plugin.actionmailer.wrong-arity]
+errors_demo.rb:18:1: error: `UserMailer.does_not_exist` is not a defined mailer action (known actions: digest, reset_password, welcome) [plugin.actionmailer.unknown-action]
+app/mailers/user_mailer.rb:26:7: warning: `UserMailer#digest` has no view template under `app/views/user_mailer/` [plugin.actionmailer.missing-view]
 ```
 
 1. **Action existence** — `Mailer.unknown_action(...)` →

data/docs/manual/plugins/rigor-activejob.md

@@ -18,9 +18,9 @@ Given a job whose `#perform` takes one required and one optional
 argument (arity `1..2`):
 
 ```text
-demo.rb:6:1:  info:  `WelcomeEmailJob.perform_later` matches `#perform` (arity 1..2)
-demo.rb:9:1:  error: `WelcomeEmailJob.perform_later` expects 1..2 argument(s), got 0
-demo.rb:12:1: error: `WelcomeEmailJob.perform_later` expects 1..2 argument(s), got 3
+demo.rb:8:1: info: `WelcomeEmailJob.perform_later` matches `#perform` (arity 1..2) [plugin.activejob.job-call]
+errors_demo.rb:10:1: error: `WelcomeEmailJob.perform_later` expects 1..2 argument(s), got 0 [plugin.activejob.wrong-arity]
+errors_demo.rb:14:1: error: `WelcomeEmailJob.perform_later` expects 1..2 argument(s), got 3 [plugin.activejob.wrong-arity]
 ```
 
 A `*rest` parameter yields an unbounded upper bound (`arity 0+`).