rigortype 0.1.18 → 0.2.0

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_index.rb

@@ -69,9 +69,9 @@ module Rigor
         # True when at least one discovered channel uses a
         # dynamic stream registration. The analyzer treats
         # this as "we can't be sure any literal name is
-        # missing" and downgrades unknown-stream from
-        # `:warning` to `:info` (or drops it entirely;
-        # current behaviour: skip warnings).
+        # missing" and skips the `unknown-stream` warning
+        # entirely — absence of a literal match doesn't prove
+        # the name is wrong.
         def any_dynamic_streams?
           @entries.any?(&:dynamic_streams)
         end

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

@@ -41,7 +41,7 @@ module Rigor
     #    `stream_for record`) — the absence of a literal
     #    match doesn't prove absence.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - **Direct-superclass match only.** Indirect
     #   inheritance (`AdminChannel < BaseChannel <
@@ -51,8 +51,8 @@ module Rigor
     #   ActionCable actions are invoked from JS via
     #   `subscription.perform("action_name", data)`; we
     #   don't analyse JS so the action-method index is
-    #   currently informational only (future cross-plugin
-    #   handoff to a hypothetical JS-side analyzer).
+    #   informational only (deferred: cross-plugin handoff
+    #   to a JS-side analyzer).
     # - **`broadcast_to` arity isn't checked.** The method
     #   takes any record + any data hash; there's no
     #   useful arity envelope.
@@ -70,7 +70,12 @@ module Rigor
         }
       )
 
-      producer :channel_index do |_params|
+      # `watch:` covers every `.rb` file under the channel search paths
+      # so the cache invalidates when channels are added, removed, or
+      # edited (ADR-60 WD3). The dependency descriptor is recorded after
+      # the discoverer runs, so the `io_boundary` reads inside it are
+      # captured too.
+      producer :channel_index, watch: -> { [[@channel_search_paths, "**/*.rb"]] } do |_params|
         ChannelDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @channel_search_paths,
@@ -81,54 +86,33 @@ module Rigor
       def init(_services)
         @channel_search_paths = Array(config.fetch("channel_search_paths")).map(&:to_s)
         @channel_base_classes = Array(config.fetch("channel_base_classes")).map(&:to_s)
-        @channel_index = nil
-        @load_error = nil
       end
 
       # File-level only: the load-error emission. Per-call broadcast
       # validation runs over the engine-owned walk via the node_rule
       # below (ADR-37). The channel index is lazily loaded + memoised by
-      # channel_index_or_nil, shared by both surfaces.
+      # `producer_value`, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = channel_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:channel_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:channel_index)
 
         []
       end
 
       node_rule Prism::CallNode do |node, _scope, path|
-        index = channel_index_or_nil
+        index = producer_value(:channel_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, channel_index: index).map do |violation|
-          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
-        end
+        diagnostics_for(Analyzer.violations_for(call_node: node, channel_index: index), path: path, node: node)
       end
 
       private
 
-      def channel_index_or_nil
-        return @channel_index if @channel_index
-
-        # Pass an explicit descriptor covering every `.rb` file
-        # under the configured channel search paths so the cache
-        # invalidates when channels are added, removed, or edited.
-        # Without it the auto-built descriptor depends on the
-        # `IoBoundary`'s in-process read history — empty on the
-        # first call of a fresh process, so warm cache hits would
-        # serve stale `ChannelIndex` data when project files have
-        # changed between sessions.
-        descriptor = glob_descriptor(@channel_search_paths, "**/*.rb")
-        @channel_index = cache_for(:channel_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @load_error = "rigor-actioncable: failed to discover channels: #{e.class}: #{e.message}"
-        nil
-      end
-
       def load_error_diagnostic(path)
+        error = producer_error(:channel_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-actioncable: failed to discover channels: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_discoverer.rb

@@ -301,19 +301,11 @@ module Rigor
             [entry.method_name, entry]
           end
 
-          # Merge in actions from include'd modules. The
-          # discoverer pre-collected every module's defs as
-          # `module_actions` keyed by fully-qualified module
-          # name. We resolve each include against that map —
-          # tries the full include name first, then walks down
-          # the class's lexical chain looking for a nested
-          # match (e.g. `Emails::Issues` inside `class Notify`
-          # at top-level resolves to top-level `Emails::Issues`).
-          # Includes we cannot resolve are silently skipped;
-          # the per-mailer `unresolved_includes?` predicate
-          # below (consumed by the analyzer) downgrades
-          # `unknown-action` to silence when any include is
-          # unresolved.
+          # Merge actions from include'd modules (pre-collected
+          # in `module_actions` keyed by fully-qualified name).
+          # Unresolvable includes are tracked; `unresolved_includes?`
+          # (consumed by the analyzer) downgrades `unknown-action`
+          # to silence when any include remains unresolved.
           unresolved_includes = []
           includes.each do |include_name|
             inc_actions = module_actions[include_name]

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

@@ -65,7 +65,13 @@ module Rigor
         }
       )
 
