rigortype 0.1.18 → 0.2.0

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord.rb

@@ -27,10 +27,12 @@ module Rigor
     #    whose direct superclass is in `model_base_classes`, and
     #    composes them with the schema table into a {ModelIndex}.
     #
-    # Both producers ride `Plugin::Base#cache_for`. The descriptor
-    # auto-includes the digests of every file the boundary read,
-    # so editing `db/schema.rb` or any model file invalidates
-    # exactly the right cache entry.
+    # Both producers ride `Plugin::Base#cache_for` (ADR-60 WD3
+    # record-and-validate): each producer's in-block boundary reads
+    # are captured into its dependency descriptor after the block
+    # runs, and `model_index`'s `watch:` covers model-file additions,
+    # so editing `db/schema.rb`, editing any model, or adding a new
+    # model file invalidates exactly the right cache entry.
     #
     # The per-file `#diagnostics_for_file` hook delegates to
     # {Analyzer}, which walks Prism and emits diagnostics for
@@ -73,10 +75,9 @@ module Rigor
           "model_base_classes" => { kind: :array, default: %w[ApplicationRecord ActiveRecord::Base] }
         },
         produces: [:model_index],
-        # ADR-25 — the bundled `ActiveRecord::Relation` RBS, the
-        # type `flow_contribution_for`'s relation-typed call sites
-        # (`has_many` accessors, `Model.where`, scopes) dispatch
-        # against.
+        # ADR-25 — the bundled `ActiveRecord::Relation` RBS that
+        # relation-typed call sites (`has_many` accessors,
+        # `Model.where`, scopes) dispatch against.
         signature_paths: ["sig"],
         # ADR-26 — `ActiveRecord::Relation` is an "open" receiver:
         # it delegates an unbounded set of user-defined scopes /
@@ -87,7 +88,7 @@ module Rigor
       )
 
       # The class the bundled `sig/active_record/relation.rbs`
-      # describes; `flow_contribution_for` contributes
+      # describes; `dynamic_return` contributes
       # `ActiveRecord::Relation[Model]` for relation-returning
       # call sites (`has_many` accessors, `Model.where`, scopes).
       RELATION_CLASS_NAME = "ActiveRecord::Relation"
@@ -101,8 +102,11 @@ module Rigor
       end
 
       # Cached: model index. Walks every model file, then composes
-      # the rows with the cached schema table.
-      producer :model_index do |_params|
+      # the rows with the cached schema table. `watch:` (ADR-60 WD3)
+      # covers model-file additions; the discoverer's in-block reads
+      # are captured into the record-and-validate dependency
+      # descriptor after the block runs.
+      producer :model_index, watch: -> { [[@model_search_paths, "**/*.rb"]] } do |_params|
         rows = ModelDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @model_search_paths,
@@ -256,9 +260,8 @@ module Rigor
         names
       end
 
-      # The migrated body of the legacy `flow_contribution_for` —
-      # same resolution order, returning the bare type the
-      # `dynamic_return` contract expects.
+      # Resolution body for `dynamic_return` — same four-path
+      # order, returning the bare type the contract expects.
       def contribution_return_type(call_node, scope)
         return nil unless call_node.is_a?(Prism::CallNode)
 
@@ -571,16 +574,11 @@ module Rigor
         table = schema_table_or_nil
         return nil if table.nil?
 
-        # Walk model files first so the IoBoundary's digest list
-        # captures them BEFORE `cache_for` snapshots the
-        # descriptor (the same "read first, cache_for second"
-        # pattern documented at the top of rigor-routes).
-        ModelDiscoverer.new(
-          io_boundary: io_boundary,
-          search_paths: @model_search_paths,
-          base_classes: @model_base_classes
-        ).discover
-
+        # ADR-60 WD3 record-and-validate: the producer's own in-block
+        # `ModelDiscoverer` reads are captured into the dependency
+        # descriptor after the block runs, and the producer's `watch:`
+        # covers model-file additions — so no priming walk is needed
+        # (it used to run the discover twice).
         @model_index = cache_for(:model_index, params: {}).call
       rescue StandardError => e
         @load_errors << "model index build failed: #{e.class}: #{e.message}"
@@ -599,9 +597,10 @@ module Rigor
         return nil if @schema_load_attempted
 
         @schema_load_attempted = true
-        # Same pattern: read schema file via boundary, then call
-        # cache_for so the descriptor includes the file digest.
-        io_boundary.read_file(@schema_file)
+        # ADR-60 WD3 record-and-validate: the producer reads
+        # `@schema_file` in-block, and that read is captured into the
+        # dependency descriptor after the block runs — so no priming
+        # read is needed here.
         @schema_table = cache_for(:schema_table, params: {}).call
       rescue Plugin::AccessDeniedError => e
         @load_errors << "rigor-activerecord: #{e.message}"

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/analyzer.rb

@@ -11,13 +11,11 @@ module Rigor
       # plugin recognised so users can verify the model →
       # attachment mapping the plugin sees.
       #
-      # No `:error` diagnostics in this slice — the
-      # `dynamic_return` return-type narrowing carries
-      # the type-checking value; surfacing unknown attachment
-      # names as errors requires a coupled receiver-class
-      # narrowing pass that the integration spec doesn't yet
-      # rely on. A future slice can add `unknown-attachment`
-      # similar to `rigor-activerecord`'s `unknown-column`.
+      # No `:error` diagnostics here — the `dynamic_return`
+      # return-type narrowing carries the type-checking value.
+      # An `unknown-attachment` rule (similar to
+      # `rigor-activerecord`'s `unknown-column`) is deferred:
+      # it requires a coupled receiver-class narrowing pass.
       class Analyzer
         attr_reader :diagnostics
 

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage.rb

@@ -54,8 +54,11 @@ module Rigor
       )
 
       # Cached: attachment index. Walks every `.rb` file under
-      # `model_search_paths` for `has_*_attached` macros.
-      producer :attachment_index do |_params|
+      # `model_search_paths` for `has_*_attached` macros. `watch:`
+      # (ADR-60 WD3) covers model-file additions; the discoverer's
+      # in-block reads are captured into the record-and-validate
+      # dependency descriptor after the block runs.
+      producer :attachment_index, watch: -> { [[@model_search_paths, "**/*.rb"]] } do |_params|
         rows = AttachmentDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @model_search_paths
@@ -126,12 +129,10 @@ module Rigor
       def attachment_index
         return @attachment_index if @attachment_index
 
-        # Walk first so the IoBoundary's digest list captures
-        # the model file digests before cache_for snapshots.
-        AttachmentDiscoverer.new(
-          io_boundary: io_boundary,
-          search_paths: @model_search_paths
-        ).discover
+        # ADR-60 WD3 record-and-validate: the producer's in-block
+        # `AttachmentDiscoverer` reads are captured into the
+        # dependency descriptor after the block runs, and the
+        # producer's `watch:` covers model-file additions.
         @attachment_index = cache_for(:attachment_index, params: {}).call
       rescue Plugin::AccessDeniedError => e
         @load_errors << "rigor-activestorage: #{e.message}"

data/plugins/rigor-devise/lib/rigor/plugin/devise.rb

@@ -44,19 +44,17 @@ module Rigor
     # `send_reset_password_instructions`, etc. resolve through the
     # synthetic-method tier without `call.undefined-method`.
     #
-    # ## Floor / ceiling per ADR-16 WD13
+    # ## Precision tier
     #
-    # Slice 3 ships at the **floor**: synthesised method names
-    # emit and the dispatcher's `try_synthetic_method` tier
-    # returns `Type::Combinator.untyped` (Dynamic[T]) for every
-    # match. Per the slice-3 design judgment (1) the precision
-    # promotion — looking up the module's authored RBS return
-    # type at dispatch time — is **slice-6 ceiling work** and is
-    # NOT a delivery commitment of slice 3c. The `origin_module:`
-    # provenance field is recorded so the ceiling slice can
-    # promote without rescanning.
+    # The scanner records `origin_module:` in each synthetic
+    # method's provenance. The dispatcher's slice-6a TierB path
+    # (`promote_via_origin_module`) redispatches on
+    # `Nominal[origin_module]` via `RbsDispatch`, so Devise's
+    # authored RBS return types win: `valid_password?` returns
+    # `bool`, not `Dynamic[T]`. Unknown return types degrade
+    # gracefully to `Dynamic[T]`.
     #
