rigortype 0.1.17 → 0.1.19

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

@@ -365,8 +365,7 @@ module Rigor
             next unless arg.is_a?(Prism::KeywordHashNode)
 
             arg.elements.each do |pair|
-              next unless pair.is_a?(Prism::AssocNode) && pair.key.is_a?(Prism::SymbolNode)
-              next unless pair.key.unescaped == key
+              next unless pair.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(pair.key, key)
 
               return true if pair.value.is_a?(Prism::TrueNode)
               return false if pair.value.is_a?(Prism::FalseNode)
@@ -380,8 +379,7 @@ module Rigor
             next unless arg.is_a?(Prism::KeywordHashNode)
 
             arg.elements.each do |pair|
-              next unless pair.is_a?(Prism::AssocNode) && pair.key.is_a?(Prism::SymbolNode)
-              next unless pair.key.unescaped == "class_name"
+              next unless pair.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(pair.key, "class_name")
               next unless pair.value.is_a?(Prism::StringNode)
 
               return pair.value.unescaped

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
@@ -101,8 +103,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,
@@ -197,45 +202,83 @@ module Rigor
         MIGRATION_PATH_PATTERNS.any? { |pattern| path_s.match?(pattern) }
       end
 
-      # v0.1.2 — return-type contribution. `Model.find(id)`
-      # narrows the call site's return type to `Nominal[Model]`,
-      # so chained calls (`User.find(1).name`) resolve through
-      # the analyzer's normal dispatch instead of the RBS-level
-      # untyped fall-back. `Model.find_by(...)` narrows to
-      # `Nominal[Model] | nil` because Rails returns nil when no
-      # row matches. `where` / `find_or_*` are intentionally
-      # deferred — they return relations, and Rigor does not yet
-      # carry an Enumerable-backed relation shape that would be
-      # more precise than the RBS envelope.
-      def flow_contribution_for(call_node:, scope:)
+      # The class-side finder / relation entry-point names
+      # `finder_return_type` recognises. Static half of the
+      # `dynamic_return` name gate; the run-time half comes from
+      # the model index (scopes, associations, columns).
+      FINDER_METHOD_NAMES = %i[find find_by! find_by where all order limit none select].freeze
+      private_constant :FINDER_METHOD_NAMES
+
+      # v0.1.2 — return-type contribution; ADR-52 slice 5b —
+      # migrated off `flow_contribution_for` onto the run-time
+      # `methods:` name gate. `Model.find(id)` narrows the call
+      # site's return type to `Nominal[Model]`, so chained calls
+      # (`User.find(1).name`) resolve through the analyzer's
+      # normal dispatch instead of the RBS-level untyped
+      # fall-back; scopes, association accessors, and column
+      # readers narrow per the paths below.
+      #
+      # WHY a method-name gate and not `receivers:` — the ADR-52
+      # "rigor-activerecord blocker": a project model not in RBS
+      # types its constant as `Dynamic[top]`, so a receiver-type
+      # gate declines exactly the calls this plugin exists for. A
+      # *name* gate never reads the receiver type; the block keeps
+      # the plugin's own AST-constant / `self_type` / `type_of`
+      # resolution, so the Dynamic-constant case still reaches it
+      # (the same shape as rigor-sorbet's catalog path). The set —
+      # the static finder names ∪ every scope, association, and
+      # column name (plus `column?` predicate forms) the model
+      # index discovered — is exactly the union of names the four
+      # resolution paths below can return a type for, so gating on
+      # it is byte-identical to the old ungated hook. It is broad
+      # (`name`, `id`, …), but membership is one Set probe and the
+      # expensive block runs only on candidate hits.
+      dynamic_return methods: -> { recognised_method_names } do |call_node, scope|
+        contribution_return_type(call_node, scope)
+      end
+
+      private
+
+      # The run-time name gate: finders ∪ scopes ∪ associations ∪
+      # column readers (+ `?` predicates). Resolved lazily on first
+      # dispatch (after `#prepare` built the index), memoised by the
+      # engine. Returns [] when discovery found nothing — the gate
+      # then declines every call, matching the old hook's
+      # `index.nil? || index.empty?` early return.
+      def recognised_method_names
+        index = model_index
+        return [] if index.nil? || index.empty?
+
+        names = FINDER_METHOD_NAMES.dup
+        index.entries.each_value do |entry|
+          names.concat(entry.scopes.map(&:to_sym))
+          names.concat(entry.association_names.map(&:to_sym))
+          entry.column_names.each do |column|
+            names << column.to_sym
+            names << :"#{column}?"
+          end
+        end
+        names
+      end
+
+      # The migrated body of the legacy `flow_contribution_for` —
+      # same resolution order, returning the bare type the
+      # `dynamic_return` contract expects.
+      def contribution_return_type(call_node, scope)
         return nil unless call_node.is_a?(Prism::CallNode)
 
         index = model_index
         return nil if index.nil? || index.empty?
 
