rigortype 0.0.9 → 0.1.0

data/lib/rigor/cache/rbs_constant_table.rb

@@ -33,10 +33,10 @@ module Rigor
         loader.each_constant_decl do |name, entry|
           translated = Inference::RbsTypeTranslator.translate(entry.decl.type)
           table[name] = translated unless translated.is_a?(Type::Bot)
-        rescue StandardError
+        rescue ::RBS::BaseError
           # Skip entries whose RBS type fails to translate; the cache
           # stays robust to a broken signature rather than corrupting
-          # the whole table.
+          # the whole table. Analyzer-internal errors propagate.
         end
         table
       end

data/lib/rigor/cache/rbs_descriptor.rb

@@ -2,6 +2,8 @@
 
 require "digest"
 
+require_relative "descriptor"
+
 module Rigor
   module Cache
     # Shared descriptor builder for cache producers that depend on the

data/lib/rigor/cache/rbs_instance_definitions.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "rbs_descriptor"
+require_relative "rbs_environment_marshal_patch"
+
+module Rigor
+  module Cache
+    # Cache producer that materialises the full
+    # `Hash<String, RBS::Definition>` for instance-side class
+    # definitions in the RBS environment, in a single cache
+    # entry. Mirrors the {RbsConstantTable} layout.
+    #
+    # ADR-7 § "Slice 6-D" carry-over and dogfooding feedback:
+    # the earlier per-class cache layout (one entry per class,
+    # ~1300 files) made warm runs *slower* than `--no-cache`
+    # because each `instance_definition` call paid disk-open +
+    # `Marshal.load` overhead and the in-memory
+    # `RBS::DefinitionBuilder.build_instance` was actually fast
+    # given a cached `RBS::Environment`. The single-blob layout
+    # collapses that to one `Marshal.load` per process; warm runs
+    # now match `--no-cache` timing while preserving the
+    # cross-process invalidation story.
+    #
+    # Marshal-cleanness of `RBS::Definition` is enabled by the
+    # v0.0.9 C2 `RBS::Location` patch.
+    class RbsInstanceDefinitions
+      PRODUCER_ID = "rbs.instance_definitions"
+
+      # @param loader [Rigor::Environment::RbsLoader]
+      # @param store [Rigor::Cache::Store]
+      # @return [Hash{String => RBS::Definition}]
+      def self.fetch(loader:, store:)
+        descriptor = RbsDescriptor.build(loader)
+        store.fetch_or_compute(producer_id: PRODUCER_ID, params: {}, descriptor: descriptor) do
+          compute(loader)
+        end
+      end
+
+      def self.compute(loader)
+        table = {}
+        loader.each_known_class_name do |name|
+          definition = loader.uncached_instance_definition(name)
+          table[name] = definition if definition
+        end
+        table
+      end
+
+      private_class_method :compute
+    end
+
+    # Singleton-side equivalent of {RbsInstanceDefinitions}.
+    # Caches the full `Hash<String, RBS::Definition>` for the
+    # singleton class of every RBS-known class.
+    class RbsSingletonDefinitions
+      PRODUCER_ID = "rbs.singleton_definitions"
+
+      # @param loader [Rigor::Environment::RbsLoader]
+      # @param store [Rigor::Cache::Store]
+      # @return [Hash{String => RBS::Definition}]
+      def self.fetch(loader:, store:)
+        descriptor = RbsDescriptor.build(loader)
+        store.fetch_or_compute(producer_id: PRODUCER_ID, params: {}, descriptor: descriptor) do
+          compute(loader)
+        end
+      end
+
+      def self.compute(loader)
+        table = {}
+        loader.each_known_class_name do |name|
+          definition = loader.uncached_singleton_definition(name)
+          table[name] = definition if definition
+        end
+        table
+      end
+
+      private_class_method :compute
+    end
+  end
+end

data/lib/rigor/cache/store.rb