-      producer :mailer_index do |_params|
+      # `watch:` covers every mailer class under `mailer_search_paths`
+      # AND every view template under `views_root` (ADR-60 WD3) — a
+      # newly-added view a mailer references must invalidate the index,
+      # and `view_exists?` failures the producer never records would
+      # otherwise be invisible to the dependency descriptor.
+      producer :mailer_index,
+               watch: -> { [[@mailer_search_paths, "**/*.rb"], [@views_root, "**/*"]] } do |_params|
         MailerDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @mailer_search_paths,
@@ -78,8 +84,6 @@ module Rigor
         @mailer_search_paths = Array(config.fetch("mailer_search_paths")).map(&:to_s)
         @mailer_base_classes = Array(config.fetch("mailer_base_classes")).map(&:to_s)
         @views_root = config.fetch("views_root").to_s
-        @mailer_index = nil
-        @load_error = nil
       end
 
       # File-level: load-error + the missing-view check (anchored on the
@@ -88,46 +92,22 @@ module Rigor
       # arity) runs over the engine-owned walk via the node_rule below
       # (ADR-37). The mailer index is lazily loaded + memoised, shared.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = mailer_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:mailer_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:mailer_index)
         return [] if index.nil? || index.empty?
 
         missing_view_diagnostics(path, index)
       end
 
       node_rule Prism::CallNode do |node, _scope, path|
-        index = mailer_index_or_nil
+        index = producer_value(:mailer_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, mailer_index: index).map do |violation|
-          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
-        end
+        diagnostics_for(Analyzer.violations_for(call_node: node, mailer_index: index), path: path, node: node)
       end
 
       private
 
-      def mailer_index_or_nil
-        return @mailer_index if @mailer_index
-
-        # Two-glob descriptor: every mailer class under
-        # `mailer_search_paths` AND every view template under
-        # `views_root`. Without explicit enumeration the cache
-        # invalidates only on files the `IoBoundary` has already
-        # read in the current process — empty on the first call
-        # of a fresh process, so warm hits would serve stale
-        # `MailerIndex` data after mailers are added / removed or
-        # view templates are added (`view_exists?` failures aren't
-        # recorded, so the auto-built descriptor cannot detect a
-        # newly-added view).
-        mailer_d = glob_descriptor(@mailer_search_paths, "**/*.rb")
-        view_d = glob_descriptor([@views_root], "**/*")
-        descriptor = Rigor::Cache::Descriptor.compose(mailer_d, view_d)
-        @mailer_index = cache_for(:mailer_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @load_error = "rigor-actionmailer: failed to discover mailers: #{e.class}: #{e.message}"
-        nil
-      end
-
       # Anchors `missing-view` diagnostics on the mailer file
       # itself: when the file currently being analysed is the
       # mailer's source file, emit one diagnostic per missing
@@ -158,9 +138,10 @@ module Rigor
       end
 
       def load_error_diagnostic(path)
+        error = producer_error(:mailer_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-actionmailer: failed to discover mailers: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

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

@@ -33,9 +33,8 @@ module Rigor
         # Phase 2 — filter-chain DSL methods. Each takes a
         # variadic list of filter names (Symbols / Strings) plus
         # optional `only:` / `except:` / `if:` / `unless:`
-        # modifiers. The validation key is the filter NAMES; the
-        # modifiers are accepted but their action-name argument
-        # is not yet validated (Phase 2.5).
+        # modifiers. Only the filter NAMES are validated; the
+        # `only:`/`except:` action-name arguments are not (deferred).
         FILTER_DSL_METHODS = %i[
           before_action after_action around_action
           skip_before_action skip_after_action skip_around_action
@@ -43,18 +42,14 @@ module Rigor
         ].freeze
 
         # Phase 3 — render-target template extensions checked in
-        # priority order. The first six cover the templating
-        # engines used by the projects this plugin is regularly
-        # exercised against: ERB (Rails default — `.html.erb`,
-        # `.text.erb`), HAML (Mastodon, Solidus admin —
-        # `.html.haml`), Slim, and JSON (`.json.jbuilder` plus a
-        # raw `.json.erb` for hand-rolled API responses). When a
-        # template exists under any of these extensions, the
-        # missing-template diagnostic stays silent.
-        # Configurable extension list is queued — see the
-        # `external-author plugin SKILL` track (v0.2.0). For now
-        # this set is wide enough to cover the surveyed real-world
-        # projects without leaking FPs.
+        # priority order. Covers the engines used by surveyed
+        # projects: ERB (Rails default — `.html.erb`, `.text.erb`),
+        # HAML (Mastodon, Solidus admin — `.html.haml`), Slim, and
+        # JSON (`.json.jbuilder` plus `.json.erb` for hand-rolled API
+        # responses). When a template exists under any of these
+        # extensions, the missing-template diagnostic stays silent.
+        # A configurable extension list is deferred; this set is wide
+        # enough to cover surveyed real-world projects without FPs.
         RENDER_TEMPLATE_EXTENSIONS = %w[
           .html.erb
           .text.erb
@@ -167,8 +162,7 @@ module Rigor
         # list (looked up via the model_index fact published by
         # `rigor-activerecord`). Calls whose `:require` argument is a
         # non-literal Symbol are passed through; namespaced models
-        # (`params.require(:admin_user)` → `Admin::User`) are deferred to a
-        # Phase 1.5 follow-up.
+        # (`params.require(:admin_user)` → `Admin::User`) are deferred.
         #
         # @param call_node [Prism::Node]
         # @param model_index [Hash{String => Hash}]

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

@@ -68,17 +68,14 @@ module Rigor
     class Actionpack < Rigor::Plugin::Base
       manifest(
         id: "actionpack",
-        # Bumped 2026-06-02 — ADR-37 node_rule migration. The four
-        # phases (helper / filter / render / strong-params) now run
-        # per-call over the engine-owned walk instead of the
-        # hand-rolled `diagnostics_for_file` traversal; the enclosing
-        # controller is read from the node-rule `NodeContext` ancestors.
-        # Nested-module qualification is preserved — a
-        # `module Admin; class DomainBlocksController; end` file still
+        # ADR-37: the four phases (helper / filter / render /
+        # strong-params) run per-call over the engine-owned walk;
+        # the enclosing controller is read from the node-rule
+        # `NodeContext` ancestors. Nested-module qualification is
+        # preserved — `module Admin; class DomainBlocksController`
         # resolves as `Admin::DomainBlocksController` (matching the
-        # `ControllerDiscoverer`), so render paths
-        # (`admin/domain_blocks/new`) and filter-chain validation on
-        # nested controllers are unchanged.
+        # `ControllerDiscoverer`), so render paths and filter-chain
+        # validation on nested controllers are correct.
         version: "0.8.0",
         description: "Validates Action Pack route-helper calls and filter chains inside controllers.",
         config_schema: {
@@ -91,27 +88,22 @@ module Rigor
         ]
       )
 
-      # Phase 2 cached producer — the controller index built
-      # from `controller_search_paths`. The IoBoundary records
-      # a `FileEntry` digest for every file the discoverer
-      # reads, so the cache invalidates when any controller
-      # file changes.
-      producer :controller_index do |_params|
+      # Phase 2 cached producer — the controller index built from
+      # `controller_search_paths`. `watch:` (ADR-60 WD3) covers every
+      # `.rb` file under those roots so the cache invalidates when a
+      # controller is added, removed, or edited; the discoverer's
+      # in-block `io_boundary` reads are captured into the dependency
+      # descriptor too, so no explicit priming is needed.
+      producer :controller_index, watch: -> { [[@controller_search_paths, "**/*.rb"]] } do |_params|
         ControllerDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @controller_search_paths
         ).discover
       end
 
-      def init(services)
-        @services = services
+      def init(_services)
         @controller_search_paths = Array(config.fetch("controller_search_paths")).map(&:to_s)
         @view_search_paths = Array(config.fetch("view_search_paths")).map(&:to_s)
-        @helper_table = nil
-        @helper_table_resolved = false
-        @controller_index = nil
-        @model_index_value = nil
-        @model_index_resolved = false
       end
 
       # ADR-37 — the four Action Pack phases run per-call over the
@@ -123,16 +115,16 @@ module Rigor
       # The filter / render phases read the enclosing controller from the
       # node-rule `NodeContext` ancestors (its fifth block argument).
 
-      # Phase 4 — route-helper consumption.
+      # Phase 4 — route-helper consumption. `:helper_table` is
+      # rigor-rails-routes's published fact (ADR-9), read lazily via
+      # `read_fact`.
       node_rule Prism::CallNode do |node, _scope, path|
         next [] unless controller_file?(path)
 
-        table = helper_table
+        table = read_fact(plugin_id: "rails-routes", name: :helper_table)
         next [] if table.nil? || table.empty?
 
-        Analyzer.helper_violations_for(call_node: node, helper_table: table).map do |v|
-          diagnostic(node, path: path, location: v.location, message: v.message, severity: v.severity, rule: v.rule)
-        end
+        diagnostics_for(Analyzer.helper_violations_for(call_node: node, helper_table: table), path: path, node: node)
       end
 
       # Phase 2 — filter-chain validation. Skips silently when the
@@ -141,12 +133,13 @@ module Rigor
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
         next [] unless controller_file?(path)
 
-        index = controller_index_or_nil
+        index = producer_value(:controller_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.filter_violations_for(call_node: node, ancestors: context.ancestors, controller_index: index).map do |v|
-          diagnostic(node, path: path, location: v.location, message: v.message, severity: v.severity, rule: v.rule)
-        end
+        diagnostics_for(
+          Analyzer.filter_violations_for(call_node: node, ancestors: context.ancestors, controller_index: index),
+          path: path, node: node
+        )
       end
 
       # Phase 3 — render-target validation against the configured
@@ -157,12 +150,13 @@ module Rigor
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
         next [] unless controller_file?(path)
 
-        Analyzer.render_violations_for(
-          call_node: node, ancestors: context.ancestors, path: path,
-          view_search_roots: @view_search_paths, controller_index: controller_index_or_nil
-        ).map do |v|
-          diagnostic(node, path: path, location: v.location, message: v.message, severity: v.severity, rule: v.rule)
-        end
+        diagnostics_for(
+          Analyzer.render_violations_for(
+            call_node: node, ancestors: context.ancestors, path: path,
+            view_search_roots: @view_search_paths, controller_index: producer_value(:controller_index)
+          ),
+          path: path, node: node
+        )
       end
 
       # Phase 1 — strong-parameter validation. Reads the `:model_index`
@@ -173,74 +167,14 @@ module Rigor
       node_rule Prism::CallNode do |node, _scope, path|
         next [] unless controller_file?(path)
 
-        index = model_index
+        index = read_fact(plugin_id: "activerecord", name: :model_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.permit_violations_for(call_node: node, model_index: index).map do |v|
-          diagnostic(node, path: path, location: v.location, message: v.message, severity: v.severity, rule: v.rule)
-        end
+        diagnostics_for(Analyzer.permit_violations_for(call_node: node, model_index: index), path: path, node: node)
       end
 
       private
 
-      def controller_index_or_nil
-        return @controller_index if @controller_index
-
-        # Read project source first so the IoBoundary's
-        # FileEntry digests get captured into the descriptor
-        # before `cache_for` snapshots it (mirrors
-        # rigor-rails-routes / rigor-pundit's pattern).
-        prime_io_boundary_for_index
-        @controller_index = cache_for(:controller_index, params: {}).call
-      rescue StandardError
-        nil
-      end
-
-      def prime_io_boundary_for_index
-        @controller_search_paths.each do |root|
-          absolute = File.expand_path(root)
-          next unless File.directory?(absolute)
-
-          Dir.glob(File.join(absolute, "**", "*.rb")).each do |path|
-            io_boundary.read_file(path)
-          rescue Plugin::AccessDeniedError, Errno::ENOENT
-            nil
-          end
-        end
-      end
-
-      # Lazily resolves the helper table from the cross-plugin
-      # fact store. The cache is per-run because the runner
-      # builds a fresh `FactStore` per invocation; memoizing on
-      # the plugin instance saves the per-file `read` while
-      # still picking up a freshly-published table on the next
-      # `bundle exec rigor check` run.
-      def helper_table
-        return @helper_table if @helper_table_resolved
-
-        @helper_table = @services.fact_store.read(
-          plugin_id: "rails-routes", name: :helper_table
-        )
-        @helper_table_resolved = true
-        @helper_table
-      end
-
-      # Phase 1 — lazily reads the cross-plugin :model_index
-      # fact from rigor-activerecord. The cache is per-run
-      # because the runner builds a fresh FactStore per
-      # invocation; memoizing on the plugin instance saves the
-      # per-file read while still picking up a freshly
-      # published index on the next `bundle exec rigor check`.
-      def model_index
-        return @model_index_value if @model_index_resolved
-
-        @model_index_value = @services.fact_store.read(
-          plugin_id: "activerecord", name: :model_index
-        )
-        @model_index_resolved = true
-        @model_index_value
-      end
-
       def controller_file?(path)
         @controller_search_paths.any? do |root|
           # The runner may pass `path` as either an absolute

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/job_index.rb

@@ -12,8 +12,9 @@ module Rigor
       # (`Float::INFINITY` for the upper bound when `*args`
       # is present). `keyword_required` lists any required
       # keyword arguments — Active Job supports keyword args
-      # but they're rare in user code, so the analyzer only
-      # validates positional arity for v0.1.0.
+      # but they're rare in user code, so the analyzer
+      # validates positional arity only (keyword arity
+      # validation is deferred).
       class JobIndex
         Entry = Data.define(:class_name, :min_arity, :max_arity, :keyword_required) do
           # Flexible-friendly textual form of the arity for

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

@@ -48,12 +48,12 @@ module Rigor
         }
       )
 
-      # Cached: discovered job index. The producer reads every
-      # file under `job_search_paths` via the trusted
-      # `IoBoundary`; the descriptor's auto-collected
-      # `FileEntry` digests invalidate the cache when any of
-      # those files change.
-      producer :job_index do |_params|
+      # Cached: discovered job index. `watch:` (ADR-60 WD3) covers
+      # every `.rb` under `job_search_paths` so the cache invalidates
+      # when a job is added, removed, or edited; the discoverer's
+      # in-block `IoBoundary` reads are captured into the record-and-
+      # validate dependency descriptor after the block runs.
+      producer :job_index, watch: -> { [[@job_search_paths, "**/*.rb"]] } do |_params|
         JobDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @job_search_paths,
@@ -64,50 +64,33 @@ module Rigor
       def init(_services)
         @job_search_paths = Array(config.fetch("job_search_paths")).map(&:to_s)
         @job_base_classes = Array(config.fetch("job_base_classes")).map(&:to_s)
-        @job_index = nil
-        @load_error = nil
       end
 
       # File-level only: the load-error emission. Per-call arity
       # validation runs over the engine-owned walk via the node_rule
       # below (ADR-37). The job index is lazily loaded + memoised by
-      # job_index_or_nil, shared by both surfaces.
+      # `producer_value`, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = job_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:job_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:job_index)
 
         []
       end
 
       node_rule Prism::CallNode do |node, _scope, path|
-        index = job_index_or_nil
+        index = producer_value(:job_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, job_index: index).map do |violation|
-          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
-        end
+        diagnostics_for(Analyzer.violations_for(call_node: node, job_index: index), path: path, node: node)
       end
 
       private
 
-      def job_index_or_nil
-        return @job_index if @job_index
-
-        # Read-then-cache pattern: the discoverer's
-        # IoBoundary reads happen INSIDE `discover`, which is
-        # invoked through `cache_for`'s producer block. The
-        # boundary's accumulated FileEntry digests get
-        # captured into the descriptor at cache_for time.
-        @job_index = cache_for(:job_index, params: {}).call
-      rescue StandardError => e
-        @load_error = "rigor-activejob: failed to discover jobs: #{e.class}: #{e.message}"
-        nil
-      end
-
       def load_error_diagnostic(path)
+        error = producer_error(:job_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-activejob: failed to discover jobs: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

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

@@ -227,8 +227,8 @@ module Rigor
         # Recognised single-instance and collection association
         # DSL methods. The kind drives the eventual return-type
         # contribution: singular associations narrow to
-        # `Nominal[Target] | nil`, plural ones currently degrade
-        # to the RBS envelope (relation types are a future track).
+        # `Nominal[Target] | nil`, plural ones narrow to
+        # `ActiveRecord::Relation[Target]`.
         #
         # `composed_of` value-object aggregations and
         # `delegated_type` roles are folded in here too — both
@@ -447,8 +447,8 @@ module Rigor
 
         # `scope :active, -> { ... }`. Records the scope name
         # only (the body is intentionally NOT introspected —
-        # scopes return ActiveRecord::Relation, which Rigor
-        # doesn't carry a precise type for yet).
+        # the caller contributes `ActiveRecord::Relation[Model]`
+        # based on the name alone via `class_scope_return_type`).
         def lookup_scopes(body)
           return [] if body.nil?