-        return_type =
-          if call_node.receiver
-            class_call_return_type(call_node, index) ||
-              relation_call_return_type(call_node, scope, index) ||
-              instance_call_return_type(call_node, scope, index)
-          else
-            implicit_self_class_call_return_type(call_node, scope, index)
-          end
-        return nil if return_type.nil?
-
-        Rigor::FlowContribution.new(
-          return_type: return_type,
-          provenance: Rigor::FlowContribution::Provenance.new(
-            source_family: "plugin.#{manifest.id}",
-            plugin_id: manifest.id,
-            node: call_node,
-            descriptor: nil
-          )
-        )
+        if call_node.receiver
+          class_call_return_type(call_node, index) ||
+            relation_call_return_type(call_node, scope, index) ||
+            instance_call_return_type(call_node, scope, index)
+        else
+          implicit_self_class_call_return_type(call_node, scope, index)
+        end
       end
 
-      private
-
       def class_call_return_type(call_node, index)
         model_name = constant_receiver_name(call_node.receiver)
         return nil if model_name.nil?
@@ -533,16 +576,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}"
@@ -561,9 +599,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

@@ -12,7 +12,7 @@ module Rigor
       # attachment mapping the plugin sees.
       #
       # No `:error` diagnostics in this slice — the
-      # `flow_contribution_for` return-type narrowing carries
+      # `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
@@ -50,8 +50,8 @@ module Rigor
           return if attachments.nil?
 
           # Only flag when the method matches a known
-          # attachment name (the `flow_contribution_for`
-          # tier provides the narrowing; the diagnostic just
+          # attachment name (the `dynamic_return` rule
+          # provides the narrowing; the diagnostic just
           # confirms the recognition).
           attachment = attachments.find { |a| a[:name] == node.name.to_s }
           return if attachment.nil?

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
@@ -79,47 +82,41 @@ module Rigor
 
       # Return-type contribution: when the receiver is
       # `Nominal[Model]` and the method matches a discovered
-      # attachment, narrow to
+      # attachment, narrows to
       # `Nominal[ActiveStorage::Attached::One]` (singular) or
-      # `Nominal[ActiveStorage::Attached::Many]` (collection).
+      # `Nominal[ActiveStorage::Attached::Many]` (collection)
+      # via a `dynamic_return` rule keyed on the live set of
+      # model class names from the attachment index.
       # The chained call (`.attached?`, `.purge`, `.url`)
       # then resolves through ActiveStorage's RBS surface.
       # Attachment setters (`user.avatar=`) decline — they
       # take side-effecting argument types that the RBS
       # surface already covers.
-      def flow_contribution_for(call_node:, scope:)
-        return nil unless call_node.is_a?(Prism::CallNode)
-        return nil if call_node.receiver.nil?
-        return nil unless call_node.arguments.nil?
+      dynamic_return receivers: -> { attachment_index&.class_names || [] } do |call_node, scope|
+        next nil unless call_node.is_a?(Prism::CallNode)
+        next nil if call_node.receiver.nil?
+        next nil unless call_node.arguments.nil?
 
         index = attachment_index
-        return nil if index.nil? || index.empty?
+        next nil if index.nil? || index.empty?
 
         receiver_type = scope.type_of(call_node.receiver)
-        return nil unless receiver_type.is_a?(Rigor::Type::Nominal)
+        next nil unless receiver_type.is_a?(Rigor::Type::Nominal)
 
         attachments = index.attachments_for(receiver_type.class_name) ||
                       index.attachments_for("::#{receiver_type.class_name}")
-        return nil if attachments.nil?
+        next nil if attachments.nil?
 
         attachment = attachments.find { |a| a[:name] == call_node.name.to_s }
-        return nil if attachment.nil?
+        next nil if attachment.nil?
 
         target = case attachment[:kind]
                  when :singular then "ActiveStorage::Attached::One"
                  when :collection then "ActiveStorage::Attached::Many"
                  end