-    # ## Scope (slice 3c minimum)
+    # ## Scope
     #
     # - Recognises model-side `devise :a, :b` on any AR::Base
     #   subclass; trait symbol set mirrors `lib/devise/modules.rb`.

data/plugins/rigor-dry-struct/lib/rigor/plugin/dry_struct.rb

@@ -35,16 +35,15 @@ module Rigor
     # other files then dispatch through the synthetic record rather
     # than falling through to `call.undefined-method`.
     #
-    # ## Floor / ceiling per ADR-16 WD13
+    # ## Precision model (ADR-16 WD13 + ADR-18)
     #
-    # Slice 2 ships at the **floor**: the synthetic reader's return
-    # type degrades to `Dynamic[T]`. The manifest's `returns: "Object"`
-    # is recorded but not resolved — precise return-type promotion
-    # (so `attribute :city, Types::String` makes `address.city`
-    # return `String`) is the **ceiling**, deferred to slice 6
-    # (ADR-13 `Plugin::TypeNodeResolver` chain). The plugin's manifest
-    # value of `returns:` would today be the upstream gem's reader
-    # return shape; slice 6 unlocks precision without re-authoring.
+    # The synthetic reader's return type is resolved via ADR-18's
+    # `returns_from_arg:` fact lookup: the call-site's second argument
+    # (`Types::String` etc.) is looked up through the `:dry_type_aliases`
+    # fact published by `rigor-dry-types`, yielding `Nominal[String]`
+    # for common cases. When the lookup misses (e.g. inline method-chain
+    # argument whose chain-head isn't currently extracted), the row
+    # falls back to `Dynamic[Top]` silently.
     #
     # ## Scope (slice 2c minimum)
     #

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types.rb

@@ -22,9 +22,8 @@ module Rigor
     # Other dry-rb adapter plugins consume this fact:
     #
     # - `rigor-dry-struct` reads it so `attribute :city, Types::String`
-    #   can promote `address.city` from `Dynamic[T]` to `Nominal[String]`
-    #   (gated on the slice-6 precision-promotion work + ADR-13
-    #   resolver chain).
+    #   promotes `address.city` from `Dynamic[Top]` to `Nominal[String]`
+    #   via ADR-18's `returns_from_arg:` fact lookup.
     # - `rigor-dry-validation` / `rigor-dry-schema` read it for
     #   per-key type recognition in `schema { … }` / `params { … }`
     #   blocks (separate plugin slice).
@@ -43,17 +42,19 @@ module Rigor
     #   "<UnderlyingClass>" }` so consumers can match on the
     #   qualified constant name they see in source.
     #
-    # The **ceiling** (slice 2+):
+    # Implemented beyond the floor:
     #
-    # - Recognises nested namespaces (`Types::Coercible::Integer`,
+    # - Nested-namespace aliases (`Types::Coercible::Integer`,
     #   `Types::Strict::Symbol`, `Types::Params::Bool`,
-    #   `Types::JSON::Date`) — each is a separate dry-types
-    #   "category" with its own coercion semantics.
-    # - Recognises user-authored compositions
-    #   (`Types::String.constrained(min_size: 1)`,
-    #   `Email = Types::String.constrained(format: …)`) so the
-    #   alias surface extends beyond the canonical names.
-    # - Emits `dry-types.unknown-alias` / `dry-types.alias-shadow`
+    #   `Types::JSON::Date`) — the four coercion categories each
+    #   map to the same underlying class as their canonical shortcut.
+    # - User-authored compositions (`Email = Types::String.constrained(...)`,
+    #   transitive resolution through composition chains) — the alias
+    #   surface extends beyond the 15 canonical names.
+    #
+    # Deferred:
+    #
+    # - `dry-types.unknown-alias` / `dry-types.alias-shadow`
     #   diagnostics when downstream code references a name that
     #   wasn't published.
     #

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb

@@ -21,10 +21,9 @@ module Rigor
     #   cross-plugin fact.
     # - Ships an RBS overlay (`sig/dry_validation.rbs`) typing
     #   `Dry::Validation::Contract#call` (returns Result) and
-    #   `Dry::Validation::Result#{success?, failure?, to_h}`. Users
-    #   add the path to their `.rigor.yml`'s `signature_paths:` so
-    #   `contract.call(input).to_h` infers cleanly. See the README
-    #   for the wiring step.
+    #   `Dry::Validation::Result#{success?, failure?, to_h}`.
+    #   The manifest's `signature_paths: ["sig"]` auto-contributes
+    #   the overlay (ADR-25) — no project-side wiring needed.
     #
     # Slice 2 (deferred, per design note):
     #

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/analyzer.rb

@@ -86,14 +86,14 @@ module Rigor
         # a `Prism::SymbolNode` is treated as a literal
         # attribute reference.
         #
-        # Phase 1 (c) — when `model_index` (the cross-plugin
-        # `:model_index` fact published by rigor-activerecord)
-        # is present, the effective accepted key set is the
-        # UNION of the factory's declared attributes plus the
-        # corresponding model's columns. FactoryBot's runtime
-        # accepts any AR attribute regardless of whether the
-        # factory declared it, so the cross-check broadens the
-        # acceptance accordingly.
+        # When `model_index` (the cross-plugin `:model_index`
+        # fact published by rigor-activerecord) is present,
+        # the effective accepted key set is the UNION of the
+        # factory's declared attributes plus the corresponding
+        # model's columns. FactoryBot's runtime accepts any AR
+        # attribute regardless of whether the factory declared
+        # it, so the cross-check broadens the acceptance
+        # accordingly.
         def unknown_attribute_violations(call_node, entry, model_index)
           accepted_keys, suggestion_dictionary = effective_keys(entry, model_index)
           attr_spell_checker = DidYouMean::SpellChecker.new(dictionary: suggestion_dictionary)

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb

@@ -23,8 +23,8 @@ module Rigor
       # - `factory :users, aliases: [:author] do ... end` — alias form
       #
       # Inside a factory block, attribute declarations come in
-      # several shapes. Phase 1 (a) recognises the literal-name
-      # forms only (Symbol arg / String arg):
+      # several shapes. Only literal-name forms are recognised
+      # (Symbol arg / String arg):
       #
       # - `name { "Alice" }` — implicit attribute via
       #   `method_missing` with a block (FactoryBot's modern
@@ -116,8 +116,8 @@ module Rigor
           Rigor::Source::Literals.symbol_or_string_name(call_node.arguments&.arguments&.first)
         end
 
-        # Pillar 2 Slice 3 — resolve the model class name for
-        # the factory. Three sources, in priority order:
+        # Resolves the model class name for the factory.
+        # Three sources, in priority order:
         #
         # 1. Explicit `class: <Const>` keyword arg —
         #    ConstantReadNode / ConstantPathNode value.
@@ -188,11 +188,10 @@ module Rigor
           attributes
         end
 
-        # Walks the block body collecting attribute names. The
-        # recogniser looks at top-level statements only —
-        # attributes inside `trait :admin do ... end` or other
-        # nested blocks are NOT collected in Phase 1 (a)
-        # (traits ship in a follow-up).
+        # Walks the block body collecting attribute names. Only
+        # top-level statements are examined — attributes inside
+        # `trait :admin do ... end` or other nested blocks are
+        # not collected (traits deferred to a follow-up).
         def collect_attributes_from(node, accumulator)
           return unless node.is_a?(Prism::Node)
 
@@ -206,8 +205,7 @@ module Rigor
         def record_attribute(node, accumulator)
           return unless node.is_a?(Prism::CallNode) && node.receiver.nil?
           # Skip association / sequence / trait / framework
-          # methods — Phase 1 (a) only records plain attribute
-          # declarations.
+          # methods — only plain attribute declarations are recorded.
           return if SKIPPED_METHODS.include?(node.name)
 
           name = if node.name == :add_attribute

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_index.rb

@@ -4,15 +4,14 @@ module Rigor
   module Plugin
     class Factorybot < Rigor::Plugin::Base
       # Per-run frozen index of discovered FactoryBot factories
-      # and the attribute keys each declares. Phase 1 (a) keys
-      # only the **literal symbol/string** factory name + the
-      # **literal symbol** attribute names; sequences,
-      # parent/child relationships, traits, and dynamically-
-      # named factories ship behind later slices.
+      # and the attribute keys each declares. Indexes only
+      # **literal symbol/string** factory names + **literal
+      # symbol** attribute names; sequences, parent/child
+      # relationships, traits, and dynamically-named factories
+      # are deferred to follow-up slices.
       #
-      # v0.2.0 (Pillar 2 Slice 3) adds `model_class` to each
-      # entry — the inferred or explicit class the factory
-      # builds. Resolved from:
+      # Each entry carries a `model_class` — the inferred or
+      # explicit class the factory builds. Resolved from:
       #
       #   1. An explicit `factory :user, class: User do`
       #      keyword option (ConstantReadNode / ConstantPathNode

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot.rb

@@ -13,12 +13,10 @@ module Rigor
     # attributes_for / *_list family against a per-run index
     # built from `factory_search_paths`.
     #
-    # **Phase 1 (a)** of the FactoryBot plugin family — the
-    # self-contained slice. Recognises factory NAMES + literal
-    # ATTRIBUTE KEYS in the call's keyword hash. Phase 1 (c)
-    # ships the AR column cross-check via the
-    # `rigor-activerecord` `:model_index` ADR-9 fact, after
-    # `rigor-activerecord` adds the matching publish hook.
+    # Recognises factory NAMES + literal ATTRIBUTE KEYS in
+    # the call's keyword hash. The AR column cross-check uses
+    # the `rigor-activerecord` `:model_index` ADR-9 fact when
+    # that plugin is loaded (optional `consumes:`).
     # Traits, sequences, parent / child factories, and dynamic
     # factory names are deferred to follow-up slices.
     #
@@ -54,9 +52,9 @@ module Rigor
     # `.build_stubbed_list`. The legacy `FactoryGirl` constant
     # is recognised identically. Implicit-receiver calls
     # (`create(:name)` inside an `include FactoryBot::Syntax::Methods`
-    # context) are NOT recognised in Phase 1 (a) — too many
-    # false positives on plain `create` calls outside test
-    # files; this needs receiver-type inference (Phase 1 (b)).
+    # context) are NOT recognised — too many false positives on
+    # plain `create` calls outside test files; deferred until
+    # receiver-type inference can disambiguate.
     #
     # ## What's recognised inside `factory :name do ... end`
     #
@@ -87,19 +85,15 @@ module Rigor
         ]
       )
 
-      producer :factory_index do |_params|
+      producer :factory_index, watch: -> { [[@factory_search_paths, "**/*.rb"]] } do |_params|
         FactoryDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @factory_search_paths
         ).discover
       end
 
-      def init(services)
-        @services = services
+      def init(_services)
         @factory_search_paths = Array(config.fetch("factory_search_paths")).map(&:to_s)
-        @factory_index = nil
-        @model_index = nil
-        @model_index_resolved = false
       end
 
       # ADR-37 — per-call factory/attribute validation over the
@@ -108,42 +102,17 @@ module Rigor
       # is positioned via `diagnostic(node, location:)`. No file-level
       # diagnostic remains, so there is no `diagnostics_for_file`.
       node_rule Prism::CallNode do |node, _scope, path|