@@ -5,6 +5,8 @@ require "fileutils"
 require "json"
 require "securerandom"
 
+require_relative "descriptor"
+
 module Rigor
   module Cache
     # Filesystem-backed cache store. Schema, layout, file format,

data/lib/rigor/cli.rb

@@ -211,9 +211,15 @@ module Rigor
         #                (no plugins are loaded today).
         # - disable:     list of `rigor check` rule identifiers to
         #                silence project-wide. The shipped rules are
-        #                undefined-method, wrong-arity,
-        #                argument-type-mismatch, possible-nil-receiver,
-        #                dump-type, assert-type. In-source
+        #                call.undefined-method, call.wrong-arity,
+        #                call.argument-type-mismatch,
+        #                call.possible-nil-receiver, dump.type,
+        #                assert.type-mismatch, flow.always-raises.
+        #                A bare family token (`call`, `flow`,
+        #                `assert`, `dump`, `def`) wildcards every
+        #                rule under that prefix. Legacy unprefixed
+        #                names (`undefined-method`, …) still
+        #                resolve. In-source
         #                `# rigor:disable <rule>` comments at the end
         #                of an offending line silence per-line; use
         #                `# rigor:disable all` to suppress every rule.

data/lib/rigor/configuration/severity_profile.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Configuration
+    # ADR-8 § "Severity profile" — three named profiles tune the
+    # severity of every built-in `Analysis::CheckRules` rule for
+    # the run. Profiles are applied as a **final filter** on
+    # `Diagnostic#severity`: rules emit with their authored
+    # severity, then `Analysis::Runner` re-stamps the severity
+    # from the active profile before adding the diagnostic to
+    # the result.
+    #
+    # Three profiles:
+    #
+    # - `lenient`: Only proven (`:no`) diagnostics are errors;
+    #   uncertain (`:maybe`) drop to `:warning`. Useful for
+    #   incremental adoption on legacy code.
+    # - `balanced` (**default**): Current Rigor stance — most
+    #   rules `:error`; `dump.type` `:info`; uncertain rules
+    #   `:warning`.
+    # - `strict`: Every rule is `:error`. CI-friendly.
+    #
+    # The profile resolution order:
+    #
+    # 1. Profile-specific entry for the canonical rule id.
+    # 2. The diagnostic's own authored severity (the rule's
+    #    default).
+    # 3. `:error` (catch-all so an unrecognised rule still emits
+    #    visibly — the public-API drift spec catches the
+    #    bookkeeping gap separately).
+    module SeverityProfile
+      VALID_PROFILES = %i[lenient balanced strict].freeze
+      VALID_SEVERITIES = %i[error warning info off].freeze
+
+      DEFAULT_PROFILE = :balanced
+
+      # Per-profile severity tables. Missing keys fall back to
+      # the diagnostic's authored severity (typically `:error`).
+      PROFILES = {
+        lenient: {
+          "call.undefined-method" => :error,
+          "call.wrong-arity" => :error,
+          "call.argument-type-mismatch" => :warning,
+          "call.possible-nil-receiver" => :warning,
+          "flow.always-raises" => :warning,
+          "assert.type-mismatch" => :error,
+          "dump.type" => :info,
+          "def.return-type-mismatch" => :warning
+        }.freeze,
+        balanced: {
+          "call.undefined-method" => :error,
+          "call.wrong-arity" => :error,
+          "call.argument-type-mismatch" => :error,
+          "call.possible-nil-receiver" => :error,
+          "flow.always-raises" => :error,
+          "assert.type-mismatch" => :error,
+          "dump.type" => :info,
+          "def.return-type-mismatch" => :warning
+        }.freeze,
+        strict: {
+          "call.undefined-method" => :error,
+          "call.wrong-arity" => :error,
+          "call.argument-type-mismatch" => :error,
+          "call.possible-nil-receiver" => :error,
+          "flow.always-raises" => :error,
+          "assert.type-mismatch" => :error,
+          "dump.type" => :error,
+          "def.return-type-mismatch" => :error
+        }.freeze
+      }.freeze
+
+      module_function
+
+      # Resolves the configured severity for a diagnostic given
+      # the active profile and any per-rule overrides.
+      #
+      # @param rule [String, nil] canonical rule id (`call.undefined-method`).
+      # @param authored_severity [Symbol] severity the rule emitted
+      #   the diagnostic with (`:error`, `:warning`, `:info`).
+      # @param profile [Symbol] one of {VALID_PROFILES}; falls back
+      #   to {DEFAULT_PROFILE} for unknown values.
+      # @param overrides [Hash{String => Symbol}] per-rule severity
+      #   overrides from `.rigor.yml`'s `severity_overrides:` map.
+      #   Keys are canonical rule ids; values are
+      #   {VALID_SEVERITIES} symbols. Family-wildcard keys
+      #   (`call`) match every rule under that prefix.
+      # @return [Symbol] the resolved severity. Returns `:off` to
+      #   mean "drop the diagnostic entirely".
+      def resolve(rule:, authored_severity:, profile: DEFAULT_PROFILE, overrides: {})
+        return authored_severity if rule.nil?
+
+        override = overrides[rule] || family_override(rule, overrides)
+        return override.to_sym if override
+
+        profile_table = PROFILES[profile] || PROFILES.fetch(DEFAULT_PROFILE)
+        profile_table.fetch(rule, authored_severity)
+      end
+
+      def family_override(rule, overrides)
+        family = rule.split(".").first
+        return nil if family.nil?
+
+        overrides[family]
+      end
+
+      private_class_method :family_override
+    end
+  end
+end

data/lib/rigor/configuration.rb

@@ -2,8 +2,10 @@
 
 require "yaml"
 
+require_relative "configuration/severity_profile"
+
 module Rigor
-  class Configuration
+  class Configuration # rubocop:disable Metrics/ClassLength
     DEFAULT_PATH = ".rigor.yml"
     DEFAULTS = {
       "target_ruby" => "4.0",
@@ -15,11 +17,19 @@ module Rigor
       "fold_platform_specific_paths" => false,
       "cache" => {
         "path" => ".rigor/cache"
-      }
+      },
+      "plugins_io" => {
+        "network" => "disabled",
+        "allowed_paths" => []
+      },
+      "severity_profile" => "balanced",
+      "severity_overrides" => {}
     }.freeze
 
     attr_reader :target_ruby, :paths, :plugins, :cache_path, :disabled_rules,
-                :libraries, :signature_paths, :fold_platform_specific_paths
+                :libraries, :signature_paths, :fold_platform_specific_paths,
+                :plugins_io_network, :plugins_io_allowed_paths,
+                :severity_profile, :severity_overrides
 
     def self.load(path = DEFAULT_PATH)
       data = if File.exist?(path)
@@ -31,12 +41,15 @@ module Rigor
       new(DEFAULTS.merge(data))
     end
 
-    def initialize(data = DEFAULTS) # rubocop:disable Metrics/AbcSize
+    def initialize(data = DEFAULTS) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
       cache = DEFAULTS.fetch("cache").merge(data.fetch("cache", {}))
+      plugins_io = DEFAULTS.fetch("plugins_io").merge(data.fetch("plugins_io", {}))
 
       @target_ruby = data.fetch("target_ruby", DEFAULTS.fetch("target_ruby")).to_s
       @paths = Array(data.fetch("paths", DEFAULTS.fetch("paths"))).map(&:to_s)
-      @plugins = Array(data.fetch("plugins", DEFAULTS.fetch("plugins"))).map(&:to_s)
+      @plugins = Array(data.fetch("plugins", DEFAULTS.fetch("plugins"))).map do |entry|
+        coerce_plugin_entry(entry)
+      end.freeze
       @disabled_rules = Array(data.fetch("disable", DEFAULTS.fetch("disable"))).map(&:to_s).freeze
       @libraries = Array(data.fetch("libraries", DEFAULTS.fetch("libraries"))).map(&:to_s).freeze
       sig_paths = data.fetch("signature_paths", DEFAULTS.fetch("signature_paths"))
@@ -45,6 +58,14 @@ module Rigor
         "fold_platform_specific_paths", DEFAULTS.fetch("fold_platform_specific_paths")
       ) == true
       @cache_path = cache.fetch("path").to_s
+      @plugins_io_network = coerce_network_policy(plugins_io.fetch("network"))
+      @plugins_io_allowed_paths = Array(plugins_io.fetch("allowed_paths")).map(&:to_s).freeze
+      @severity_profile = coerce_severity_profile(
+        data.fetch("severity_profile", DEFAULTS.fetch("severity_profile"))
+      )
+      @severity_overrides = coerce_severity_overrides(
+        data.fetch("severity_overrides", DEFAULTS.fetch("severity_overrides"))
+      )
     end
 
     def to_h
@@ -58,8 +79,91 @@ module Rigor
         "fold_platform_specific_paths" => fold_platform_specific_paths,
         "cache" => {
           "path" => cache_path
-        }
+        },
+        "plugins_io" => {
+          "network" => plugins_io_network.to_s,
+          "allowed_paths" => plugins_io_allowed_paths
+        },
+        "severity_profile" => severity_profile.to_s,
+        "severity_overrides" => severity_overrides.to_h { |k, v| [k, v.to_s] }
       }
     end
+
+    private
+
+    # Accepts either `"rigor-foo"` (gem-name shorthand) or
+    # `{ "gem" => "rigor-foo", "id" => "foo", "config" => {...} }`
+    # (full form). Returns the canonical hash form so the loader
+    # works against a single shape.
+    def coerce_plugin_entry(entry)
+      case entry
+      when String
+        entry.dup.freeze
+      when Hash
+        entry.to_h { |k, v| [k.to_s, v] }.freeze
+      else
+        raise ArgumentError,
+              "plugin configuration entry must be a String or Hash, got #{entry.inspect}"
+      end
+    end
+
+    # Slice 2 only accepts `:disabled` for the network policy. The
+    # YAML scalar may arrive as a String (`"disabled"`) or already
+    # as the Symbol; coerce to the canonical Symbol shape so the
+    # downstream `TrustPolicy` constructor stays strict.
+    #
+    # The accepted set is duplicated from
+    # {Rigor::Plugin::TrustPolicy::VALID_NETWORK_POLICIES} so
+    # `Configuration` does not require the plugin namespace at
+    # load time (Configuration is loaded before Plugin in
+    # `lib/rigor.rb`); the two stay in lockstep via spec.
+    VALID_NETWORK_POLICIES = %i[disabled].freeze
+    private_constant :VALID_NETWORK_POLICIES
+
+    def coerce_network_policy(value)
+      sym = value.to_sym
+      unless VALID_NETWORK_POLICIES.include?(sym)
+        raise ArgumentError,
+              "plugins_io.network must be one of #{VALID_NETWORK_POLICIES.inspect}, got #{value.inspect}"
+      end
+
+      sym
+    end
+
+    # ADR-8 § "Severity profile" — accepts the canonical Symbol
+    # form or its String spelling; rejects unknown profile names
+    # so typos fail loudly.
+    def coerce_severity_profile(value)
+      sym = value.to_sym
+      unless SeverityProfile::VALID_PROFILES.include?(sym)
+        raise ArgumentError,
+              "severity_profile must be one of " \
+              "#{SeverityProfile::VALID_PROFILES.inspect}, got #{value.inspect}"
+      end
+
+      sym
+    end
+
+    # ADR-8 § "Severity profile" — `severity_overrides:` is a
+    # `{ rule => severity }` map. Keys are canonical rule ids
+    # (`call.undefined-method`) or family wildcards (`call`).
+    # Values are {SeverityProfile::VALID_SEVERITIES} symbols
+    # (`:error` / `:warning` / `:info` / `:off`). Unknown
+    # severities raise; unknown rule ids are silently kept (the
+    # override is inert until the rule lands).
+    def coerce_severity_overrides(value)
+      raise ArgumentError, "severity_overrides must be a Hash, got #{value.inspect}" unless value.is_a?(Hash)
+
+      value.to_h do |k, v|
+        sym = v.to_sym
+        unless SeverityProfile::VALID_SEVERITIES.include?(sym)
+          raise ArgumentError,
+                "severity_overrides[#{k.inspect}] must be one of " \
+                "#{SeverityProfile::VALID_SEVERITIES.inspect}, got #{v.inspect}"
+        end
+
+        [k.to_s, sym]
+      end.freeze
+    end
   end
 end

data/lib/rigor/environment/rbs_loader.rb

@@ -125,19 +125,42 @@ module Rigor
 
         env.class_decls.each_key { |rbs_name| yield rbs_name.to_s }
         env.class_alias_decls.each_key { |rbs_name| yield rbs_name.to_s }
-      rescue StandardError
-        # fail-soft: a broken environment yields no names.
+      rescue ::RBS::BaseError
+        # fail-soft: a broken RBS environment yields no names.
+        # Analyzer-internal errors (NameError, NoMethodError,
+        # LoadError) are NOT swallowed — those are bugs and
+        # must surface so they don't hide silently the way the
+        # v0.0.9 cache `Cache::Descriptor` regression did.
       end
 
       # @return [RBS::Definition, nil] the resolved instance definition
       #   for `class_name`, or nil when the class is unknown or its
       #   definition cannot be built (RBS may raise on broken hierarchies;
       #   we fail-soft and return nil so the caller can fall back).
+      #
+      # When `cache_store` is set, the loader fetches the per-class
+      # definition through {Cache::RbsInstanceDefinitions.fetch} so
+      # subsequent runs (and other loaders sharing the same Store)
+      # skip the `RBS::DefinitionBuilder.build_instance` step.
+      # In-memory `@instance_definition_cache` keeps the per-process
+      # short-circuit on top.
       def instance_definition(class_name)
         key = class_name.to_s
         return @instance_definition_cache[key] if @instance_definition_cache.key?(key)
 
-        @instance_definition_cache[key] = build_instance_definition(class_name)
+        @instance_definition_cache[key] = if cache_store
+                                            cached_instance_definition(class_name)
+                                          else
+                                            build_instance_definition(class_name)
+                                          end
+      end
+
+      # Public uncached accessor used by the cache producer
+      # ({Rigor::Cache::RbsInstanceDefinitions}). Avoids the
+      # `private_method_called` round-trip a `loader.send(...)`
+      # callsite would require.
+      def uncached_instance_definition(class_name)
+        build_instance_definition(class_name)
       end
 
       # @return [RBS::Definition::Method, nil]
@@ -153,11 +176,25 @@ module Rigor
       #   definition are the *class methods* of `class_name`, including
       #   those inherited from `Class` and `Module` for class types.
       #   Returns nil for unknown names and on RBS build errors (fail-soft).
+      #
+      # When `cache_store` is set, the loader fetches the per-class
+      # singleton definition through
+      # {Cache::RbsSingletonDefinitions.fetch}; the same caching
+      # discipline as {#instance_definition}.
       def singleton_definition(class_name)
         key = class_name.to_s
         return @singleton_definition_cache[key] if @singleton_definition_cache.key?(key)
 
-        @singleton_definition_cache[key] = build_singleton_definition(class_name)
+        @singleton_definition_cache[key] = if cache_store
+                                             cached_singleton_definition(class_name)
+                                           else
+                                             build_singleton_definition(class_name)
+                                           end
+      end
+
+      # Public uncached accessor used by the cache producer.
+      def uncached_singleton_definition(class_name)
+        build_singleton_definition(class_name)
       end
 
       # @return [RBS::Definition::Method, nil] the class method on
@@ -214,7 +251,7 @@ module Rigor
       #   should keep using {#constant_type} for point lookups.
       def constant_names
         env.constant_decls.keys.map(&:to_s)
-      rescue StandardError
+      rescue ::RBS::BaseError
         []
       end
 
@@ -229,8 +266,8 @@ module Rigor
         env.constant_decls.each do |rbs_name, entry|
           yield rbs_name.to_s, entry
         end
-      rescue StandardError
-        # fail-soft: a broken environment yields no entries.
+      rescue ::RBS::BaseError
+        # fail-soft: a broken RBS environment yields no entries.
       end
 
       # Slice A constant-value lookup. Returns the translated
@@ -258,7 +295,7 @@ module Rigor
         else
           translate_constant_decl(rbs_name)
         end
-      rescue StandardError
+      rescue ::RBS::BaseError
         nil
       end
 
@@ -290,7 +327,7 @@ module Rigor
         return false unless rbs_name
 
         known_class_names_set.include?(rbs_name.to_s)
-      rescue StandardError
+      rescue ::RBS::BaseError
         false
       end
 
@@ -311,6 +348,45 @@ module Rigor
         Cache::RbsEnvironment.fetch(loader: self, store: cache_store)
       end
 
+      # Per-process Hash<String, RBS::Definition> for the instance
+      # side. Loaded once on first miss through the
+      # {Cache::RbsInstanceDefinitions} producer (single Marshal
+      # blob); subsequent calls are pure Hash lookups. Cold runs
+      # build every known class once and persist; warm runs (and
+      # other loaders sharing the same Store) skip the
+      # `RBS::DefinitionBuilder.build_instance` work entirely.
+      def cached_instance_definition(class_name)
+        instance_definitions_table[normalise_class_key(class_name)]
+      end
+
+      def instance_definitions_table
+        @state[:instance_definitions_table] ||= begin
+          require_relative "../cache/rbs_instance_definitions"
+          Cache::RbsInstanceDefinitions.fetch(loader: self, store: cache_store)
+        end
+      end
+
+      def cached_singleton_definition(class_name)
+        singleton_definitions_table[normalise_class_key(class_name)]
+      end
+
+      def singleton_definitions_table
+        @state[:singleton_definitions_table] ||= begin
+          require_relative "../cache/rbs_instance_definitions"
+          Cache::RbsSingletonDefinitions.fetch(loader: self, store: cache_store)
+        end
+      end
+
+      # The cache producers persist class names in
+      # `RBS::TypeName#to_s` form (top-level prefixed
+      # `"::Hash"`); plain-name lookups (`"Hash"`) normalise
+      # before the Hash query so callers stay agnostic to the
+      # prefix.
+      def normalise_class_key(class_name)
+        s = class_name.to_s
+        s.start_with?("::") ? s : "::#{s}"
+      end
+
       def builder
         @state[:builder] ||= RBS::DefinitionBuilder.new(env: env)
       end
@@ -325,7 +401,7 @@ module Rigor
         return nil unless env.class_decls.key?(rbs_name)
 
         builder.build_instance(rbs_name)
-      rescue StandardError
+      rescue ::RBS::BaseError
         nil
       end
 
@@ -335,7 +411,7 @@ module Rigor
         return nil unless env.class_decls.key?(rbs_name)
 
         builder.build_singleton(rbs_name)
-      rescue StandardError
+      rescue ::RBS::BaseError
         nil
       end
 
@@ -345,7 +421,7 @@ module Rigor
 
         s = "::#{s}" unless s.start_with?("::")
         RBS::TypeName.parse(s)
-      rescue StandardError
+      rescue ::RBS::BaseError
         nil
       end
 
@@ -358,7 +434,7 @@ module Rigor
         # them under one map post-resolution. Aliases live in their
         # own table.
         env.class_decls.key?(rbs_name) || env.class_alias_decls.key?(rbs_name)
-      rescue StandardError
+      rescue ::RBS::BaseError
         false
       end
     end

data/lib/rigor/flow_contribution/conflict.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Rigor
+  class FlowContribution
+    # Records a contradiction between two or more flow contributions
+    # detected during {Merger.merge}. Carried on {MergeResult#conflicts}
+    # so the analyzer / formatter can surface a `:contribution_merge`
+    # diagnostic per ADR-2 § "Plugin Contribution Merging".
+    #
+    # ADR-2 § "Plugin Contribution Merging" rules out first-wins /
+    # last-wins behaviour: when contributions conflict, both sources
+    # are reported and the merger falls back to the nearest non-
+    # conflicting higher-tier (or default) value for the affected
+    # `(target, edge, kind)` slot. The conflict object is the
+    # carrier of that report.
+    #
+    # Slice-3 conflict reasons:
+    #
+    # - `:return_type_collapse` — two return-type contributions
+    #   intersect to `bot`.
+    # - `:exceptional_disagreement` — two contributions assert
+    #   incompatible non-`nil` exceptional effects.
+    # - `:lower_tier_contradiction` — a lower-tier contribution
+    #   would weaken or contradict a higher-tier proof.
+    CONFLICT_VALID_REASONS = %i[
+      return_type_collapse
+      exceptional_disagreement
+      lower_tier_contradiction
+    ].freeze
+
+    Conflict = Data.define(:target, :edge, :kind, :reason, :provenances, :message) do
+      def initialize(target:, edge:, kind:, reason:, provenances:, message:) # rubocop:disable Metrics/ParameterLists
+        unless CONFLICT_VALID_REASONS.include?(reason)
+          raise ArgumentError,
+                "FlowContribution::Conflict reason must be one of " \
+                "#{CONFLICT_VALID_REASONS.inspect}, got #{reason.inspect}"
+        end
+
+        super(target: target, edge: edge, kind: kind, reason: reason,
+              provenances: provenances.dup.freeze, message: message.to_s.dup.freeze)
+      end
+
+      def to_h
+        {
+          "target" => target.to_s,
+          "edge" => edge.to_s,
+          "kind" => kind.to_s,
+          "reason" => reason.to_s,
+          "sources" => provenances.map { |p| p.respond_to?(:to_h) ? p.to_h : p.to_s },
+          "message" => message
+        }
+      end
+
+      # ADR-7 § "Slice 5-C" — converts the conflict into a
+      # `Rigor::Analysis::Diagnostic` for the run result.
+      # Carries `source_family: :contribution_merge` so the
+      # qualified-rule formatter (slice 5 formatter half,
+      # `ef730b2`) prefixes the rule id with
+      # `contribution_merge.` and the JSON output side-bands
+      # `source_family` + `rule` for plugin attribution.
+      #
+      # The `rule` identifier is the kebab-case form of the
+      # conflict reason (`return_type_collapse` →
+      # `return-type-collapse`, etc.) so the qualified rule
+      # reads `[contribution_merge.return-type-collapse]` in
+      # the standard text stream.
+      def to_diagnostic(path:, line:, column:, severity: :error)
+        require_relative "../analysis/diagnostic" unless defined?(Rigor::Analysis::Diagnostic)
+        Rigor::Analysis::Diagnostic.new(
+          path: path,
+          line: line,
+          column: column,
+          message: message,
+          severity: severity,
+          rule: reason.to_s.tr("_", "-"),
+          source_family: :contribution_merge
+        )
+      end
+    end
+  end
+end