-        return nil if target.nil?
-
-        Rigor::FlowContribution.new(
-          return_type: Rigor::Type::Combinator.nominal_of(target),
-          provenance: Rigor::FlowContribution::Provenance.new(
-            source_family: "plugin.#{manifest.id}",
-            plugin_id: manifest.id,
-            node: call_node,
-            descriptor: nil
-          )
-        )
+        next nil if target.nil?
+
+        Rigor::Type::Combinator.nominal_of(target)
       end
 
       # @!visibility private
@@ -132,12 +129,11 @@ 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 — so no
+        # priming walk is needed (it used to run the discover twice).
         @attachment_index = cache_for(:attachment_index, params: {}).call
       rescue Plugin::AccessDeniedError => e
         @load_errors << "rigor-activestorage: #{e.message}"

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext.rb

@@ -5,7 +5,7 @@ require "rigor/plugin"
 module Rigor
   module Plugin
     # ADR-25 — a pure RBS-bundle plugin. It ships NO analyzer code:
-    # no `diagnostics_for_file`, no `flow_contribution_for`. Its
+    # no `diagnostics_for_file`, no `dynamic_return`. Its
     # whole contribution is the manifest's `signature_paths: ["sig"]`,
     # which declares the bundled ActiveSupport `core_ext` RBS
     # directory. `Plugin::Loader` resolves that directory against

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

@@ -146,8 +146,7 @@ module Rigor
 
           class_pair = kwargs.elements.find do |elem|
             elem.is_a?(Prism::AssocNode) &&
-              elem.key.is_a?(Prism::SymbolNode) &&
-              elem.key.value == "class"
+              Source::Literals.symbol_named?(elem.key, "class")
           end
           return nil if class_pair.nil?
 

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

@@ -87,19 +87,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 +104,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

@@ -281,7 +281,7 @@ module Rigor
           return false unless kwargs.is_a?(Prism::KeywordHashNode)
 
           pair = kwargs.elements.find do |el|
-            el.is_a?(Prism::AssocNode) && el.key.is_a?(Prism::SymbolNode) && el.key.unescaped == "required"
+            el.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(el.key, "required")
           end
           return false if pair.nil?
 
@@ -364,7 +364,7 @@ module Rigor
           return true unless kwargs.is_a?(Prism::KeywordHashNode)
 
           null_pair = kwargs.elements.find do |el|
-            el.is_a?(Prism::AssocNode) && el.key.is_a?(Prism::SymbolNode) && el.key.unescaped == "null"
+            el.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(el.key, "null")
           end
           return true if null_pair.nil?
 

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

@@ -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-pundit/lib/rigor/plugin/pundit.rb

@@ -66,7 +66,7 @@ module Rigor
         }
       )
 
-      producer :policy_index do |_params|
+      producer :policy_index, watch: -> { [[@policy_search_paths, "**/*.rb"]] } do |_params|
         PolicyDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @policy_search_paths,
@@ -77,46 +77,35 @@ module Rigor
       def init(_services)
         @policy_search_paths = Array(config.fetch("policy_search_paths")).map(&:to_s)
         @policy_base_classes = Array(config.fetch("policy_base_classes")).map(&:to_s)
-        @policy_index = nil
-        @load_error = nil
       end
 
       # File-level only: the load-error emission. The per-call policy
       # validation runs over the engine-owned walk via the node_rule
       # below (ADR-37). The index is lazily loaded + memoised by
-      # policy_index_or_nil, so both surfaces share one load.
+      # `producer_value`, so both surfaces share one load.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = policy_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:policy_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:policy_index)
 
         []
       end
 
       node_rule Prism::CallNode do |node, scope, path|
-        index = policy_index_or_nil
+        index = producer_value(:policy_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, policy_index: index, scope: scope).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, policy_index: index, scope: scope), path: path, node: node
+        )
       end
 
       private
 
-      def policy_index_or_nil
-        return @policy_index if @policy_index
-
-        descriptor = glob_descriptor(@policy_search_paths, "**/*.rb")
-        @policy_index = cache_for(:policy_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @load_error = "rigor-pundit: failed to discover policies: #{e.class}: #{e.message}"
-        nil
-      end
-
       def load_error_diagnostic(path)
+        error = producer_error(:policy_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-pundit: failed to discover policies: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )