rigortype 0.1.18 → 0.2.0

data/lib/rigor/cli/mutation_protection_report.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Rigor
+  class CLI
+    # ADR-63 Tier 2 — aggregates per-file {Protection::MutationScanner}
+    # results into a project-level *effectiveness* report: the kill ratio (when
+    # a type-visible bug was introduced, how often Rigor caught it), the per-file
+    # breakdown, and a ranked "add a type here" list keyed by the method whose
+    # breakage Rigor most often *missed* — the sites where a receiver annotation
+    # would buy real catching power.
+    #
+    # The framing is load-bearing (ADR-63 Criterion A / ADR-62 Criterion A): the
+    # number is *effectiveness*, the survivors are *missed breakages / where to
+    # add a type*, never "your code is broken".
+    FileEffectiveness = Data.define(:path, :killed, :survived, :ratio)
+    MissedBreakage = Data.define(:method_name, :count, :examples)
+
+    MutationProtectionReport = Data.define(:files, :missed, :parse_errors) do
+      def total_killed = files.sum(&:killed)
+      def total_survived = files.sum(&:survived)
+      def grand_total = total_killed + total_survived
+      def ratio = grand_total.zero? ? 1.0 : total_killed.to_f / grand_total
+
+      def to_h
+        {
+          "mode" => "mutation",
+          "killed" => total_killed,
+          "survived" => total_survived,
+          "effectiveness_ratio" => ratio.round(4),
+          "files" => files.map do |f|
+            { "path" => f.path, "killed" => f.killed,
+              "survived" => f.survived, "ratio" => f.ratio.round(4) }
+          end,
+          "add_a_type_here" => missed.map do |m|
+            { "method" => m.method_name, "count" => m.count, "examples" => m.examples }
+          end,
+          "parse_errors" => parse_errors
+        }
+      end
+    end
+
+    class MutationProtectionAccumulator
+      def initialize
+        @files = []
+        @missed = Hash.new { |h, k| h[k] = { count: 0, examples: [] } }
+        @parse_errors = []
+      end
+
+      def absorb(file_result)
+        @files << FileEffectiveness.new(
+          path: file_result.path, killed: file_result.killed,
+          survived: file_result.survived, ratio: file_result.ratio
+        )
+        file_result.sites.each do |site|
+          bucket = @missed[site.method_name]
+          bucket[:count] += 1
+          bucket[:examples] << "#{file_result.path}:#{site.line}" if bucket[:examples].size < 3
+        end
+      end
+
+      def record_parse_error(path, errors)
+        @parse_errors << { "path" => path, "errors" => errors.size }
+      end
+
+      def to_report
+        missed = @missed
+                 .map { |method, v| MissedBreakage.new(method_name: method, count: v[:count], examples: v[:examples]) }
+                 .sort_by { |m| [-m.count, m.method_name] }
+        MutationProtectionReport.new(files: @files, missed: missed, parse_errors: @parse_errors)
+      end
+    end
+  end
+end

data/lib/rigor/cli/options.rb

@@ -17,6 +17,15 @@ module Rigor
     module Options
       module_function
 
+      # Defines the standard `--config=PATH` flag on `parser`, writing the
+      # path into `options[:config]`. Used by every subcommand that loads a
+      # `.rigor.yml`; the few whose `--config` help text is intentionally
+      # bespoke (`diff`, `mcp`, `show-bleedingedge`) keep their own
+      # `parser.on` rather than this shared wording.
+      def add_config(parser, options)
+        parser.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+      end
+
       # Defines the `--tmp-file` / `--instead-of` editor-mode flag pair
       # on `parser`, writing into `options`.
       def add_editor_mode(parser, options)

data/lib/rigor/cli/plugins_command.rb

@@ -3,6 +3,7 @@
 require "optparse"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../plugin"
 require_relative "../plugin/loader"
 require_relative "../plugin/services"
@@ -30,7 +31,7 @@ module Rigor
     # - every manifest-declared extension surface
     #   (`open_receivers:` / `owns_receivers:` / `produces:` /
     #   `consumes:` / `block_as_methods:` / `heredoc_templates:` /