-        index = factory_index_or_nil
+        index = producer_value(:factory_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(
-          call_node: node, factory_index: index, model_index: model_index_or_nil
-        ).map do |violation|
-          diagnostic(
-            node, path: path, location: violation.location,
-                  message: violation.message, severity: violation.severity, rule: violation.rule
-          )
-        end
-      end
-
-      private
-
-      # Phase 1 (c) — lazily resolves the :model_index fact
-      # from rigor-activerecord. Returns nil when
-      # rigor-activerecord isn't loaded or hasn't published
-      # an index; the analyzer treats nil as "no cross-check"
-      # and falls back to Phase 1 (a) behaviour (factory
-      # attributes only).
-      def model_index_or_nil
-        return @model_index if @model_index_resolved
-
-        @model_index = @services.fact_store.read(plugin_id: "activerecord", name: :model_index)
-        @model_index_resolved = true
-        @model_index
-      end
-
-      def factory_index_or_nil
-        return @factory_index if @factory_index
-
-        descriptor = glob_descriptor(@factory_search_paths, "**/*.rb")
-        @factory_index = cache_for(:factory_index, params: {}, descriptor: descriptor).call
-      rescue StandardError
-        nil
+        # `:model_index` is rigor-activerecord's published fact (ADR-9);
+        # nil when that plugin isn't loaded, in which case the analyzer
+        # falls back to factory-attributes-only checking.
+        violations = Analyzer.violations_for(
+          call_node: node, factory_index: index,
+          model_index: read_fact(plugin_id: "activerecord", name: :model_index)
+        )
+        diagnostics_for(violations, path: path, node: node)
       end
     end
 

data/plugins/rigor-graphql/lib/rigor/plugin/graphql/type_scanner.rb

@@ -50,12 +50,13 @@ module Rigor
 
         # @param paths [Array<String>] absolute paths to `.rb` files
         #   the project's `paths:` resolves to.
-        # @return [Hash{Symbol => Hash}] frozen 3-key result with
+        # @return [Hash{Symbol => Hash}] frozen 4-key result:
         #   `:types` (per-`Schema::Object` field table),
-        #   `:enums` (per-`Schema::Enum` value list), and
-        #   `:input_objects` (per-`Schema::InputObject` argument
-        #   table). Any subset may be empty when no recognisable
-        #   declaration of that kind is found.
+        #   `:enums` (per-`Schema::Enum` value list),
+        #   `:input_objects` (per-`Schema::InputObject` argument table),
+        #   `:mutations` (per-`Schema::Mutation` arguments+fields table).
+        #   Any subset may be empty when no recognisable declaration
+        #   of that kind is found.
         def scan(paths:)
           acc = empty_accumulator
           paths.each do |path|
@@ -97,10 +98,9 @@ module Rigor
         private_class_method :scan_file
 
         # Walks the AST collecting `class X < GraphQL::Schema::Object`,
-        # `class X < GraphQL::Schema::Enum`, and
-        # `class X < GraphQL::Schema::InputObject` decls at any
-        # nesting level. Returns a 3-key hash so the caller can
-        # publish multiple cross-plugin facts from one walk.
+        # `Schema::Enum`, `Schema::InputObject`, and `Schema::Mutation`
+        # decls at any nesting level. Returns a 4-key hash so the
+        # caller can publish multiple cross-plugin facts from one walk.
         def collect_definitions(node, qualified_prefix)
           return empty_accumulator if node.nil?
 
@@ -203,10 +203,9 @@ module Rigor
         # The first positional must be a String literal — the
         # graphql-ruby `value` API also accepts a Symbol form
         # (`value :ACTIVE`) but the documented idiom is String.
-        # Slice 2b only stores the GraphQL-side value name; the
-        # optional `value:` kwarg (Ruby-side override) and
-        # `description:` stay out of the published table for
-        # the floor.
+        # Only the GraphQL-side value name is stored; the optional
+        # `value:` kwarg (Ruby-side override) and `description:`
+        # are omitted from the published table.
         def collect_values(body)
           return [] if body.nil?
 

data/plugins/rigor-graphql/lib/rigor/plugin/graphql.rb

@@ -25,10 +25,10 @@ module Rigor
     # resolver methods themselves; rigor's value here is producing a
     # static type table downstream consumers can cross-reference.
     #
-    # ## What downstream consumers DO with `:graphql_type_table`
+    # ## What downstream consumers DO with the published facts
     #
-    # The fact is the substrate for two future capabilities (both
-    # demand-driven, NOT in slice 1):
+    # The tables are the substrate for two future capabilities
+    # (demand-driven, not yet implemented):
     #
     # - Resolver-method check: for each `field :name, Type` whose
     #   `name` is also defined as a Ruby method on the class, verify
@@ -37,33 +37,25 @@ module Rigor
     #   plugin could type `Schema.execute(query).to_h` against the
     #   queried fields.
     #
-    # ## Floor / ceiling (slice 1)
+    # ## What's recognised
     #
-    # Slice 1 ships the **floor**:
+    # - `class T < GraphQL::Schema::Object` subclasses (including
+    #   nested namespaces); `field :name, Type, null: ...`
+    #   declarations with constant-reference or list-array types
+    #   and GraphQL→Ruby scalar mapping.
+    # - `class T < GraphQL::Schema::Enum`; `value "ACTIVE"` calls.
+    # - `class T < GraphQL::Schema::InputObject` /
+    #   `GraphQL::Schema::Mutation`; `argument :name, Type,
+    #   required: ...` declarations.
+    # - No user-facing diagnostics yet.
     #
-    # - Recognises `class T < GraphQL::Schema::Object` subclasses
-    #   (including nested namespaces: `class Types::User < ...`,
-    #   `module Types; class User < ...; end; end`).
-    # - Recognises the `field :name, Type, **opts` declaration with:
-    #   - `Type` as a `ConstantReadNode` / `ConstantPathNode` (`String`
-    #     / `Integer` / `Boolean` / `Float` / `ID`, or a user-defined
-    #     `Types::OtherObject`).
-    #   - `null: true` / `null: false` keyword extracts nullability.
-    # - Maps the canonical GraphQL scalar names to underlying Ruby
-    #   classes (`String` → `String`, `Integer` → `Integer`,
-    #   `Boolean` → `TrueClass`, `Float` → `Float`, `ID` → `String`).
-    # - Publishes the table; no user-facing diagnostics yet.
+    # ## Deferred (demand-driven)
     #
-    # The **ceiling** (future slices, demand-driven):
-    #
-    # - **`GraphQL::Schema::Enum`** with `value "ACTIVE"` calls.
-    # - **`GraphQL::Schema::Mutation`** + **`GraphQL::Schema::InputObject`**.
-    # - **List / Non-Null wrappers** (`[String]`, `String.array`).
     # - **`resolver:` / `mutation:` reroute** recognition.
     # - **String type expressions** (`field :foo, "User"`) — defeats
     #   static resolution by design (graphql-ruby's `BuildType.parse_type`
     #   constantizes at runtime); a future slice could surface these
-    #   as `graphql.string-type` `:info` diagnostics that point the
+    #   as `graphql.string-type` `:info` diagnostics pointing the
     #   user at the constant-reference form for static typing.
     class Graphql < Rigor::Plugin::Base
       manifest(

data/plugins/rigor-mangrove/lib/rigor/plugin/mangrove.rb

@@ -71,9 +71,9 @@ module Rigor
     # - `is_a?(Result::Ok)` / `Some` / `None` exhaustive
     #   narrowing — core control-flow analysis over a sealed
     #   hierarchy, not a plugin surface.
-    # - The `variants do variant Const, Type end` Enum DSL — needs
-    #   an ADR-16 nested-class emission tier (ADR-36). Today's
-    #   contract has no `const_set`-emitting macro substrate.
+    # - The `variants do variant Const, Type end` Enum DSL is handled
+    #   via ADR-36 `nested_class_templates:` in this plugin's manifest
+    #   (Slice A — see `nested_class_templates:` block below).
     class Mangrove < Rigor::Plugin::Base
       manifest(
         id: "mangrove",
@@ -99,7 +99,7 @@ module Rigor
             receiver_constraint: "Mangrove::Enum",
             block_method: :variants,
             variant_method: :variant,
-            name_arg_position: 0,
+            symbol_arg_position: 0,
             inner_arg_position: 1,
             inner_reader: :inner
           )

data/plugins/rigor-minitest/lib/rigor/plugin/minitest.rb

@@ -30,10 +30,10 @@ module Rigor
     #
     # ## Configuration
     #
-    # No knobs in v0.1.0. Activate via `plugins: ["rigor-minitest"]`
-    # in `.rigor.yml`.
+    # No configuration knobs. Activate via
+    # `plugins: ["rigor-minitest"]` in `.rigor.yml`.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - **No `assert_raises(T) { ... }`** — that's a block-shape
     #   matcher and Rigor's narrowing model is for