rigortype 0.2.1 → 0.2.3

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

@@ -0,0 +1,74 @@
+# rigor-actionmailer
+
+Validates `Mailer.action(args).deliver_*` call sites for action
+existence and argument arity, and flags mailer actions whose view
+template is missing under `app/views/`. Actions inherited from
+included concern modules are merged into the mailer's action set,
+so a mailer that derives its actions from `include`d `Emails::*`
+concerns still type-checks. No Rails runtime dependency.
+
+It ships bundled in `rigortype`. Activate it under `plugins:`:
+
+```yaml
+plugins:
+  - rigor-actionmailer
+```
+
+## 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/`
+```
+
+1. **Action existence** — `Mailer.unknown_action(...)` →
+   `unknown-action` (an unresolved `include` silences this rather
+   than guessing).
+2. **Argument arity** — too few / too many positional args →
+   `wrong-arity`.
+3. **View template existence** — each action needs at least one
+   `app/views/<mailer_underscore>/<action>.{html,text}.{erb,haml,slim}`;
+   a missing one → `missing-view`, anchored on the action's `def`.
+
+Recognised call shapes: a direct action call
+(`UserMailer.welcome(user)`), a `.with(...)` chain
+(`UserMailer.with(user: u).welcome(user)`), and a trailing
+`.deliver_now` / `.deliver_later` (accepted, not interpreted).
+
+## Configuration
+
+```yaml
+plugins:
+  - gem: rigor-actionmailer
+    config:
+      mailer_search_paths: ["app/mailers"]                            # default
+      mailer_base_classes: ["ApplicationMailer", "ActionMailer::Base"] # default
+      views_root: "app/views"                                         # default
+```
+
+## Limitations
+
+- **Direct-superclass match only.** `class CustomerMailer <
+  BaseMailer` where `BaseMailer < ApplicationMailer` is not
+  discovered unless `BaseMailer` is in `mailer_base_classes`.
+  (Actions from `include`d concern *modules* are merged; this is
+  about the superclass chain.)
+- **Syntactic action list.** Actions are read from instance-side
+  `def`s; `define_method`, `initialize`, and `_`-prefixed names are
+  excluded.
+- **Standard view filename pattern only**
+  (`<action>.{html,text}.{erb,haml,slim}`); custom engines / view
+  paths are out of scope.
+- A brand-new view file does not invalidate the cached index until
+  something the mailer file touches changes (the read-tracking
+  trade-off).
+
+## Plugin internals
+
+The mailer/concern discoverer, the cached `:mailer_index` producer,
+the demo, and the contract surfaces this plugin exercises are in
+the [plugin's README](../../../plugins/rigor-actionmailer/README.md).
+To write a plugin, see [`examples/`](../../../examples/README.md)
+and the [`rigor-plugin-author`](../08-skills.md) skill.

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

@@ -0,0 +1,80 @@
+# rigor-actionpack
+
+Checks controller-side Action Pack code across four areas, by
+consuming facts other Rails plugins publish (ADR-9):
+
+- **Route-helper calls** — `redirect_to user_path(@user)` against
+  the `:helper_table` from [`rigor-rails-routes`](rigor-rails-routes.md).
+- **Filter chains** — `before_action :name` against the
+  controller's (and its parents') defined methods.
+- **Render targets** — `render :show` / `render partial:` against
+  the view templates under `view_search_paths`.
+- **Strong parameters** — `params.require(:user).permit(:name, …)`
+  keys against the model's columns (via `:model_index` from
+  [`rigor-activerecord`](rigor-activerecord.md)).
+
+It ships bundled in `rigortype`. Activate it under `plugins:`,
+alongside the producers whose facts it consumes:
+
+```yaml
+plugins:
+  - rigor-rails-routes   # publishes :helper_table  (optional)
+  - rigor-activerecord   # publishes :model_index   (optional)
+  - rigor-actionpack
+```
+
+Both dependencies are declared `optional` — a project that omits a
+producer still loads; the area that needed that fact degrades to a
+no-op rather than erroring.
+
+## What it checks
+
+| Rule | Severity | Fires when |
+| --- | --- | --- |
+| `plugin.actionpack.helper-call` | info | a `*_path` / `*_url` call resolved against the helper table |
+| `plugin.actionpack.unknown-helper` | error | the helper name is not in the table (with a did-you-mean) |
+| `plugin.actionpack.wrong-helper-arity` | error | the call's positional-arg count ≠ the helper's recorded arity |
+| `plugin.actionpack.filter-call` | info | a filter reference (`before_action :name`, `skip_around_action`, …) resolved to a defined method |
+| `plugin.actionpack.unknown-filter-method` | error | a filter reference names a method not defined on the controller or a parent (with a did-you-mean) |
+| `plugin.actionpack.render-target` | info | an explicit `render :symbol` / `"string"` / `partial:` resolved to a view template |
+| `plugin.actionpack.missing-template` | error | an explicit `render` resolved to a view path that doesn't exist under any `view_search_paths` |
+| `plugin.actionpack.permit-call` | info | a `params.require(:m).permit(:key, …)` chain resolved to a known model; keys matched against its columns |
+| `plugin.actionpack.unknown-permit-key` | error | a literal `permit(:key)` isn't a column on the model (with a did-you-mean) |
+
+Filter and render resolution honours nested-module controller
+qualification (`module Admin; class WidgetsController` resolves
+views under `admin/widgets/…`) and silences gem-shipped parent
+classes it can't see.
+
+## Configuration
+
+```yaml
+plugins:
+  - gem: rigor-actionpack
+    config:
+      controller_search_paths: ["app/controllers"]  # default
+      view_search_paths: ["app/views"]               # default
+```
+
+## Limitations
+
+- **Implicit-self helpers only.** `*_path` / `*_url` calls with an
+  explicit receiver (`Rails.application.routes.url_helpers.x_path`)
+  are passed through.
+- **Path-based file filter.** Files under
+  `controller_search_paths` are checked regardless of class
+  hierarchy; a non-controller file placed there (rare) would be
+  scanned.
+- **Coverage follows the upstream facts.** Helper validation only
+  knows what `rigor-rails-routes` published, and `permit`
+  validation only what `rigor-activerecord` published — enabling
+  those producers widens what this plugin can check.
+
+## Plugin internals
+
+The cross-plugin fact contract (`:helper_table` / `:model_index`),
+the controller/view discovery producers, the demo, and the
+contract surfaces this plugin exercises are in the
+[plugin's README](../../../plugins/rigor-actionpack/README.md). To
+write a plugin, see [`examples/`](../../../examples/README.md) and
+the [`rigor-plugin-author`](../08-skills.md) skill.

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

@@ -0,0 +1,58 @@
+# rigor-activejob
+
+Validates `Job.perform_later(...)` / `.perform_now(...)` /
+`.perform(...)` argument arity against the discovered `#perform`
+definition. No Rails runtime dependency — the plugin reads project
+source via Prism only.
+
+It ships bundled in `rigortype`. Activate it under `plugins:`:
+
+```yaml
+plugins:
+  - rigor-activejob
+```
+
+## What it checks
+
+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
+```
+
+A `*rest` parameter yields an unbounded upper bound (`arity 0+`).
+All three entry points — `perform_later` (async), `perform_now`
+(sync), and bare `perform` — are validated against the same
+`#perform` envelope.
+
+## Configuration
+
+```yaml
+plugins:
+  - gem: rigor-activejob
+    config:
+      job_search_paths: ["app/jobs"]                            # default
+      job_base_classes: ["ApplicationJob", "ActiveJob::Base"]   # default
+```
+
+## Limitations
+
+- **Direct-superclass match only.** `class WelcomeJob < BaseJob`
+  where `BaseJob < ApplicationJob` is not discovered unless you
+  add `BaseJob` to `job_base_classes`.
+- **Syntactic arity.** `#perform` arity is read from the parameter
+  list; a `#perform` built with `define_method` is out of scope.
+- **Positional arity only.** Required keyword arguments are
+  recorded by the discoverer but not yet validated at the call
+  site.
+
+## Plugin internals
+
+The job discoverer / index, the cached `:job_index` producer, the
+demo, and the contract surfaces this plugin exercises are in the
+[plugin's README](../../../plugins/rigor-activejob/README.md). To
+write a plugin, see [`examples/`](../../../examples/README.md) and
+the [`rigor-plugin-author`](../08-skills.md) skill.

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

@@ -0,0 +1,102 @@
+# rigor-activerecord
+
+Types ActiveRecord finder and relation calls against your
+project's `db/schema.rb` and discovered model classes — so
+`User.find(1)` is `User`, `User.where(emial: …)` is flagged as
+an unknown column, and `user.posts` carries its element type
+through the chain. The plugin reads source only; it never loads
+`active_record`, so Rigor stays decoupled from Rails.
+
+It ships bundled in `rigortype` — no separate install. Activate
+it under `plugins:` in your config file:
+
+```yaml
+plugins:
+  - rigor-activerecord
+```
+
+## What it checks
+
+```text
+demo.rb:20:1: info: `User.find` returns User (table: `users`) [plugin.activerecord.model-call]
+demo.rb:23:1: info: `User.where` (:admin) on table `users` [plugin.activerecord.model-call]
+
+errors_demo.rb:13:1: error: `User.where(emial: ...)` references unknown column `emial` on table `users` (did you mean `:email`?) [plugin.activerecord.unknown-column]
+errors_demo.rb:25:1: error: `User.find` expects at least 1 argument, got 0 [plugin.activerecord.wrong-arity]
+```
+
+| Diagnostic | Severity | Rule |
+| --- | --- | --- |
+| Recognised `Model.find` / `Model.find_by` / `Model.where` call | `:info` | `plugin.activerecord.model-call` |
+| `Model.find_by(unknown: ...)` / `Model.where(unknown: ...)` | `:error` | `plugin.activerecord.unknown-column` |
+| `Model.find` with 0 args | `:error` | `plugin.activerecord.wrong-arity` |
+| `db/schema.rb` not readable | `:warning` | `plugin.activerecord.load-error` |
+
+Did-you-mean suggestions use Levenshtein distance ≤ 3 against
+the resolved table's column names.
+
+## Configuration
+
+```yaml
+plugins:
+  - gem: rigor-activerecord
+    config:
+      schema_file: "db/schema.rb"                                  # default
+      model_search_paths: ["app/models"]                           # default
+      model_base_classes: ["ApplicationRecord", "ActiveRecord::Base"]  # default
+```
+
+All three keys are optional. Tweak them when:
+
+- the schema lives elsewhere (`schema_file: "shared/db/schema.rb"`);
+- models are in a non-standard directory
+  (`model_search_paths: ["domain/models", "engines/billing/app/models"]`);
+- the base class is custom
+  (`model_base_classes: ["DbRecord", "ApplicationRecord"]`).
+
+## What it infers
+
+The plugin contributes call-site types as well as diagnostics.
+Class-side: `User.find(1)` → `User`, `User.find_by(...)` →
+`User | nil`, `User.find_by!(...)` → non-nullable `User`.
+Instance-side: a column read (`user.name`) narrows to the
+column's value type, `user.admin?` to `bool`, and a singular
+association (`post.user`) to the target model.
+
+Relation-returning call sites — `User.where(...)`, `User.all`,
+`User.order(...)`, a `has_many` / `has_and_belongs_to_many`
+accessor (`user.posts`), and user-declared `scope`s
+(`Post.published`) — narrow to `ActiveRecord::Relation[Model]`.
+Chained query methods keep the element type, and iteration
+(`user.posts.each { |p| ... }`) yields the model. A user-defined
+scope invoked on a typed relation (`User.where(...).published`)
+never surfaces a false `call.undefined-method`.
+
+## Limitations
+
+- **Direct-superclass match only.** `class Admin < User` where
+  `User < ApplicationRecord` is not discovered. Either add `User`
+  to `model_base_classes`, or list every concrete model
+  explicitly.
+- **`db/schema.rb` only.** `db/structure.sql` (raw SQL dumps) is
+  not supported in this iteration.
+- **Column reads, not setters.** The plugin types instance-side
+  column *reads* (`user.name`, `user.admin?`) and singular
+  associations, but not the `name=` setter or the dirty-tracking
+  family (`name_changed?`, `name_was`, …).
+- **Project-custom inflections aren't read yet.** Model↔table
+  pluralization goes through the real ActiveSupport inflector
+  (so `Person → people`, `Mouse → mice` resolve), but rules you
+  declare in `config/initializers/inflections.rb` are not yet
+  ingested — a model relying on one needs `self.table_name`
+  (ADR-39 slice 3).
+
+## Plugin internals
+
+Architecture (the cached schema-parser → model-index → analyzer
+chain), the source layout, how to run the demo, and the plugin
+contract surfaces this plugin exercises are documented in the
+[plugin's README](../../../plugins/rigor-activerecord/README.md).
+To write a plugin of your own, see the
+[`examples/`](../../../examples/README.md) walkthroughs and the
+[`rigor-plugin-author`](../08-skills.md) skill.

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

@@ -0,0 +1,74 @@
+# rigor-activestorage
+
+Walks ActiveRecord model files for `has_one_attached` /
+`has_many_attached` macros and types the attachment accessors they
+generate, so navigating an attachment resolves through
+ActiveStorage's own RBS surface instead of falling to the untyped
+envelope. It reads source only — no Rails runtime dependency.
+
+It ships bundled in `rigortype`. Activate it under `plugins:`:
+
+```yaml
+plugins:
+  - rigor-activestorage
+```
+
+## What it infers
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar
+  has_many_attached :photos
+end
+
+user = User.find(1)
+user.avatar           # Nominal[ActiveStorage::Attached::One]
+user.avatar.attached? # resolves through ActiveStorage's RBS
+user.photos           # Nominal[ActiveStorage::Attached::Many]
+```
+
+| Macro | Accessor | Contributed type |
+| --- | --- | --- |
+| `has_one_attached :avatar` | `user.avatar` | `Nominal[ActiveStorage::Attached::One]` |
+| `has_many_attached :photos` | `user.photos` | `Nominal[ActiveStorage::Attached::Many]` |
+
+Setters (`user.avatar = …`) and attachment-name calls with
+arguments decline — those are covered by ActiveStorage's own RBS.
+
+## Diagnostics
+
+| Rule | Severity | When |
+| --- | --- | --- |
+| `plugin.activestorage.attachment-call` | info | a recognised `model.attachment_name` call surfaces; confirms the model → attachment mapping |
+| `plugin.activestorage.load-error` | warning | discovery failed (e.g. the model directory is inaccessible under the IoBoundary trust policy) |
+
+No `:error` diagnostics in this slice — the value is the
+return-type contribution; an "unknown attachment name" rule is a
+future slice.
+
+## Configuration
+
+```yaml
+plugins:
+  - gem: rigor-activestorage
+    config:
+      model_search_paths: ["app/models"]   # default
+```
+
+## With or without rigor-activerecord
+
+The plugin discovers model files independently, so it works
+stand-alone. When [`rigor-activerecord`](rigor-activerecord.md) is
+also active the two coexist (each contributes its own per-call
+return type and the contribution merger reconciles); the
+`:model_index` dependency is declared `optional`, reserved for a
+future slice that would restrict attachment recognition to
+discovered AR classes.
+
+## Plugin internals
+
+The discovery pass, the `AttachmentIndex`, and the contract
+surfaces this plugin exercises are in the
+[plugin's README](../../../plugins/rigor-activestorage/README.md).
+To write a plugin, see [`examples/`](../../../examples/README.md)
+and the [`rigor-plugin-author`](../08-skills.md) skill.

data/docs/manual/plugins/rigor-activesupport-core-ext.md

@@ -0,0 +1,86 @@
+# rigor-activesupport-core-ext
+
+An opt-in **RBS bundle** for the ActiveSupport `core_ext` extensions
+that real Rails code uses most — `Time.current`, `3.days`, `Array.wrap`,
+`"x".squish`, `obj.blank?`, and the rest. It ships no analyzer and no
+diagnostics: its whole job is to hand Rigor signatures for these
+methods so they stop showing up as `call.undefined-method` false
+positives. A four-project Rails survey found **64–90% of every
+project's diagnostics** came from ActiveSupport extensions missing from
+stdlib RBS — making this the single largest false-positive suppressor
+for Rails apps, and the one to reach for first when Rigor floods a Rails
+codebase with undefined-method noise.
+
+It ships bundled in `rigortype`. Activate it under `plugins:`:
+
+```yaml
+plugins:
+  - rigor-activesupport-core-ext
+```
+
+That is the whole setup — Rigor resolves the bundled `sig/`
+automatically ([ADR-25](../../adr/25-plugin-contributed-rbs.md)); no
+path, no vendoring, no `signature_paths:` wiring.
+
+> **You may not need this plugin.** As of
+> [ADR-72](../../adr/72-gemfile-lock-gated-rbs-overlays.md), Rigor
+> auto-loads a bundled core-ext RBS overlay whenever `activesupport` is
+> in your `Gemfile.lock` but ships no RBS — so the most common
+> ActiveSupport false positives are already suppressed with zero config.
+> This plugin is the **opt-in, fuller twin** of that overlay (and the
+> authoring home for the signatures); load it when you want the complete
+> surface. When it is loaded, the auto overlay stands down so the two
+> never double-declare.
+
+## What it covers
+
+Roughly the top ~40 selectors plus their close neighbours, across:
+
+- **Object (universal)** — `#blank?`, `#present?`, `#presence`, `#try`,
+  `#try!`, `#acts_like?` (+ `NilClass` / `TrueClass` / `FalseClass`).
+- **Integer / Float** — Duration multipliers (`#days`, `#hours`,
+  `#minutes`, …) and Bytes multipliers (`#megabytes`, `#gigabytes`, …).
+- **String** — inflections (`#underscore`, `#camelize`, `#classify`,
+  `#constantize`, `#pluralize`, …), filters (`#squish`, `#truncate`),
+  `#html_safe`, `#starts_with?` / `#ends_with?`, conversions.
+- **Time / Date / DateTime** — `.current`, `.zone`, `#yesterday`,
+  `#tomorrow`, `#beginning_of_*` / `#end_of_*`, `#ago`, `#since`.
+- **Array** — `.wrap`, `#to_sentence`, `#in_groups_of`, `#second` …
+  `#fifth`, `#compact_blank`, `#exclude?`.
+- **Hash** — `#symbolize_keys` / `#stringify_keys` (+ deep / bang),
+  `#deep_merge`, `#with_indifferent_access`, `#except!`.
+- **Enumerable** — `#index_by`, `#index_with`, `#pluck`, `#exclude?`.
+
+```ruby
+3.days           # without the bundle: call.undefined-method Integer#days
+"  x  ".squish   # without the bundle: call.undefined-method String#squish
+Time.current     # without the bundle: call.undefined-method Time.current
+```
+
+## No diagnostics, no config
+
+The plugin is RBS-only — it emits no diagnostics and has no
+configuration knobs. It contributes its signatures unconditionally when
+listed under `plugins:`.
+
+## Limitations
+
+- **Conservative return types.** `Integer#days` really returns
+  `ActiveSupport::Duration`, but the bundle types it `untyped` because
+  the analysis environment usually lacks the Duration class — the goal
+  is to silence undefined-method, not to give precise returns. Likewise
+  `#html_safe` is typed `String` (not `SafeBuffer`) and `#try` / `#try!`
+  return `untyped`.
+- **Project-private monkey-patches are not covered** — only real
+  ActiveSupport extensions. For your own core-class patches see the
+  `pre_eval:` mechanism ([ADR-17](../../adr/17-monkey-patch-pre-evaluation.md)).
+- **Top ~40 selectors, not exhaustive.** ActiveSupport ships hundreds of
+  extensions; this covers the head of the real-world distribution.
+
+## Plugin internals
+
+The RBS layout, the per-class coverage, and the survey that picked the
+selectors are in the
+[plugin's README](../../../plugins/rigor-activesupport-core-ext/README.md).
+To write a plugin, see [`examples/`](../../../examples/README.md) and the
+[`rigor-plugin-author`](../08-skills.md) skill.

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

@@ -0,0 +1,70 @@
+# rigor-devise
+
+Teaches Rigor about the methods Devise mixes into a model from a
+`devise :strategy, …` declaration, so cross-file calls to those
+methods (`user.valid_password?("pw")`,
+`user.send_reset_password_instructions`) resolve instead of
+surfacing a false `call.undefined-method` — and resolve with their
+real return types. It reads source only; no Devise runtime
+dependency.
+
+It ships bundled in `rigortype`. Activate it under `plugins:`:
+
+```yaml
+plugins:
+  - rigor-devise
+```
+
+## What it does — no diagnostics, no config
+
+`rigor-devise` is a macro-expansion plugin (ADR-16 Tier B): it
+emits no diagnostics and has no configuration. From a declaration
+like
+
+```ruby
+class User < ApplicationRecord
+  devise :database_authenticatable, :recoverable
+end
+```
+
+it synthesises the instance methods each named strategy module
+contributes, attaching them to the declaring class so a call in
+another file type-checks:
+
+```ruby
+user.valid_password?("pw")              # bool
+user.send_reset_password_instructions   # (the module's RBS return)
+```
+
+Return types are the strategy module's **authored RBS return**
+(via `origin_module:` provenance), not a widened `Dynamic[T]`.
+Eleven strategies are recognised — `database_authenticatable`,
+`recoverable`, `rememberable`, `registerable`, `trackable`,
+`validatable`, `confirmable`, `lockable`, `timeoutable`,
+`omniauthable`, `authenticatable` — plus the always-included
+`Devise::Models::Authenticatable`. Strategies declared inside an
+`ActiveSupport::Concern`'s `included do … end` are re-targeted onto
+whatever class includes the concern.
+
+## Limitations
+
+- **Instance methods only.** Per-module `ClassMethods` (e.g.
+  `User.reset_password_by_token`) are not yet synthesised.
+- **Controller helpers deferred.** `current_user` /
+  `authenticate_user!` / `user_signed_in?` come from
+  `devise_for :users` in the routes file (Tier C work), not the
+  model declaration, so they are not contributed yet.
+- **Third-party strategies aren't scanned.** A strategy registered
+  via `Devise.add_module :foo` in an initializer is unknown to the
+  bundled strategy table.
+
+## Plugin internals
+
+The macro manifest (the trait registry mapping each strategy to its
+module), the concern re-targeting walk, the demo, and the
+contract surfaces this plugin exercises are in the
+[plugin's README](../../../plugins/rigor-devise/README.md);
+[handbook chapter 9](../../handbook/09-plugins.md) covers the Tier B
+macro substrate generally. To write a plugin, see
+[`examples/`](../../../examples/README.md) and the
+[`rigor-plugin-author`](../08-skills.md) skill.

data/docs/manual/plugins/rigor-dry-schema.md

@@ -0,0 +1,56 @@
+# rigor-dry-schema
+
+Recognises dry-schema declarations and publishes a per-schema
+typed-key table as a cross-plugin fact (`:dry_schema_table`) that
+`rigor-dry-validation` consumes for typed-payload synthesis. Like
+[`rigor-dry-types`](rigor-dry-types.md), it is a foundation plugin:
+no diagnostics of its own, no config keys.
+
+It ships bundled in `rigortype`. Activate it (pair with
+`rigor-dry-types` to resolve `Types::*` aliases inside predicate
+arguments):
+
+```yaml
+plugins:
+  - rigor-dry-types     # optional: resolves Types::Email etc.
+  - rigor-dry-schema
+```
+
+## What it recognises
+
+```ruby
+NewUserSchema = Dry::Schema.Params do
+  required(:email).filled(:string)
+  required(:age).value(:integer)
+  required(:tags).each(:string)
+  optional(:nickname).maybe(:string)
+end
+```
+
+- `required` / `optional` keys, with the predicate's type symbol
+  mapped to a Ruby class (`:string` → `String`, `:integer` →
+  `Integer`, `:decimal` → `BigDecimal`, `:bool` → `TrueClass`, …).
+- `each(:T)` marks the key as a **list** (`list: true`);
+  `filled` / `value` / `maybe` are scalar (`list: false`).
+- `value(Types::Email)` resolves through the `:dry_type_aliases`
+  fact when `rigor-dry-types` is loaded; without it (or for an
+  unknown reference) the row drops from the table rather than
+  mislead downstream consumers.
+- Top-level (`Foo = Dry::Schema.Params { … }`) and class-level
+  (`class Bar; SCHEMA = …; end` → `"Bar::SCHEMA"`) declarations,
+  across `.Params` / `.JSON` / `.define`.
+
+## No diagnostics, no config
+
+The plugin only publishes the schema table for other plugins to
+consume; it surfaces no diagnostics and takes no config keys. (A
+future slice adds `dry-schema.unknown-predicate` / `unknown-type`
+info diagnostics and typed `result.to_h` synthesis.)
+
+## Plugin internals
+
+The `prepare(services)` scan, the published `:dry_schema_table`
+shape, and the slice floor/ceiling are documented in the
+[plugin's README](../../../plugins/rigor-dry-schema/README.md). To
+write a plugin, see [`examples/`](../../../examples/README.md) and
+the [`rigor-plugin-author`](../08-skills.md) skill.

data/docs/manual/plugins/rigor-dry-struct.md

@@ -0,0 +1,60 @@
+# rigor-dry-struct
+
+Recognises dry-struct's class-level `attribute :name, Type` /
+`attribute? :name, Type` DSL on `Dry::Struct` subclasses and
+synthesises the reader methods it generates — so a bare
+`address.city` in another file resolves instead of falling through
+to `call.undefined-method`.
+
+It ships bundled in `rigortype`. Activate it — and pair it with
+[`rigor-dry-types`](rigor-dry-types.md) for precise reader types:
+
+```yaml
+plugins:
+  - rigor-dry-struct
+  - rigor-dry-types   # optional: resolves Types::String → String on the readers
+```
+
+## What it does
+
+```ruby
+class Address < Dry::Struct
+  attribute :city, Types::String
+  attribute? :postcode, Types::String
+end
+
+address.city      # resolves (synthesised reader)
+address.postcode  # resolves
+```
+
+When [`rigor-dry-types`](rigor-dry-types.md) is also active and the
+project declares `module Types; include Dry.Types(); end`, the
+reader's return type resolves through the attribute's type argument
+(`attribute :city, Types::String` → `city` returns `String`). When
+dry-types isn't loaded, or for a shape it can't resolve (a
+`.constrained(...)` chain, an inline composition), the reader falls
+back to `Dynamic[top]` — silently, no diagnostic.
+
+## No diagnostics, no config
+
+The plugin contributes synthesised methods, not diagnostics, and
+has no config keys. It handles any class inheriting from
+`Dry::Struct` (lexically, transitively, or through the RBS env when
+the chain terminates upstream). Its visible effect is that
+attribute-reader calls type-check.
+
+## Limitations
+
+- **Readers only.** The `schema` / `to_h` / `[:key]` / keyword-arg
+  `.new(name:)` shapes are not synthesised yet.
+- **No nested-block form.** `attribute :details do … end` (which
+  mints a sibling `Dry::Struct` subclass) is deferred.
+
+## Plugin internals
+
+The declarative `HeredocTemplate` manifest, the
+`returns_from_arg` precision path (ADR-18), and the
+synthetic-method substrate it rides on are documented in the
+[plugin's README](../../../plugins/rigor-dry-struct/README.md). To
+write a plugin, see [`examples/`](../../../examples/README.md) and
+the [`rigor-plugin-author`](../08-skills.md) skill.