rigortype 0.1.15 → 0.1.16

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

@@ -68,22 +68,22 @@ module Rigor
     class Actionpack < Rigor::Plugin::Base
       manifest(
         id: "actionpack",
-        # Bumped 2026-05-27 — analyzer-side nested-module
-        # qualification slice. `diagnose_filters` and
-        # `diagnose_renders` now thread the enclosing
-        # namespace through the AST walk so a
-        # `module Admin; class DomainBlocksController; end`
-        # file resolves as `Admin::DomainBlocksController`
-        # — matching the qualification the
-        # `ControllerDiscoverer` already records. Fixes render
-        # paths (`admin/domain_blocks/new` not bare
-        # `domain_blocks/new`) and filter-chain validation
-        # silently skipping nested controllers.
-        version: "0.7.0",
+        # 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
+        # resolves as `Admin::DomainBlocksController` (matching the
+        # `ControllerDiscoverer`), so render paths
+        # (`admin/domain_blocks/new`) and filter-chain validation on
+        # nested controllers are unchanged.
+        version: "0.8.0",
         description: "Validates Action Pack route-helper calls and filter chains inside controllers.",
         config_schema: {
-          "controller_search_paths" => :array,
-          "view_search_paths" => :array
+          "controller_search_paths" => { kind: :array, default: ["app/controllers"] },
+          "view_search_paths" => { kind: :array, default: ["app/views"] }
         },
         consumes: [
           { plugin_id: "rails-routes", name: :helper_table, optional: true },
@@ -91,9 +91,6 @@ module Rigor
         ]
       )
 
-      DEFAULT_CONTROLLER_SEARCH_PATHS = ["app/controllers"].freeze
-      DEFAULT_VIEW_SEARCH_PATHS = ["app/views"].freeze
-
       # Phase 2 cached producer — the controller index built
       # from `controller_search_paths`. The IoBoundary records
       # a `FileEntry` digest for every file the discoverer
@@ -108,12 +105,8 @@ module Rigor
 
       def init(services)
         @services = services
-        @controller_search_paths = Array(
-          config.fetch("controller_search_paths", DEFAULT_CONTROLLER_SEARCH_PATHS)
-        ).map(&:to_s)
-        @view_search_paths = Array(
-          config.fetch("view_search_paths", DEFAULT_VIEW_SEARCH_PATHS)
-        ).map(&:to_s)
+        @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
@@ -121,63 +114,75 @@ module Rigor
         @model_index_resolved = false
       end
 
-      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        return [] unless controller_file?(path)
-
-        helper_diagnostics(path, root) +
-          filter_diagnostics(path, root) +
-          render_diagnostics(path, root) +
-          permit_diagnostics(path, root)
-      end
+      # ADR-37 — the four Action Pack phases run per-call over the
+      # engine-owned walk. Each rule gates on `controller_file?(path)` (the
+      # plugin only validates files under `controller_search_paths`,
+      # exactly as the former `diagnostics_for_file` top-level guard did),
+      # then delegates to a per-node `Analyzer.*_violations_for` and
+      # positions each location-free `Violation` with `Base#diagnostic`.
+      # The filter / render phases read the enclosing controller from the
+      # node-rule `NodeContext` ancestors (its fifth block argument).
 
-      private
+      # Phase 4 — route-helper consumption.
+      node_rule Prism::CallNode do |node, _scope, path|
+        next [] unless controller_file?(path)
 
-      def helper_diagnostics(path, root)
         table = helper_table
-        return [] if table.nil? || table.empty?
+        next [] if table.nil? || table.empty?
 
-        Analyzer.diagnose(path: path, root: root, helper_table: table)
-                .map { |diag| build_diagnostic(diag) }
+        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
       end
 
-      # Phase 2 — runs the filter-chain validator over the
-      # controller's class body using the cached
-      # {ControllerIndex}. Skips silently when the index is
-      # absent or doesn't recognise the file's top-level class.
-      def filter_diagnostics(path, root)
+      # Phase 2 — filter-chain validation. Skips silently when the
+      # controller index is absent or doesn't recognise the enclosing
+      # class.
+      node_rule Prism::CallNode do |node, _scope, path, _fc, context|
+        next [] unless controller_file?(path)
+
         index = controller_index_or_nil
-        return [] if index.nil? || index.empty?
+        next [] if index.nil? || index.empty?
 
-        Analyzer.diagnose_filters(path: path, root: root, controller_index: index)
-                .map { |diag| build_diagnostic(diag) }
+        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
       end
 
-      # Phase 3 — runs the render-target validator against the
-      # configured `view_search_paths`. Always invoked
-      # regardless of whether the controller is in the index;
-      # render shapes are recognised purely from the call site
-      # + class name, no per-controller pre-discovery needed.
-      def render_diagnostics(path, root)
-        Analyzer.diagnose_renders(
-          path: path, root: root,
-          view_search_roots: @view_search_paths,
-          controller_index: controller_index_or_nil
-        ).map { |diag| build_diagnostic(diag) }
+      # Phase 3 — render-target validation against the configured
+      # `view_search_paths`. Recognised purely from the call site + the
+      # enclosing controller name, so no per-controller pre-discovery is
+      # needed; the controller index is consulted only to suppress
+      # gem-shipped-view false positives.
+      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
       end
 
-      # Phase 1 — strong-parameter validation. Reads the
-      # `:model_index` fact from the cross-plugin fact store
-      # (published by rigor-activerecord) and validates every
-      # `params.require(:user).permit(:name, :email)` chain
-      # against the User model's column list.
-      def permit_diagnostics(path, root)
+      # Phase 1 — strong-parameter validation. Reads the `:model_index`
+      # fact from the cross-plugin fact store (published by
+      # rigor-activerecord) and validates every
+      # `params.require(:user).permit(:name, :email)` chain against the
+      # User model's column list.
+      node_rule Prism::CallNode do |node, _scope, path|
+        next [] unless controller_file?(path)
+
         index = model_index
-        return [] if index.nil? || index.empty?
+        next [] if index.nil? || index.empty?
 
-        Analyzer.diagnose_permits(path: path, root: root, model_index: index)
-                .map { |diag| build_diagnostic(diag) }
+        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
       end
 
+      private
+
       def controller_index_or_nil
         return @controller_index if @controller_index
 
@@ -247,13 +252,6 @@ module Rigor
           path.include?("/#{root}/") || path.start_with?("#{root}/") || path == root
         end
       end
-
-      def build_diagnostic(diag)
-        Rigor::Analysis::Diagnostic.new(
-          path: diag.path, line: diag.line, column: diag.column,
-          message: diag.message, severity: diag.severity, rule: diag.rule
-        )
-      end
     end
 
     Rigor::Plugin.register(Actionpack)

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

@@ -23,35 +23,33 @@ module Rigor
         # the bare execution path.
         ENTRY_METHODS = %i[perform_later perform_now perform].freeze
 
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One job-call observation. Carries no path/location — the
+        # caller (the `node_rule` block) positions it via
+        # `Plugin::Base#diagnostic`.
+        Violation = Struct.new(:rule, :severity, :message, keyword_init: true)
 
         module_function
 
-        # @param path [String]
-        # @param root [Prism::Node]
+        # The job-call violations for a single call node (0..2), or `[]`
+        # when the node is not a `<Job>.perform_*` entry call on a known
+        # job. ADR-37: the engine owns the walk.
+        #
+        # @param call_node [Prism::Node]
         # @param job_index [JobIndex]
-        # @return [Array<Diagnostic>]
-        def diagnose(path:, root:, job_index:)
-          diagnostics = []
-          walk(root) do |call_node|
-            class_name = constant_receiver_name(call_node.receiver)
-            next if class_name.nil?
+        # @return [Array<Violation>]
+        def violations_for(call_node:, job_index:)
+          return [] unless call_node.is_a?(Prism::CallNode) && entry_call?(call_node)
 
-            entry = job_index.find(class_name) || job_index.find("::#{class_name}")
-            next if entry.nil?
+          class_name = constant_receiver_name(call_node.receiver)
+          return [] if class_name.nil?
 
-            diagnostics << info_diagnostic(path, call_node, entry)
-            arity = arity_check(path, call_node, entry)
-            diagnostics << arity if arity
-          end
-          diagnostics
-        end
-
-        def walk(node, &)
-          return unless node.is_a?(Prism::Node)
+          entry = job_index.find(class_name) || job_index.find("::#{class_name}")
+          return [] if entry.nil?
 
-          yield node if node.is_a?(Prism::CallNode) && entry_call?(node)
-          node.compact_child_nodes.each { |child| walk(child, &) }
+          violations = [info_violation(call_node, entry)]
+          arity = arity_violation(call_node, entry)
+          violations << arity if arity
+          violations
         end
 
         def entry_call?(node)
@@ -59,27 +57,19 @@ module Rigor
             (node.receiver.is_a?(Prism::ConstantReadNode) || node.receiver.is_a?(Prism::ConstantPathNode))
         end
 
-        def info_diagnostic(path, call_node, entry)
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+        def info_violation(call_node, entry)
+          Violation.new(
             severity: :info,
             rule: "job-call",
             message: "`#{entry.class_name}.#{call_node.name}` matches `#perform` (arity #{entry.arity_label})"
           )
         end
 
-        def arity_check(path, call_node, entry)
+        def arity_violation(call_node, entry)
           actual = (call_node.arguments&.arguments || []).size
           return nil if entry.accepts?(actual)
 
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "wrong-arity",
             message: "`#{entry.class_name}.#{call_node.name}` expects #{entry.arity_label} argument(s), got #{actual}"

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

@@ -43,14 +43,11 @@ module Rigor
         version: "0.1.0",
         description: "Validates ActiveJob `Job.perform_later` argument arity.",
         config_schema: {
-          "job_search_paths" => :array,
-          "job_base_classes" => :array
+          "job_search_paths" => { kind: :array, default: ["app/jobs"] },
+          "job_base_classes" => { kind: :array, default: %w[ApplicationJob ActiveJob::Base] }
         }
       )
 
-      DEFAULT_JOB_SEARCH_PATHS = ["app/jobs"].freeze
-      DEFAULT_JOB_BASE_CLASSES = %w[ApplicationJob ActiveJob::Base].freeze
-
       # Cached: discovered job index. The producer reads every
       # file under `job_search_paths` via the trusted
       # `IoBoundary`; the descriptor's auto-collected
@@ -65,18 +62,30 @@ module Rigor
       end
 
       def init(_services)
-        @job_search_paths = Array(config.fetch("job_search_paths", DEFAULT_JOB_SEARCH_PATHS)).map(&:to_s)
-        @job_base_classes = Array(config.fetch("job_base_classes", DEFAULT_JOB_BASE_CLASSES)).map(&:to_s)
+        @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.
       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
-        return [] if index.nil? || index.empty?
 
-        Analyzer.diagnose(path: path, root: root, job_index: index).map { |diag| build_diagnostic(diag) }
+        []
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path|
+        index = job_index_or_nil
+        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
       end
 
       private
@@ -103,13 +112,6 @@ module Rigor
           rule: "load-error"
         )
       end
-
-      def build_diagnostic(diag)
-        Rigor::Analysis::Diagnostic.new(
-          path: diag.path, line: diag.line, column: diag.column,
-          message: diag.message, severity: diag.severity, rule: diag.rule
-        )
-      end
     end
 
     Rigor::Plugin.register(Activejob)

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

@@ -36,8 +36,6 @@ module Rigor
           create_or_find_by create_or_find_by!
         ].freeze
 
-        DID_YOU_MEAN_DISTANCE = 3
-
         attr_reader :diagnostics
 
         def initialize(path:, model_index:)
@@ -107,7 +105,7 @@ module Rigor
           else
             unknown.each do |pair|
               key = pair[:key]
-              suggestion = closest_column(key, entry.column_names)
+              suggestion = Rigor::Plugin::Base.suggest(key, entry.column_names)
               hint = suggestion ? " (did you mean `:#{suggestion}`?)" : ""
               push_error(node, "unknown-column",
                          "`#{entry.class_name}.#{node.name}(#{key}: ...)` references " \
@@ -157,7 +155,7 @@ module Rigor
           values = entry.enum_values(pair[:key])
           return if values.include?(value)
 
-          suggestion = closest_column(value, values)
+          suggestion = Rigor::Plugin::Base.suggest(value, values)
           hint = suggestion ? " (did you mean `:#{suggestion}`?)" : ""
           push_error(node, "unknown-enum-value",
                      "`#{entry.class_name}.#{node.name}(#{pair[:key]}: :#{value})` references " \
@@ -224,40 +222,6 @@ module Rigor
           pairs
         end
 
-        def closest_column(name, candidates)
-          best = nil
-          best_distance = DID_YOU_MEAN_DISTANCE + 1
-          candidates.each do |candidate|
-            distance = levenshtein(name, candidate)
-            if distance < best_distance
-              best = candidate
-              best_distance = distance
-            end
-          end
-          best
-        end
-
-        def levenshtein(a, b) # rubocop:disable Naming/MethodParameterName
-          return b.length if a.empty?
-          return a.length if b.empty?
-
-          rows = Array.new(a.length + 1) { |_i| Array.new(b.length + 1, 0) }
-          (0..a.length).each { |i| rows[i][0] = i }
-          (0..b.length).each { |j| rows[0][j] = j }
-
-          (1..a.length).each do |i|
-            (1..b.length).each do |j|
-              cost = a[i - 1] == b[j - 1] ? 0 : 1
-              rows[i][j] = [
-                rows[i - 1][j] + 1,
-                rows[i][j - 1] + 1,
-                rows[i - 1][j - 1] + cost
-              ].min
-            end
-          end
-          rows[a.length][b.length]
-        end
-
         def push_info(node, rule, message)
           push_diagnostic(node, severity: :info, rule: rule, message: message)
         end
@@ -267,14 +231,8 @@ module Rigor
         end
 
         def push_diagnostic(node, severity:, rule:, message:)
-          location = node.location
-          @diagnostics << Rigor::Analysis::Diagnostic.new(
-            path: @path,
-            line: location.start_line,
-            column: location.start_column + 1,
-            message: message,
-            severity: severity,
-            rule: rule
+          @diagnostics << Rigor::Analysis::Diagnostic.from_node(
+            node, path: @path, message: message, severity: severity, rule: rule
           )
         end
       end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 module Rigor
   module Plugin
@@ -312,10 +313,9 @@ module Rigor
           args = node.arguments&.arguments
           return nil if args.nil? || args.empty?
 
-          name_node = args.first
-          return nil unless name_node.is_a?(Prism::SymbolNode)
+          name = Rigor::Source::Literals.symbol_name(args.first)
+          return nil if name.nil?
 
-          name = name_node.unescaped
           polymorphic = POLYMORPHIC_BY_DEFAULT.include?(node.name) ||
                         association_option(args, "polymorphic") == true
 
@@ -326,7 +326,7 @@ module Rigor
           if polymorphic
             target = nil
           else
-            target = explicit_class_name(args) || Inflector.classify(name)
+            target = explicit_class_name(args) || Rigor::Plugin::Inflector.classify(name)
             return nil if target.nil? || target.empty?
           end
 

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

@@ -153,7 +153,7 @@ module Rigor
             override = row[:table_name_override]
             return override if override
           end
-          Inflector.tableize(strip_leading_namespace(chain.first.fetch(:class_name)))
+          Rigor::Plugin::Inflector.tableize(strip_leading_namespace(chain.first.fetch(:class_name)))
         end
 
         # Dedups association-style rows by `:name`, keeping the

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

@@ -2,7 +2,6 @@
 
 require "rigor/plugin"
 
-require_relative "activerecord/inflector"
 require_relative "activerecord/schema_table"
 require_relative "activerecord/schema_parser"
 require_relative "activerecord/model_index"
@@ -69,9 +68,9 @@ module Rigor
         version: "0.5.0",
         description: "Types ActiveRecord finders against the project's db/schema.rb and AR models.",
         config_schema: {
-          "schema_file" => :string,
-          "model_search_paths" => :array,
-          "model_base_classes" => :array
+          "schema_file" => { kind: :string, default: "db/schema.rb" },
+          "model_search_paths" => { kind: :array, default: ["app/models"] },
+          "model_base_classes" => { kind: :array, default: %w[ApplicationRecord ActiveRecord::Base] }
         },
         produces: [:model_index],
         # ADR-25 — the bundled `ActiveRecord::Relation` RBS, the
@@ -87,10 +86,6 @@ module Rigor
         open_receivers: ["ActiveRecord::Relation"]
       )
 
-      DEFAULT_SCHEMA_FILE = "db/schema.rb"
-      DEFAULT_MODEL_SEARCH_PATHS = ["app/models"].freeze
-      DEFAULT_MODEL_BASE_CLASSES = %w[ApplicationRecord ActiveRecord::Base].freeze
-
       # The class the bundled `sig/active_record/relation.rbs`
       # describes; `flow_contribution_for` contributes
       # `ActiveRecord::Relation[Model]` for relation-returning
@@ -117,10 +112,11 @@ module Rigor
       end
 
       def init(_services)
-        @schema_file = config.fetch("schema_file", DEFAULT_SCHEMA_FILE)
-        @model_search_paths = Array(config.fetch("model_search_paths", DEFAULT_MODEL_SEARCH_PATHS)).map(&:to_s)
-        @model_base_classes = Array(config.fetch("model_base_classes", DEFAULT_MODEL_BASE_CLASSES)).map(&:to_s)
+        @schema_file = config.fetch("schema_file")
+        @model_search_paths = Array(config.fetch("model_search_paths")).map(&:to_s)
+        @model_base_classes = Array(config.fetch("model_base_classes")).map(&:to_s)
         @schema_table = nil
+        @schema_load_attempted = false
         @model_index = nil
         @load_errors = []
       end
@@ -555,7 +551,16 @@ module Rigor
 
       def schema_table_or_nil
         return @schema_table if @schema_table
-
+        # Memoize the *failure*, not just the success: `model_index`
+        # (and thus this method) is invoked per AR call site, so a
+        # missing / unreadable schema file would otherwise re-attempt
+        # the read and append a fresh interpolated error string to
+        # `@load_errors` on every call. On a large Rails app that grew
+        # `@load_errors` to millions of retained strings (measured: 4.2 M
+        # strings / ~1.5 GB on Redmine). One attempt is enough.
+        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)

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

@@ -62,14 +62,8 @@ module Rigor
         end
 
         def push_info(node, rule, message)
-          location = node.location
-          @diagnostics << Rigor::Analysis::Diagnostic.new(
-            path: @path,
-            line: location.start_line,
-            column: location.start_column + 1,
-            message: message,
-            severity: :info,
-            rule: rule
+          @diagnostics << Rigor::Analysis::Diagnostic.from_node(
+            node, path: @path, message: message, severity: :info, rule: rule
           )
         end
       end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 module Rigor
   module Plugin
@@ -126,13 +127,7 @@ module Rigor
         end
 
         def symbol_literal_arg(node)
-          args = node.arguments&.arguments
-          return nil if args.nil? || args.empty?
-
-          first = args.first
-          return nil unless first.is_a?(Prism::SymbolNode)
-
-          first.unescaped
+          Rigor::Source::Literals.symbol_name(node.arguments&.arguments&.first)
         end
 
         def constant_path_name(node)

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

@@ -48,13 +48,11 @@ module Rigor
         version: "0.1.0",
         description: "Types ActiveStorage attachment macros (has_one_attached / has_many_attached) on AR models.",
         config_schema: {
-          "model_search_paths" => :array
+          "model_search_paths" => { kind: :array, default: ["app/models"] }
         },
         consumes: [{ plugin_id: "activerecord", name: :model_index, optional: true }]
       )
 
-      DEFAULT_MODEL_SEARCH_PATHS = ["app/models"].freeze
-
       # Cached: attachment index. Walks every `.rb` file under
       # `model_search_paths` for `has_*_attached` macros.
       producer :attachment_index do |_params|
@@ -66,9 +64,7 @@ module Rigor
       end
 
       def init(_services)
-        @model_search_paths = Array(
-          config.fetch("model_search_paths", DEFAULT_MODEL_SEARCH_PATHS)
-        ).map(&:to_s)
+        @model_search_paths = Array(config.fetch("model_search_paths")).map(&:to_s)
         @attachment_index = nil
         @load_errors = []
       end

data/plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema/schema_scanner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 module Rigor
   module Plugin
@@ -187,10 +188,10 @@ module Rigor
           current = node
           while current.is_a?(Prism::CallNode)
             if %i[required optional].include?(current.name)
-              key_node = current.arguments&.arguments&.first
-              return [nil, nil] unless key_node.is_a?(Prism::SymbolNode)
+              key = Rigor::Source::Literals.symbol(current.arguments&.arguments&.first)
+              return [nil, nil] if key.nil?
 
-              return [key_node.unescaped.to_sym, current.name]
+              return [key, current.name]
             end
             current = current.receiver
           end

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

@@ -47,7 +47,11 @@ module Rigor
         version: "0.1.0",
         description: "Recognises `class T < Dry::Validation::Contract` subclasses and " \
                      "publishes the contract FQN set.",
-        produces: [:dry_validation_contracts]
+        produces: [:dry_validation_contracts],
+        # Auto-contribute the bundled RBS overlay (Contract#call -> Result,
+        # Result#success?/#to_h/...) per ADR-25, so no project-side
+        # signature_paths wiring is needed.
+        signature_paths: ["sig"]
       )
 
       def prepare(services)