-    #   `trait_registries:` / `external_files:` /
+    #   `trait_registries:` /
     #   `type_node_resolvers:` / `hkt_registrations:` /
     #   `hkt_definitions:` / `protocol_contracts:` /
     #   `source_rbs_synthesizer:`);
@@ -102,7 +103,7 @@ module Rigor
         options = { config: nil, format: "text", strict: false, capabilities: false }
         OptionParser.new do |opts|
           opts.banner = USAGE
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          Options.add_config(opts, options)
           opts.on("--format=FORMAT", "Output format: text (default) or json") { |v| options[:format] = v }
           opts.on("--strict", "Exit 1 if any plugin failed to load (CI gate)") { options[:strict] = true }
           opts.on("--capabilities", "Emit the per-plugin extension-protocol catalogue (ADR-37)") do
@@ -233,7 +234,6 @@ module Rigor
           block_as_methods: manifest.block_as_methods.size,
           heredoc_templates: manifest.heredoc_templates.size,
           trait_registries: manifest.trait_registries.size,
-          external_files: manifest.external_files.size,
           type_node_resolvers: manifest.type_node_resolvers.size,
           hkt_registrations: manifest.hkt_registrations.size,
           hkt_definitions: manifest.hkt_definitions.size,
@@ -257,7 +257,6 @@ module Rigor
           block_as_methods: 0,
           heredoc_templates: 0,
           trait_registries: 0,
-          external_files: 0,
           type_node_resolvers: 0,
           hkt_registrations: 0,
           hkt_definitions: 0,
@@ -337,7 +336,7 @@ module Rigor
             signature_paths: [],
             open_receivers: [], owns_receivers: [], produces: [], consumes: [],
             block_as_methods: 0, heredoc_templates: 0, trait_registries: 0,
-            external_files: 0, type_node_resolvers: 0,
+            type_node_resolvers: 0,
             hkt_registrations: 0, hkt_definitions: 0,
             protocol_contracts: 0, source_rbs_synthesizer: false,
             node_rule_types: [], dynamic_return_receivers: [], type_specifier_methods: [],

data/lib/rigor/cli/plugins_renderer.rb

@@ -209,7 +209,6 @@ module Rigor
         parts << "block_as_methods=#{row[:block_as_methods]}" if row[:block_as_methods].positive?
         parts << "heredoc_templates=#{row[:heredoc_templates]}" if row[:heredoc_templates].positive?
         parts << "trait_registries=#{row[:trait_registries]}" if row[:trait_registries].positive?
-        parts << "external_files=#{row[:external_files]}" if row[:external_files].positive?
         return [] if parts.empty?
 
         ["        macro substrate: #{parts.join(', ')}"]
@@ -233,7 +232,6 @@ module Rigor
           "block_as_methods" => row[:block_as_methods],
           "heredoc_templates" => row[:heredoc_templates],
           "trait_registries" => row[:trait_registries],
-          "external_files" => row[:external_files],
           "type_node_resolvers" => row[:type_node_resolvers],
           "hkt_registrations" => row[:hkt_registrations],
           "hkt_definitions" => row[:hkt_definitions],

data/lib/rigor/cli/protection_renderer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rigor
+  class CLI
+    # Renders an {ProtectionReport} (ADR-63 Tier 1) as text or JSON. The text
+    # form leads with the protected ratio, then the highest-traffic untyped
+    # dispatches ("add a type here"), then the lowest-protected files. The
+    # framing is always *where to add a type*, never "your code is broken".
+    class ProtectionRenderer
+      TOP_CALLS = 15
+      TOP_FILES = 10
+
+      def initialize(out:)
+        @out = out
+      end
+
+      def render(report, format:)
+        format == "json" ? render_json(report) : render_text(report)
+      end
+
+      private
+
+      def render_json(report)
+        @out.puts(JSON.pretty_generate(report.to_h))
+      end
+
+      def render_text(report)
+        pct = (report.ratio * 100).round(1)
+        @out.puts "Type-protection coverage (Tier 1 — dispatch-site receiver concreteness)"
+        @out.puts "  protected dispatch sites: #{report.total_protected} / #{report.grand_total}  (#{pct}%)"
+        @out.puts "  (protected = Rigor can catch a wrong call here; an upper bound on real protection)"
+        render_untyped_calls(report)
+        render_files(report)
+      end
+
+      def render_untyped_calls(report)
+        calls = report.untyped_calls
+        return if calls.empty?
+
+        @out.puts "\nAdd a type here — methods most often called on an untyped receiver:"
+        calls.first(TOP_CALLS).each do |call|
+          @out.puts format("  %<count>-5d #%<method>s   e.g. %<sites>s",
+                           count: call.count, method: call.method_name, sites: call.examples.join("  "))
+        end
+        @out.puts "  (#{calls.size - TOP_CALLS} more)" if calls.size > TOP_CALLS
+      end
+
+      def render_files(report)
+        worst = report.files.reject { |f| f.unprotected_count.zero? }.sort_by(&:ratio).first(TOP_FILES)
+        return if worst.empty?
+
+        @out.puts "\nLeast-protected files:"
+        worst.each do |file|
+          total = file.protected_count + file.unprotected_count
+          @out.puts format("  %<pct>5.1f%%  %<path>s  (%<n>d/%<total>d protected)",
+                           pct: file.ratio * 100, path: file.path, n: file.protected_count, total: total)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/cli/protection_report.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Rigor
+  class CLI
+    # ADR-63 Tier 1 — aggregates per-file {Inference::ProtectionScanner}
+    # results into a project-level protection report: the protected ratio, the
+    # per-file breakdown, and a ranked "add a type here" list keyed by the
+    # method called on an unprotected (`Dynamic`) receiver — the highest-traffic
+    # untyped dispatches, where a receiver annotation buys the most catching
+    # power.
+    FileProtection = Data.define(:path, :protected_count, :unprotected_count, :ratio)
+    UntypedCall = Data.define(:method_name, :count, :examples)
+
+    ProtectionReport = Data.define(:files, :untyped_calls, :parse_errors) do
+      def total_protected = files.sum(&:protected_count)
+      def total_unprotected = files.sum(&:unprotected_count)
+      def grand_total = total_protected + total_unprotected
+      def ratio = grand_total.zero? ? 1.0 : total_protected.to_f / grand_total
+
+      def to_h
+        {
+          "protected" => total_protected,
+          "unprotected" => total_unprotected,
+          "protection_ratio" => ratio.round(4),
+          "files" => files.map do |f|
+            { "path" => f.path, "protected" => f.protected_count,
+              "unprotected" => f.unprotected_count, "ratio" => f.ratio.round(4) }
+          end,
+          "add_a_type_here" => untyped_calls.map do |c|
+            { "method" => c.method_name, "count" => c.count, "examples" => c.examples }
+          end,
+          "parse_errors" => parse_errors
+        }
+      end
+    end
+
+    class ProtectionAccumulator
+      def initialize
+        @files = []
+        @calls = Hash.new { |h, k| h[k] = { count: 0, examples: [] } }
+        @parse_errors = []
+      end
+
+      def absorb(path, file_result)
+        @files << FileProtection.new(
+          path: path, protected_count: file_result.protected_count,
+          unprotected_count: file_result.unprotected_count, ratio: file_result.ratio
+        )
+        file_result.sites.each do |site|
+          bucket = @calls[site.method_name]
+          bucket[:count] += 1
+          bucket[:examples] << "#{path}:#{site.line}" if bucket[:examples].size < 3
+        end
+      end
+
+      def record_parse_error(path, errors)
+        @parse_errors << { "path" => path, "errors" => errors.size }
+      end
+
+      def to_report
+        untyped = @calls
+                  .map { |method, v| UntypedCall.new(method_name: method, count: v[:count], examples: v[:examples]) }
+                  .sort_by { |c| [-c.count, c.method_name] }
+        ProtectionReport.new(files: @files, untyped_calls: untyped, parse_errors: @parse_errors)
+      end
+    end
+  end
+end

data/lib/rigor/cli/show_bleedingedge_command.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "json"
+require "optionparser"
+
+require_relative "../bleeding_edge"
+require_relative "../configuration"
+require_relative "command"
+
+module Rigor
+  class CLI
+    # Executes `rigor show-bleedingedge` (ADR-50 § WD2).
+    #
+    # Prints the bleeding-edge overlay — the Rigor-maintained set of the
+    # next major's queued changes ({Rigor::BleedingEdge}) — as an
+    # explicit list, and reports which of them the project's
+    # `bleeding_edge:` configuration adopts. The overlay is empty in this
+    # release, so the command currently reports an empty set; it becomes
+    # the inspection surface ADR-50 describes once a feature is queued.
+    #
+    # Read-only: it loads `.rigor.yml` to resolve the active selection
+    # but runs no analysis.
+    class ShowBleedingedgeCommand < Command
+      USAGE = "Usage: rigor show-bleedingedge [options]"
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        configuration = load_configuration(options)
+        return CLI::EXIT_USAGE if configuration.nil?
+
+        case options.fetch(:format)
+        when "json" then render_json(configuration)
+        else render_text(configuration)
+        end
+        0
+      end
+
+      private
+
+      def parse_options
+        options = { format: "text", config: nil }
+        OptionParser.new do |opt|
+          opt.banner = USAGE
+          opt.on("--format=FORMAT", %w[text json], "Output format (text | json). Default: text.") do |fmt|
+            options[:format] = fmt
+          end
+          opt.on("--config=PATH", "Path to a .rigor.yml (default: auto-discovery).") do |path|
+            options[:config] = path
+          end
+        end.parse!(@argv)
+        options
+      end
+
+      def load_configuration(options)
+        Configuration.load(options.fetch(:config))
+      rescue StandardError => e
+        @err.puts("show-bleedingedge: could not load configuration: #{e.message}")
+        nil
+      end
+
+      def render_json(configuration)
+        selector = configuration.bleeding_edge
+        @out.puts(JSON.pretty_generate(
+                    "overlay" => BleedingEdge.features.map(&:to_h),
+                    "selector" => configuration.to_h.fetch("bleeding_edge"),
+                    "active" => BleedingEdge.active_features(selector).map(&:id),
+                    "unknown_selected" => BleedingEdge.unknown_selected_ids(selector)
+                  ))
+      end
+
+      def render_text(configuration)
+        @out.puts("Bleeding-edge overlay (ADR-50 § WD2)")
+        @out.puts("")
+        if BleedingEdge.features.empty?
+          render_empty_overlay
+        else
+          render_overlay
+        end
+        @out.puts("")
+        render_selection(configuration)
+      end
+
+      def render_empty_overlay
+        @out.puts("The overlay is empty in this release — no features are queued for")
+        @out.puts("the next major. The `bleeding_edge:` mechanism is wired and ready;")
+        @out.puts("there is simply nothing to adopt yet.")
+      end
+
+      def render_overlay
+        @out.puts("#{BleedingEdge.features.length} feature(s) queued for the next major:")
+        @out.puts("")
+        BleedingEdge.features.each do |feature|
+          @out.puts("  #{feature.id}")
+          @out.puts("    #{feature.summary}")
+          feature.severity_overrides.each do |rule, severity|
+            @out.puts("    severity: #{rule} → :#{severity}")
+          end
+        end
+      end
+
+      def render_selection(configuration)
+        selector = configuration.bleeding_edge
+        active = BleedingEdge.active_features(selector).map(&:id)
+        @out.puts("Your configuration adopts: #{active.empty? ? '(none)' : active.join(', ')}")
+
+        unknown = BleedingEdge.unknown_selected_ids(selector)
+        return if unknown.empty?
+
+        @out.puts("Selected but not in this overlay (ignored): #{unknown.join(', ')}")
+      end
+    end
+  end
+end

data/lib/rigor/cli/sig_gen_command.rb

@@ -3,6 +3,7 @@
 require "optionparser"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../sig_gen"
 require_relative "command"
 
@@ -145,7 +146,7 @@ module Rigor
           opts.on("--tighter-returns", "Emit only tighter-return classifications") do
             options[:selection] << SigGen::Classification::TIGHTER_RETURN
           end
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          Options.add_config(opts, options)
         end
       end
 

data/lib/rigor/cli/trace_command.rb

@@ -5,6 +5,7 @@ require "optionparser"
 require "prism"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../environment"
 require_relative "../scope"
 require_relative "../inference/flow_tracer"
@@ -63,7 +64,7 @@ module Rigor
             options[:line] = value
           end
           opts.on("--verbose", "Include every expression enter/result frame") { options[:verbose] = true }
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          Options.add_config(opts, options)
         end
         parser.parse!(@argv)
         options

data/lib/rigor/cli/triage_command.rb

@@ -3,6 +3,7 @@
 require "optionparser"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../analysis/runner"
 require_relative "../cache/store"
 require_relative "../triage"
@@ -21,7 +22,7 @@ module Rigor
     # command, not a gate (`rigor check` remains the gate).
     class TriageCommand < Command
       USAGE = "Usage: rigor triage [options] [paths]"
-      DEFAULT_SECTIONS = %i[distribution hotspots hints].freeze
+      DEFAULT_SECTIONS = %i[distribution selectors hotspots hints].freeze
 
       # @return [Integer] CLI exit status (always 0).
       def run
@@ -42,12 +43,15 @@ module Rigor
         options = { config: nil, format: "text", top: 10, sections: DEFAULT_SECTIONS }
         OptionParser.new do |opts|
           opts.banner = USAGE
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          Options.add_config(opts, options)
           opts.on("--format=FORMAT", "Output format: text (default) or json") { |v| options[:format] = v }
           opts.on("--top=N", Integer, "Hotspot-file count (default 10)") { |v| options[:top] = v }
           opts.on("--hints-only", "Print only the heuristic-hints section") { options[:sections] = %i[hints] }
-          opts.on("--no-hints", "Print distribution + hotspots only") do
-            options[:sections] = %i[distribution hotspots]
+          opts.on("--no-hints", "Print distribution + selectors + hotspots only") do
+            options[:sections] = %i[distribution selectors hotspots]
+          end
+          opts.on("--selectors-only", "Print only the class/method selectors section") do
+            options[:sections] = %i[selectors]
           end
         end.parse!(@argv)
         validate!(options)

data/lib/rigor/cli/triage_renderer.rb

@@ -10,10 +10,11 @@ module Rigor
     # triage` text report or as `--format json`.
     class TriageRenderer
       BAR_WIDTH = 24
+      SELECTOR_ROWS = 15 # text-output cap; `--format json` carries the full list
 
       def initialize(report, sections:)
         @report = report
-        @sections = sections # subset of %i[distribution hotspots hints]
+        @sections = sections # subset of %i[distribution selectors hotspots hints]
       end
 
       def json
@@ -23,6 +24,7 @@ module Rigor
       def text
         blocks = []
         blocks << distribution_block if @sections.include?(:distribution)
+        blocks << selectors_block    if @sections.include?(:selectors)
         blocks << hotspots_block     if @sections.include?(:hotspots)
         blocks << hints_block        if @sections.include?(:hints)
         "#{blocks.join("\n\n")}\n"
@@ -42,6 +44,18 @@ module Rigor
         lines.join("\n")
       end
 
+      def selectors_block
+        return "Selectors — by class / method\n  (none)" if @report.selectors.empty?
+
+        lines = ["Selectors — by class / method (top #{SELECTOR_ROWS}; full list in --format json)"]
+        @report.selectors.first(SELECTOR_ROWS).each do |sel|
+          label = sel.receiver ? "#{sel.receiver}##{sel.method_name}" : sel.method_name
+          lines << format("  %<label>-44s %<count>5d  %<files>3d file(s)",
+                          label: label, count: sel.count, files: sel.files)
+        end
+        lines.join("\n")
+      end
+
       def hotspots_block
         return "Hotspot files\n  (none)" if @report.hotspots.empty?
 

data/lib/rigor/cli/type_of_command.rb

@@ -53,7 +53,7 @@ module Rigor
           opts.banner = USAGE
           opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
           opts.on("--trace", "Record fail-soft fallbacks via FallbackTracer") { options[:trace] = true }
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          Options.add_config(opts, options)
           Options.add_editor_mode(opts, options)
         end
         parser.parse!(@argv)

data/lib/rigor/cli/type_scan_command.rb

@@ -4,6 +4,7 @@ require "optionparser"
 require "prism"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../environment"
 require_relative "../inference/coverage_scanner"
 require_relative "../scope"
@@ -46,7 +47,7 @@ module Rigor
         parser = OptionParser.new do |opts|
           opts.banner = USAGE
           opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          Options.add_config(opts, options)
           opts.on("--limit=N", Integer, "Max example events to print (text only)") do |value|
             options[:limit] = value
           end

data/lib/rigor/cli.rb

@@ -38,7 +38,8 @@ module Rigor
       "plugins" => :run_plugins,
       "plugin" => :run_plugin,
       "playground" => :run_playground,
-      "skill" => :run_skill
+      "skill" => :run_skill,
+      "show-bleedingedge" => :run_show_bleedingedge
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -150,8 +151,9 @@ module Rigor
         # - target_ruby: minimum Ruby version your project targets.
         # - paths:       directories scanned by `rigor check` and
         #                `rigor type-scan` when no path is given.
-        # - plugins:     reserved for future plugin contributions
-        #                (no plugins are loaded today).
+        # - plugins:     opt-in list of plugin gem names to load.
+        #                See https://github.com/rigortype/rigor/tree/main/plugins
+        #                for production plugins (rigor-activerecord, rigor-sorbet, …).
         # - disable:     list of `rigor check` rule identifiers to
         #                silence project-wide. The shipped rules are
         #                call.undefined-method, call.wrong-arity,
@@ -289,6 +291,12 @@ module Rigor
       CLI::PluginCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_show_bleedingedge
+      require_relative "cli/show_bleedingedge_command"
+
+      CLI::ShowBleedingedgeCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def help
       <<~HELP
         Usage: rigor <command> [options]
@@ -311,6 +319,7 @@ module Rigor
           plugin     Browse bundled plugin source as worked examples (list/path/print/root)
           playground Start the browser playground (requires rigor-playground gem)
           skill      List or print bundled Agent Skills (rigor-project-init, ...)
+          show-bleedingedge  Show the bleeding-edge overlay + what your config adopts (ADR-50)
           version    Print the Rigor version
           help       Print this help
       HELP

data/lib/rigor/configuration/dependencies.rb

@@ -9,10 +9,8 @@ module Rigor
     # inference instead of degrading to `Dynamic[top]` at the
     # dependency boundary.
     #
-    # Slice 1 lands the parser only — `Configuration#dependencies`
-    # is read, but no analyzer machinery consumes it yet. Slice 2
-    # wires `Analysis::DependencySourceInference` against this
-    # value object.
+    # Parser for the `dependencies:` YAML section; consumed by
+    # `Analysis::DependencySourceInference` (ADR-10).
     class Dependencies
       # Walking modes per
       # [ADR-10 § "Decision"](../../../docs/adr/10-dependency-source-inference.md#decision).

data/lib/rigor/configuration/severity_profile.rb

@@ -130,14 +130,26 @@ module Rigor
       #   Keys are canonical rule ids; values are
       #   {VALID_SEVERITIES} symbols. Family-wildcard keys
       #   (`call`) match every rule under that prefix.
+      # @param bleeding_edge_overrides [Hash{String => Symbol}] the
+      #   severity map imposed by the active ADR-50 § WD2 bleeding-edge
+      #   features ({Rigor::BleedingEdge.severity_overrides_for}).
+      #   Consulted *below* the user's own `overrides` (so an explicit
+      #   `severity_overrides:` entry, exact or family wildcard, always
+      #   wins) and *above* the profile table. Exact rule ids only — the
+      #   overlay never carries family wildcards. Empty while the
+      #   overlay is unpopulated, so the default leaves resolution
+      #   bit-for-bit unchanged.
       # @return [Symbol] the resolved severity. Returns `:off` to
       #   mean "drop the diagnostic entirely".
-      def resolve(rule:, authored_severity:, profile: DEFAULT_PROFILE, overrides: {})
+      def resolve(rule:, authored_severity:, profile: DEFAULT_PROFILE, overrides: {}, bleeding_edge_overrides: {})
         return authored_severity if rule.nil?
 
         override = overrides[rule] || family_override(rule, overrides)
         return override.to_sym if override
 
+        bleeding = bleeding_edge_overrides[rule]
+        return bleeding.to_sym if bleeding
+
         profile_table = PROFILES[profile] || PROFILES.fetch(DEFAULT_PROFILE)
         profile_table.fetch(rule, authored_severity)
       end