ast-merge-git 7.1.6 → 7.1.8

data/lib/ast/merge/git/local_benchmark.rb

@@ -5,6 +5,7 @@ require 'fileutils'
 require 'json'
 require 'open3'
 require 'rbconfig'
+require 'tree_haver'
 
 module Ast
   module Merge
@@ -15,8 +16,8 @@ module Ast
         Error = Class.new(StandardError)
         SCHEMA = 'structuredmerge.benchmark.corpus/v1'
         CASE_SCHEMA = 'structuredmerge.benchmark/v1'
-        OPERATIONS = %w[merge3 metamorphic diff].freeze
-        EXECUTABLE_OPERATIONS = %w[merge3 metamorphic].freeze
+        OPERATIONS = %w[merge2 merge3 metamorphic diff].freeze
+        EXECUTABLE_OPERATIONS = %w[merge2 merge3 metamorphic].freeze
         PARTITIONS = %w[sentinel gold metamorphic].freeze
         EXPECTATIONS = %w[clean conflict error excluded_ambiguous].freeze
         SEVERITIES = %w[none low high critical].freeze
@@ -34,10 +35,17 @@ module Ast
         ].freeze
         SELECTOR_FIELDS = %w[provider_id family dialect backend profile require].freeze
         INPUT_ROLES = {
+          'merge2' => %w[incoming current],
           'merge3' => %w[base ours theirs],
           'metamorphic' => %w[source transformed],
           'diff' => %w[before after]
         }.freeze
+        PROFILE_POLICIES = {
+          'micro' => %w[sentinels none],
+          'dev' => %w[affected none],
+          'nightly' => %w[all none],
+          'competitive' => %w[all configured]
+        }.freeze
 
         attr_reader :document, :corpus_digest, :path
 
@@ -87,14 +95,22 @@ module Ast
           capabilities = inferred.values.flatten.uniq.sort
           direct = cases.select { |item| direct_case?(item, capabilities) }.map { |item| item.fetch('id') }
           sentinels = definition.fetch('mandatory_sentinels')
-          selected = ordered(sentinels + direct)
-          population = cases.map { |item| item.fetch('id') } - selected
-          neighbors = neighbor_order(population).first(definition.fetch('neighbor_count'))
-          selected = ordered(selected + neighbors)
-          selected = sentinels if profile == 'micro'
+          base = ordered(sentinels + direct)
+          population = cases.map { |item| item.fetch('id') } - base
+          neighbors = if definition.fetch('selection_mode') == 'affected'
+                        neighbor_order(population).first(definition.fetch('neighbor_count'))
+                      else
+                        []
+                      end
+          selected = selected_ids_for(definition.fetch('selection_mode'), sentinels, base, neighbors)
+          if selected.length > definition.dig('budgets', 'case_count')
+            error!("profile #{profile} case budget does not fit selection")
+          end
 
           {
             'profile' => profile,
+            'selection_mode' => definition.fetch('selection_mode'),
+            'competitor_policy' => definition.fetch('competitor_policy'),
             'seed' => document.dig('selection', 'seed'),
             'selected_case_ids' => selected,
             'excluded_case_ids' => cases.map { |item| item.fetch('id') } - selected,
@@ -119,7 +135,7 @@ module Ast
             end,
             'budgets' => definition.fetch('budgets'),
             'explanation' => explanation(
-              profile,
+              definition.fetch('selection_mode'),
               inferred: inferred,
               direct: direct,
               sentinels: sentinels,
@@ -136,10 +152,18 @@ module Ast
         private
 
         def validate_profiles!
-          error!('profiles must be exactly micro and dev') unless document['profiles'].keys.sort == %w[dev micro]
+          unless document['profiles'].keys.sort == PROFILE_POLICIES.keys.sort
+            error!('profiles must be exactly micro, dev, nightly, and competitive')
+          end
           document['profiles'].each do |name, profile|
-            require_keys(profile, %w[mandatory_sentinels neighbor_count budgets], "profile #{name}")
+            require_keys(
+              profile,
+              %w[selection_mode competitor_policy mandatory_sentinels neighbor_count budgets],
+              "profile #{name}"
+            )
             require_keys(profile['budgets'], %w[wall_seconds case_count output_bytes], "profile #{name} budgets")
+            actual = [profile['selection_mode'], profile['competitor_policy']]
+            error!("profile #{name} policy differs") unless actual == PROFILE_POLICIES.fetch(name)
           end
         end
 
@@ -267,7 +291,7 @@ module Ast
         end
 
         def validate_operation!(item, id)
-          if item['operation'] == 'merge3'
+          if %w[merge2 merge3].include?(item['operation'])
             require_keys(item, %w[expected expected_conflicts], id)
             expectation = item.dig('expected', 'outcome')
             error!("#{id}: unsupported expected outcome") unless EXPECTATIONS.include?(expectation)
@@ -331,9 +355,22 @@ module Ast
           ids.sort_by { |id| [digest("#{seed}\0#{id}"), id] }
         end
 
-        def explanation(profile, details)
+        def selected_ids_for(mode, sentinels, base, neighbors)
+          case mode
+          when 'sentinels' then sentinels
+          when 'affected' then ordered(base + neighbors)
+          when 'all' then cases.map { |item| item.fetch('id') }
+          else error!("unknown selection mode: #{mode}")
+          end
+        end
+
+        def explanation(selection_mode, details)
           {
-            'profile_rule' => profile == 'micro' ? 'mandatory sentinels only' : 'sentinels + direct + neighbors',
+            'profile_rule' => {
+              'sentinels' => 'mandatory sentinels only',
+              'affected' => 'sentinels + direct + neighbors',
+              'all' => 'all admitted cases in canonical corpus order'
+            }.fetch(selection_mode),
             'changed_paths' => details[:inferred].map { |path, caps| "#{path} => #{caps.join(',')}" },
             'direct_cases' => details[:direct],
             'sentinels' => details[:sentinels],
@@ -373,9 +410,102 @@ module Ast
         end
       end
 
+      # Owns one long-lived benchmark adapter subprocess and its JSONL exchange.
+      class BenchmarkAdapterSession
+        attr_reader :spawn_duration_ns
+
+        def initialize(driver_path:, chdir:, timeout:, env: {})
+          @driver_path = Pathname(driver_path).expand_path
+          @chdir = Pathname(chdir).expand_path
+          @timeout = timeout
+          @env = env
+        end
+
+        def start
+          return self if @process
+
+          started = monotonic_nanoseconds
+          @stdin, @stdout, @stderr, @process = Open3.popen3(
+            @env,
+            @driver_path.to_s,
+            'benchmark-provider-session',
+            chdir: @chdir.to_s
+          )
+          [@stdin, @stdout, @stderr].each(&:binmode)
+          @stderr_reader = Thread.new { @stderr.read }
+          @spawn_duration_ns = monotonic_nanoseconds - started
+          @request_count = 0
+          self
+        rescue Errno::ENOENT => e
+          raise LocalBenchmark::Error, "cannot start benchmark adapter session: #{e.message}"
+        end
+
+        def request(payload)
+          start
+          started = monotonic_nanoseconds
+          @stdin.puts(JSON.generate(payload))
+          @stdin.flush
+          line = read_response_line
+          response = JSON.parse(line)
+          @request_count += 1
+          response.merge(
+            'round_trip_duration_ns' => monotonic_nanoseconds - started,
+            'session_request_index' => @request_count
+          )
+        rescue Errno::EPIPE, IOError, JSON::ParserError => e
+          raise LocalBenchmark::Error, "benchmark adapter session failed: #{e.message}#{stderr_suffix}"
+        end
+
+        def close
+          return unless @process
+
+          @stdin.close unless @stdin.closed?
+          terminate unless @process.join(1)
+          @stderr_reader.join(1)
+        ensure
+          [@stdin, @stdout, @stderr].compact.each { |io| io.close unless io.closed? }
+          @process = nil
+        end
+
+        private
+
+        def read_response_line
+          reader = Thread.new { @stdout.gets }
+          unless reader.join(@timeout)
+            terminate
+            raise LocalBenchmark::Error, "benchmark adapter session timed out after #{@timeout}s#{stderr_suffix}"
+          end
+
+          reader.value || raise(LocalBenchmark::Error, "benchmark adapter session closed#{stderr_suffix}")
+        end
+
+        def terminate
+          Process.kill('TERM', @process.pid)
+          return if @process.join(1)
+
+          Process.kill('KILL', @process.pid)
+          @process.join
+        rescue Errno::ESRCH, Errno::ECHILD
+          @process.join
+        end
+
+        def stderr_suffix
+          return '' unless @stderr_reader&.join(0)
+
+          stderr = @stderr_reader.value
+          stderr.empty? ? '' : ": #{stderr}"
+        end
+
+        def monotonic_nanoseconds
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        end
+      end
+
       # Executes the same authored merge bytes through Git and the installed driver.
       class LocalBenchmarkRunner
         DEFAULT_TIMEOUT = 30
+        MAX_WORKERS = 32
+        ADAPTER_DESCRIPTOR_SCHEMA = 'structuredmerge.benchmark.adapter-descriptor/v1'
         MERGIRAF_EXTENSIONS = {
           'bash' => 'sh',
           'html' => 'html',
@@ -387,22 +517,37 @@ module Ast
           'yaml' => 'yaml'
         }.freeze
 
-        def initialize(benchmark:, driver_path:, tmp_root:, timeout: DEFAULT_TIMEOUT, competitor_paths: {})
+        # rubocop:disable Metrics/ParameterLists -- runner dependencies and resource limits remain explicit
+        def initialize(benchmark:, driver_path:, tmp_root:, timeout: DEFAULT_TIMEOUT, competitor_paths: {}, workers: 1,
+                       adapter_descriptor: nil)
           @benchmark = benchmark
           @driver_path = Pathname(driver_path).expand_path
           @tmp_root = Pathname(tmp_root).expand_path
           @timeout = Integer(timeout)
           @competitor_paths = competitor_paths.transform_values { |path| Pathname(path).expand_path }
+          @workers = Integer(workers)
+          error!("workers must be between 1 and #{MAX_WORKERS}") unless @workers.between?(1, MAX_WORKERS)
+          @adapter_descriptor = load_adapter_descriptor(adapter_descriptor)
         end
+        # rubocop:enable Metrics/ParameterLists
 
         def run(profile:, changed_paths: [])
           verify_environment!
           selection = @benchmark.select(profile: profile, changed_paths: changed_paths)
-          original_cwd = Dir.pwd
-          results = selection['selected_case_ids'].flat_map do |id|
-            item = @benchmark.case_by_id(id)
-            execute_case(item) + execute_competitors(item)
+          if @competitor_paths.any? && selection.fetch('competitor_policy') != 'configured'
+            error!('competitor adapters require the competitive profile')
           end
+          execution = {
+            'kind' => 'correctness',
+            'adapter_mode' => 'cold-process',
+            'workers' => @workers
+          }
+          manifest = run_manifest(selection, execution: execution)
+          original_cwd = Dir.pwd
+          results, worker_process_ids = execute_selected_cases(
+            selection.fetch('selected_case_ids'),
+            competitors: selection.fetch('competitor_policy') == 'configured'
+          )
           raise LocalBenchmark::Error, 'runner changed its working directory' unless Dir.pwd == original_cwd
 
           {
@@ -411,16 +556,143 @@ module Ast
             'corpus_id' => @benchmark.document['id'],
             'corpus_digest' => @benchmark.corpus_digest,
             'selection' => selection,
-            'cache_identity' => cache_identity(selection),
+            'run_manifest' => manifest,
+            'cache_identity' => cache_identity(selection, manifest),
             'competitors' => competitor_provenance,
+            'execution' => {
+              'workers_requested' => @workers,
+              'workers_used' => worker_process_ids.length,
+              'worker_process_ids' => worker_process_ids
+            },
             'results' => results
           }
         ensure
           Dir.chdir(original_cwd) if original_cwd && Dir.pwd != original_cwd
         end
 
+        def performance(profile:, changed_paths: [], iterations: 1)
+          verify_environment!
+          count = Integer(iterations)
+          error!('iterations must be positive') unless count.positive?
+
+          selection = @benchmark.select(profile: profile, changed_paths: changed_paths)
+          execution = {
+            'kind' => 'performance',
+            'adapter_mode' => 'persistent-jsonl',
+            'iterations' => count,
+            'timing_components' => %w[spawn adapter_execution harness_overhead round_trip]
+          }
+          manifest = run_manifest(selection, execution: execution)
+          FileUtils.mkdir_p(@tmp_root)
+          session = BenchmarkAdapterSession.new(
+            driver_path: @driver_path,
+            chdir: @tmp_root,
+            timeout: @timeout,
+            env: oracle_free_env
+          ).start
+          samples = selection.fetch('selected_case_ids').flat_map do |id|
+            item = @benchmark.case_by_id(id)
+            Array.new(count) do |index|
+              performance_sample(session, item, index + 1)
+            end
+          end
+          {
+            'schema_version' => 'structuredmerge.benchmark.performance-run/v1',
+            'kind' => 'performance_only',
+            'quality_classification_performed' => false,
+            'selection' => selection,
+            'run_manifest' => manifest,
+            'cache_identity' => cache_identity(selection, manifest),
+            'session' => {
+              'adapter_mode' => 'persistent-jsonl',
+              'spawn_duration_ns' => session.spawn_duration_ns,
+              'process_ids' => samples.map { |sample| sample['process_id'] }.uniq
+            },
+            'timing' => performance_timing(samples, session.spawn_duration_ns),
+            'samples' => samples
+          }
+        ensure
+          session&.close
+        end
+
         private
 
+        def execute_selected_cases(case_ids, competitors:)
+          return [[], []] if case_ids.empty?
+          if @workers == 1
+            return [execute_case_group(case_ids.each_with_index.to_a, competitors: competitors), [Process.pid]]
+          end
+
+          error!('parallel benchmark workers require Process.fork') unless Process.respond_to?(:fork)
+
+          groups = Array.new([@workers, case_ids.length].min) { [] }
+          case_ids.each_with_index { |id, index| groups[index % groups.length] << [id, index] }
+          execute_case_groups(groups, competitors: competitors)
+        end
+
+        def execute_case_groups(groups, competitors:)
+          root = @tmp_root.join("workers-#{Process.pid}-#{monotonic_nanoseconds}")
+          FileUtils.mkdir_p(root)
+          workers = groups.each_with_index.map do |group, index|
+            result_path = root.join("worker-#{index}.marshal")
+            pid = fork_case_group(group, result_path, competitors: competitors)
+            { pid: pid, result_path: result_path }
+          end
+          statuses = workers.to_h do |worker|
+            pid, status = Process.wait2(worker.fetch(:pid))
+            [pid, status]
+          end
+          payloads = workers.map do |worker|
+            result_path = worker.fetch(:result_path)
+            error!("benchmark worker #{worker.fetch(:pid)} produced no result") unless result_path.file?
+
+            # The parent reads only a result written by its own forked child in a private run directory.
+            Marshal.load(result_path.binread) # rubocop:disable Security/MarshalLoad
+          end
+          failed = workers.find { |worker| !statuses.fetch(worker.fetch(:pid)).success? }
+          if failed
+            payload = payloads.fetch(workers.index(failed))
+            details = payload[:error]&.first(2)&.join(': ') || statuses.fetch(failed.fetch(:pid)).inspect
+            error!("benchmark worker #{failed.fetch(:pid)} failed: #{details}")
+          end
+          entries = payloads.flat_map { |payload| payload.fetch(:entries) }
+          [entries.sort_by(&:first).flat_map(&:last), payloads.map { |payload| payload.fetch(:process_id) }]
+        ensure
+          FileUtils.rm_rf(root) if root
+        end
+
+        def fork_case_group(group, result_path, competitors:)
+          fork do
+            payload = {
+              process_id: Process.pid,
+              entries: execute_case_group_entries(group, competitors: competitors)
+            }
+            result_path.binwrite(Marshal.dump(payload))
+            exit! 0
+          rescue Exception => e # rubocop:disable Lint/RescueException -- worker must serialize all failures
+            result_path.binwrite(
+              Marshal.dump(process_id: Process.pid, entries: [], error: [e.class.name, e.message, e.backtrace])
+            )
+            exit! 1
+          end
+        end
+
+        def execute_case_group(indexed_case_ids, competitors:)
+          execute_case_group_entries(indexed_case_ids, competitors: competitors).sort_by(&:first).flat_map(&:last)
+        end
+
+        def execute_case_group_entries(indexed_case_ids, competitors:)
+          indexed_case_ids.map do |id, index|
+            item = @benchmark.case_by_id(id)
+            competitor_results = competitors ? execute_competitors(item) : []
+            [index, execute_case(item) + competitor_results]
+          end
+        end
+
+        def monotonic_nanoseconds
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        end
+
         def verify_environment!
           error!("missing installed driver: #{@driver_path}") unless @driver_path.file? && @driver_path.executable?
           @competitor_paths.each do |id, path|
@@ -433,12 +705,62 @@ module Ast
         end
 
         def execute_case(item)
+          return unsupported_candidate(item) unless candidate_supports?(item)
+          return execute_merge2_case(item) if item['operation'] == 'merge2'
           return execute_merge3_case(item) if item['operation'] == 'merge3'
           return execute_metamorphic_case(item) if item['operation'] == 'metamorphic'
 
           unsupported_pair(item)
         end
 
+        def unsupported_candidate(item)
+          [execute_baseline_for(item), raw_result(
+            item,
+            'structuredmerge.unsupported',
+            nil,
+            outcome: 'unsupported',
+            unsupported_reason: "candidate does not support #{item['operation']}/#{item['family']}/#{item['dialect']}"
+          )]
+        end
+
+        def execute_baseline_for(item)
+          workspace = @tmp_root.join("#{safe_id(item['id'])}-unsupported-#{Process.pid}")
+          FileUtils.rm_rf(workspace)
+          FileUtils.mkdir_p(workspace)
+          if item['operation'] == 'merge2'
+            write_merge2_roles(item, workspace)
+            execute_merge2_baseline(item, workspace)
+          elsif item['operation'] == 'metamorphic'
+            write_metamorphic_roles(item, workspace)
+            execute_metamorphic_baseline(item, workspace)
+          else
+            write_roles(item, workspace)
+            execute_baseline(item, workspace)
+          end
+        ensure
+          FileUtils.rm_rf(workspace) if workspace
+        end
+
+        def candidate_supports?(item)
+          # The default candidate is the Ruby golden master. Cross-runtime
+          # corpus cases must opt in through an adapter descriptor rather than
+          # being executed and reported as Ruby failures.
+          return item.fetch('selector').fetch('provider_id').start_with?('ruby.') unless @adapter_descriptor
+
+          support = @adapter_descriptor.fetch('supports')
+          if support['combinations']
+            return support.fetch('combinations').any? do |combination|
+              combination.fetch('family') == item.fetch('family') &&
+              combination.fetch('dialects').include?(item.fetch('dialect')) &&
+              combination.fetch('operations').include?(item.fetch('operation'))
+            end
+          end
+
+          support.fetch('operations').include?(item.fetch('operation')) &&
+            support.fetch('families').include?(item.fetch('family')) &&
+            support.fetch('dialects').include?(item.fetch('dialect'))
+        end
+
         def execute_competitors(item)
           @competitor_paths.map do |id, path|
             metadata = @benchmark.document.dig('competitors', id)
@@ -452,10 +774,37 @@ module Ast
               )
             end
 
-            execute_mergiraf(item, path)
+            execute_competitor(item, id, path)
           end
         end
 
+        def execute_competitor(item, id, path)
+          return execute_mergiraf(item, path) if id == 'mergiraf'
+          return execute_git_competitor(item, path) if id == 'git'
+
+          error!("unsupported competitor adapter: #{id}")
+        end
+
+        def execute_git_competitor(item, path)
+          workspace = @tmp_root.join("#{safe_id(item['id'])}-git-#{Process.pid}")
+          FileUtils.rm_rf(workspace)
+          FileUtils.mkdir_p(workspace)
+          write_roles(item, workspace)
+          capture = timed_capture(
+            oracle_free_env,
+            path.to_s,
+            'merge-file',
+            '-p',
+            'ours',
+            'base',
+            'theirs',
+            chdir: workspace
+          )
+          raw_result(item, 'git', capture)
+        ensure
+          FileUtils.rm_rf(workspace) if workspace
+        end
+
         def execute_mergiraf(item, path)
           workspace = @tmp_root.join("#{safe_id(item['id'])}-mergiraf-#{Process.pid}")
           FileUtils.rm_rf(workspace)
@@ -496,6 +845,20 @@ module Ast
           FileUtils.rm_rf(workspace) if workspace
         end
 
+        def execute_merge2_case(item)
+          workspace = @tmp_root.join("#{safe_id(item['id'])}-#{Process.pid}")
+          FileUtils.rm_rf(workspace)
+          FileUtils.mkdir_p(workspace)
+          write_merge2_roles(item, workspace)
+          baseline = execute_merge2_baseline(item, workspace)
+          candidate = execute_merge2_candidate(item, workspace)
+          rerun = execute_merge2_candidate(item, workspace)
+          candidate['deterministic_correctness_rerun'] = correctness_record(candidate) == correctness_record(rerun)
+          [baseline, candidate]
+        ensure
+          FileUtils.rm_rf(workspace) if workspace
+        end
+
         def execute_metamorphic_case(item)
           workspace = @tmp_root.join("#{safe_id(item['id'])}-#{Process.pid}")
           FileUtils.rm_rf(workspace)
@@ -542,6 +905,56 @@ module Ast
           end
         end
 
+        def write_merge2_roles(item, workspace)
+          %w[incoming current].each do |role|
+            workspace.join(role).binwrite(item.dig('inputs', role, 'bytes'))
+          end
+        end
+
+        def execute_merge2_baseline(item, workspace)
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+          output = workspace.join('incoming').binread
+          capture = {
+            stdout: '',
+            stderr: '',
+            status: 0,
+            output: output,
+            duration_ns: Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) - started
+          }
+          raw_result(item, 'template.overwrite', capture)
+        end
+
+        def execute_merge2_candidate(item, workspace)
+          selector = item.fetch('selector')
+          capture = timed_capture(
+            candidate_env(selector),
+            @driver_path.to_s,
+            'benchmark-provider-merge2',
+            'incoming',
+            'current',
+            "#{item['id']}.#{item['dialect']}",
+            chdir: workspace
+          )
+          result = capture[:stdout].empty? ? {} : JSON.parse(capture[:stdout])
+          capture[:stderr] = provider_diagnostics(result, capture[:stderr])
+          capture[:output] = capture[:status].zero? ? result.fetch('output') : ''
+          raw_result(item, 'ast-merge-provider.merge2', capture)
+        rescue JSON::ParserError, KeyError => e
+          capture ||= { stdout: '', stderr: '', status: 2, duration_ns: 0 }
+          capture[:stderr] = [capture[:stderr], e.message].reject(&:empty?).join("\n")
+          capture[:status] = 2
+          capture[:output] = ''
+          raw_result(item, 'ast-merge-provider.merge2', capture)
+        end
+
+        def provider_diagnostics(result, stderr)
+          diagnostics = Array(result['diagnostics']).filter_map do |diagnostic|
+            message = diagnostic['message'] || diagnostic[:message]
+            message && "#{diagnostic['category'] || diagnostic[:category]}: #{message}"
+          end
+          [stderr, *diagnostics].reject(&:empty?).join("\n")
+        end
+
         def write_metamorphic_roles(item, workspace)
           %w[source transformed].each do |role|
             workspace.join(role).binwrite(item.dig('inputs', role, 'bytes'))
@@ -632,7 +1045,12 @@ module Ast
           output = capture&.fetch(:output, '') || ''
           checks = equivalence_checks(item, output)
           markers = conflict_regions(output)
-          classified = outcome || classify(item, capture.fetch(:status), checks)
+          classified = outcome || classify(
+            item,
+            capture.fetch(:status),
+            checks,
+            stderr: capture.fetch(:stderr, '')
+          )
           eligible = item.dig('oracle', 'score_eligible') && !%w[unsupported excluded_ambiguous].include?(classified)
           {
             'schema_version' => 'structuredmerge.benchmark.result/v1',
@@ -664,8 +1082,15 @@ module Ast
         end
 
         def adapter_role(adapter)
-          return 'baseline' if adapter.start_with?('git.')
-          return 'candidate' if %w[ast-merge-git ast-merge-provider.diff2 structuredmerge.unsupported].include?(adapter)
+          return 'baseline' if adapter.start_with?('git.') || adapter == 'template.overwrite'
+
+          candidates = %w[
+            ast-merge-git
+            ast-merge-provider.diff2
+            ast-merge-provider.merge2
+            structuredmerge.unsupported
+          ]
+          return 'candidate' if candidates.include?(adapter)
 
           'competitor'
         end
@@ -792,18 +1217,29 @@ module Ast
           'analyzed'
         end
 
-        def classify(item, status, checks)
+        def classify(item, status, checks, stderr: '')
           expected = item.dig('expected', 'outcome')
           return 'excluded_ambiguous' if expected == 'excluded_ambiguous'
+
+          if expected == 'error'
+            return 'error' if status.nil?
+
+            return expected_error_diagnostic?(status, stderr) ? 'correct_clean' : 'error' if status >= 2
+
+            return status == 1 ? 'false_conflict' : 'false_auto_merge'
+          end
           return 'error' if status.nil? || status >= 2
-          return status == 1 ? 'false_conflict' : 'false_auto_merge' if expected == 'error'
           return status == 1 ? 'true_conflict' : 'false_auto_merge' if expected == 'conflict'
           return 'false_conflict' if status == 1
-          return 'correct_clean' if checks['acceptable']
+          return 'correct_clean' if checks['equivalence_acceptable']
 
           'false_auto_merge'
         end
 
+        def expected_error_diagnostic?(status, stderr)
+          status >= 2 && /\A[^:\r\n]+: (?:destination_)?parse_error:/i.match?(stderr.to_s)
+        end
+
         def equivalence_checks(item, output)
           expected = item.dig('expected', 'output', 'bytes')
           exact = !expected.nil? && output == expected
@@ -825,8 +1261,20 @@ module Ast
             'accepted_equivalence' => selected&.fetch('class'),
             'parse_validity_only_accepted' => false
           }
-          violations = preservation_violations(item, checks, output)
-          checks.merge('preservation_violations' => violations, 'acceptable' => !selected.nil? && violations.empty?)
+          preservation = preservation_evaluations(item, checks, output)
+          violations = preservation.filter_map { |name, status| name if status == 'fail' }
+          unverified = preservation.filter_map { |name, status| name if status == 'unverified' }
+          equivalence_acceptable = !selected.nil?
+          preservation_acceptable = violations.empty? && unverified.empty?
+          checks.merge(
+            'agreement' => agreement(expected, output),
+            'preservation_evaluations' => preservation,
+            'preservation_violations' => violations,
+            'preservation_unverified' => unverified,
+            'equivalence_acceptable' => equivalence_acceptable,
+            'preservation_acceptable' => preservation_acceptable,
+            'acceptable' => equivalence_acceptable && preservation_acceptable
+          )
         end
 
         def structural_equivalence(item, output, expected)
@@ -856,6 +1304,34 @@ module Ast
           policy['provider'].to_s == item.dig('selector', 'provider_id').to_s
         end
 
+        def agreement(expected, output)
+          return nil unless expected
+
+          {
+            'line' => sequence_agreement(expected.lines, output.lines),
+            'token' => sequence_agreement(lexemes(expected), lexemes(output))
+          }
+        end
+
+        def lexemes(content)
+          content.split(/(\s+)/).reject(&:empty?)
+        end
+
+        def sequence_agreement(expected, output)
+          expected_counts = expected.tally
+          output_counts = output.tally
+          matched = expected_counts.sum do |value, count|
+            [count, output_counts.fetch(value, 0)].min
+          end
+          denominator = [expected.length, output.length].max
+          {
+            'matched' => matched,
+            'expected' => expected.length,
+            'observed' => output.length,
+            'percent' => denominator.zero? ? nil : (matched * 100.0 / denominator).round(2)
+          }
+        end
+
         def dimensions(item, outcome, checks)
           eligible = item.dig('oracle', 'score_eligible')
           {
@@ -872,35 +1348,55 @@ module Ast
             'preservation' => {
               'eligible' => eligible,
               'requirements' => item['preservation_policy'],
-              'violations' => checks.fetch('preservation_violations')
+              'agreement' => checks['agreement'],
+              'violations' => checks.fetch('preservation_violations', []),
+              'unverified' => checks.fetch('preservation_unverified', [])
             },
             'performance' => { 'quality_offset_allowed' => false }
           }
         end
 
-        def preservation_violations(item, checks, output)
-          return [] if checks['exact']
-
+        def preservation_evaluations(item, checks, output)
           expected = item.dig('expected', 'output', 'bytes')
-          return [] unless expected
+          return {} unless expected
 
-          item['preservation_policy'].filter_map do |name, requirement|
-            next unless requirement == 'required'
-            next unless preservation_violation?(name, output, expected, checks)
+          item['preservation_policy'].to_h do |name, requirement|
+            next [name, 'not_required'] unless requirement == 'required'
+            next [name, 'pass'] if checks['exact']
 
-            name
+            [name, preservation_evaluation(name, output, expected, checks)]
           end
         end
 
-        def preservation_violation?(name, output, expected, checks)
+        def preservation_evaluation(name, output, expected, checks)
           case name
-          when 'encoding' then output.encoding != expected.encoding
-          when 'line_endings' then line_ending_style(output) != line_ending_style(expected)
-          when 'unknown_fields' then checks['structural'] != true
-          else output != expected
+          when 'encoding'
+            encoding_signature(output) == encoding_signature(expected) ? 'pass' : 'fail'
+          when 'line_endings'
+            line_ending_style(output) == line_ending_style(expected) ? 'pass' : 'fail'
+          when 'unknown_fields'
+            checks['structural'] == true ? 'pass' : 'unverified'
+          when 'formatting', 'source_regions'
+            output == expected ? 'pass' : 'fail'
+          else
+            'unverified'
           end
         end
 
+        def encoding_signature(content)
+          bytes = content.b
+          bom = if bytes.start_with?("\xEF\xBB\xBF".b)
+                  'utf-8-bom'
+                elsif bytes.start_with?("\xFF\xFE".b)
+                  'utf-16le-bom'
+                elsif bytes.start_with?("\xFE\xFF".b)
+                  'utf-16be-bom'
+                end
+          return bom if bom
+
+          bytes.dup.force_encoding(Encoding::UTF_8).valid_encoding? ? 'utf-8' : 'binary'
+        end
+
         def line_ending_style(content)
           return 'crlf' if content.include?("\r\n")
 
@@ -953,7 +1449,7 @@ module Ast
           lines = stderr.lines.map(&:strip).reject(&:empty?)
           lines << unsupported_reason if unsupported_reason
           lines.map do |line|
-            match = /\Aast-merge-git: ([a-z_]+):/.match(line)
+            match = /\A(?:[^:\r\n]+:\s+)?([a-z_]+):/i.match(line)
             category = match&.[](1) || (unsupported_reason == line ? 'unsupported' : 'process')
             { 'severity' => 'error', 'category' => category, 'message' => line }
           end
@@ -978,26 +1474,36 @@ module Ast
           ENV.keys.grep(/(?:ORACLE|EXPECTED)/i).to_h { |name| [name, nil] }
         end
 
-        def cache_identity(selection)
-          source_sha, = Open3.capture2('git', '-C', Pathname(__dir__).join('..', '..', '..', '..').to_s,
-                                       'rev-parse', 'HEAD')
-          environment = {
-            'ruby' => RUBY_DESCRIPTION,
-            'platform' => RUBY_PLATFORM,
-            'host_os' => RbConfig::CONFIG['host_os'],
-            'host_cpu' => RbConfig::CONFIG['host_cpu']
+        def run_manifest(selection, execution: { 'kind' => 'correctness', 'adapter_mode' => 'cold-process' })
+          configuration = benchmark_configuration(selection, execution: execution)
+          manifest = {
+            'schema_version' => 'structuredmerge.benchmark.run-manifest/v1',
+            'adapter' => adapter_identity,
+            'configuration' => configuration,
+            'environment' => run_environment,
+            'corpus' => {
+              'id' => @benchmark.document.fetch('id'),
+              'sha256' => @benchmark.corpus_digest
+            }
           }
-          configuration = selection['selected_case_ids'].map do |id|
-            @benchmark.case_by_id(id).slice('id', 'selector')
-          end
+          manifest.merge('sha256' => canonical_digest(manifest))
+        end
+
+        def cache_identity(selection, manifest = run_manifest(selection))
+          configuration = manifest.fetch('configuration')
           competitors = competitor_provenance
           identity = {
-            'adapter_source_sha' => source_sha.strip,
-            'adapter_artifact_sha256' => Digest::SHA256.file(@driver_path).hexdigest,
-            'configuration_sha256' => Digest::SHA256.hexdigest(JSON.generate(configuration)),
+            'adapter_id' => manifest.dig('adapter', 'adapter_id'),
+            'adapter_source_sha' => manifest.dig('adapter', 'source', 'revision'),
+            'adapter_artifact_sha256' => manifest.dig('adapter', 'artifact', 'sha256'),
+            'configuration_sha256' => canonical_digest(configuration),
+            'parser_providers' => configuration.fetch('cases').map do |item|
+              item.fetch('parser_provider')
+            end.uniq,
+            'run_manifest_sha256' => manifest.fetch('sha256'),
             'competitors' => competitors,
             'corpus_sha256' => @benchmark.corpus_digest,
-            'environment' => environment,
+            'environment' => manifest.fetch('environment'),
             'profile' => selection['profile'],
             'changed_paths' => selection['changed_paths'],
             'inferred_capabilities' => selection['inferred_capabilities'],
@@ -1009,12 +1515,279 @@ module Ast
           identity.merge('sha256' => Digest::SHA256.hexdigest(JSON.generate(identity)))
         end
 
+        def benchmark_configuration(selection, execution:)
+          provider = @adapter_descriptor&.fetch('provider')
+          {
+            'profile' => selection.fetch('profile'),
+            'changed_paths' => selection.fetch('changed_paths'),
+            'inferred_capabilities' => selection.fetch('inferred_capabilities'),
+            'selected_case_ids' => selection.fetch('selected_case_ids'),
+            'timeout_seconds' => @timeout,
+            'network_policy' => @benchmark.document.fetch('network_policy'),
+            'competitor_ids' => @competitor_paths.keys.sort,
+            'execution' => execution,
+            'cases' => selection.fetch('selected_case_ids').map do |id|
+              item = @benchmark.case_by_id(id)
+              selector = item.fetch('selector')
+              backend_ref = TreeHaver::BackendRegistry.fetch(selector.fetch('backend')) unless provider
+              case_configuration = {
+                'case_id' => id,
+                'operation' => item.fetch('operation'),
+                'merge_provider' => adapter_merge_provider(item) || {
+                  'provider_id' => selector.fetch('provider_id'),
+                  'require_path' => selector.fetch('require')
+                },
+                'parser_provider' => provider&.fetch('parser_provider') || {
+                  'requested_backend_id' => selector.fetch('backend'),
+                  'backend_family' => backend_ref&.family,
+                  'selection_mode' => 'explicit'
+                },
+                'selector' => selector
+              }
+              case_configuration['selector_role'] = 'oracle_context' if provider
+              case_configuration
+            end
+          }
+        end
+
+        def adapter_merge_provider(item)
+          return unless @adapter_descriptor
+
+          provider = @adapter_descriptor.fetch('provider')
+          provider.dig('merge_providers', item.fetch('family')) || provider['merge_provider']
+        end
+
+        def performance_sample(session, item, iteration)
+          request_id = "#{item.fetch('id')}.#{iteration}"
+          response = session.request(benchmark_adapter_request(item, request_id))
+          output = BenchmarkAdapter.decode_source(response.fetch('output_base64'))
+          adapter_duration = response.fetch('duration_ns')
+          round_trip_duration = response.fetch('round_trip_duration_ns')
+          harness_overhead = [round_trip_duration - adapter_duration, 0].max
+          measurement_class = if response.fetch('session_request_index') == 1
+                                'session_startup_and_first_request'
+                              else
+                                'warm_persistent_process'
+                              end
+          {
+            'case_id' => item.fetch('id'),
+            'request_id' => request_id,
+            'iteration' => iteration,
+            'operation' => response['operation'],
+            'process_id' => response.fetch('process_id'),
+            'status' => response.fetch('status'),
+            'result' => response.fetch('result'),
+            'diagnostics' => diagnostics(response.fetch('stderr'), nil),
+            'output' => raw_record(output),
+            'runtime' => {
+              'adapter_duration_ns' => adapter_duration,
+              'harness_overhead_ns' => harness_overhead,
+              'round_trip_duration_ns' => round_trip_duration,
+              'measurement_class' => measurement_class
+            }
+          }
+        rescue ArgumentError => e
+          error!("invalid adapter response for #{request_id}: #{e.message}")
+        end
+
+        def performance_timing(samples, spawn_duration)
+          runtimes = samples.map { |sample| sample.fetch('runtime') }
+          {
+            'spawn_duration_ns' => spawn_duration,
+            'adapter_execution_total_ns' => runtimes.sum { |runtime| runtime.fetch('adapter_duration_ns') },
+            'harness_overhead_total_ns' => runtimes.sum { |runtime| runtime.fetch('harness_overhead_ns') },
+            'round_trip_total_ns' => runtimes.sum { |runtime| runtime.fetch('round_trip_duration_ns') },
+            'first_request_includes_runtime_startup' => true,
+            'quality_classification_uses_these_values' => false
+          }
+        end
+
+        def benchmark_adapter_request(item, request_id)
+          operation, roles = benchmark_adapter_operation(item)
+          {
+            'schema_version' => BenchmarkAdapter::REQUEST_SCHEMA,
+            'request_id' => request_id,
+            'operation' => operation,
+            'selector' => item.fetch('selector'),
+            'path_name' => "#{item.fetch('id')}.#{item.fetch('dialect')}",
+            'sources' => roles.to_h do |adapter_role, corpus_role|
+              [adapter_role, BenchmarkAdapter.encode_source(item.dig('inputs', corpus_role, 'bytes'))]
+            end
+          }
+        end
+
+        def benchmark_adapter_operation(item)
+          case item.fetch('operation')
+          when 'merge2' then ['merge2', { 'incoming' => 'incoming', 'current' => 'current' }]
+          when 'merge3' then ['merge3', { 'base' => 'base', 'ours' => 'ours', 'theirs' => 'theirs' }]
+          when 'metamorphic' then ['diff2', { 'before' => 'source', 'after' => 'transformed' }]
+          when 'diff' then ['diff2', { 'before' => 'before', 'after' => 'after' }]
+          else error!("unsupported benchmark adapter operation: #{item.fetch('operation')}")
+          end
+        end
+
+        def source_provenance(root: Pathname(__dir__).join('..', '..', '..', '..').expand_path,
+                              repository: 'structuredmerge/structuredmerge-ruby', label: 'Ruby golden-master')
+          revision, revision_status = Open3.capture2('git', '-C', root.to_s, 'rev-parse', 'HEAD')
+          error!("cannot determine #{label} source revision") unless revision_status.success?
+
+          status, status_result = Open3.capture2('git', '-C', root.to_s, 'status', '--porcelain',
+                                                 '--untracked-files=no')
+          error!("cannot determine #{label} source state") unless status_result.success?
+
+          {
+            'repository' => repository,
+            'revision' => revision.strip,
+            'dirty' => !status.empty?
+          }
+        end
+
+        def adapter_identity
+          artifact = {
+            'path' => @driver_path.to_s,
+            'sha256' => Digest::SHA256.file(@driver_path).hexdigest
+          }
+          unless @adapter_descriptor
+            return {
+              'adapter_id' => 'ruby-gm.ast-merge-git',
+              'implementation' => 'ruby-golden-master',
+              'package' => Ast::Merge::Git::PACKAGE_NAME,
+              'package_version' => Ast::Merge::Git::VERSION,
+              'source' => source_provenance,
+              'artifact' => artifact
+            }
+          end
+
+          declared = @adapter_descriptor.fetch('adapter')
+          source = declared.fetch('source')
+          declared.slice('adapter_id', 'implementation', 'package', 'package_version').merge(
+            'source' => source_provenance(
+              root: @adapter_descriptor.fetch('source_root'),
+              repository: source.fetch('repository'),
+              label: declared.fetch('adapter_id')
+            ),
+            'artifact' => artifact
+          )
+        end
+
+        def run_environment
+          return benchmark_environment unless @adapter_descriptor
+
+          {
+            'harness' => benchmark_environment,
+            'adapter' => @adapter_descriptor.fetch('environment')
+          }
+        end
+
+        def load_adapter_descriptor(path)
+          return unless path
+
+          descriptor_path = Pathname(path).expand_path
+          descriptor = JSON.parse(descriptor_path.binread)
+          unless descriptor['schema_version'] == ADAPTER_DESCRIPTOR_SCHEMA
+            error!('unsupported adapter descriptor schema')
+          end
+          %w[adapter source_root provider supports environment].each do |key|
+            error!("adapter descriptor missing #{key}") unless descriptor.key?(key)
+          end
+          %w[adapter_id implementation package package_version source].each do |key|
+            error!("adapter descriptor missing adapter.#{key}") unless descriptor.fetch('adapter').key?(key)
+          end
+          unless descriptor.dig('adapter', 'source', 'repository')
+            error!('adapter descriptor missing adapter.source.repository')
+          end
+          provider = descriptor.fetch('provider')
+          error!('adapter descriptor missing provider.parser_provider') unless provider.key?('parser_provider')
+          unless provider.key?('merge_provider') || provider['merge_providers'].is_a?(Hash)
+            error!('adapter descriptor requires provider.merge_provider or provider.merge_providers')
+          end
+          %w[operations families dialects].each do |key|
+            values = descriptor.fetch('supports')[key]
+            unless values.is_a?(Array) && values.any?
+              error!("adapter descriptor supports.#{key} must be a non-empty array")
+            end
+          end
+          validate_support_combinations!(descriptor.fetch('supports'))
+          source_root = Pathname(descriptor.fetch('source_root'))
+          source_root = descriptor_path.dirname.join(source_root) unless source_root.absolute?
+          descriptor.merge('source_root' => source_root.expand_path)
+        rescue JSON::ParserError => e
+          error!("invalid adapter descriptor JSON: #{e.message}")
+        rescue SystemCallError => e
+          error!("cannot read adapter descriptor: #{e.message}")
+        end
+
+        def validate_support_combinations!(support)
+          return unless support.key?('combinations')
+
+          combinations = support.fetch('combinations')
+          unless combinations.is_a?(Array) && combinations.any?
+            error!('adapter descriptor supports.combinations must be a non-empty array')
+          end
+          combinations.each do |combination|
+            error!('adapter support combination requires family') unless combination['family'].is_a?(String)
+            %w[operations dialects].each do |key|
+              values = combination[key]
+              unless values.is_a?(Array) && values.any?
+                error!("adapter support combination #{key} must be a non-empty array")
+              end
+            end
+          end
+        end
+
+        def benchmark_environment
+          allowlisted = %w[
+            BUNDLE_GEMFILE
+            STRUCTUREDMERGE_DEV
+            TREE_HAVER_BACKEND
+            TREE_HAVER_NATIVE_BACKEND
+            TREE_HAVER_RUBY_BACKEND
+            TSLP_DEV
+          ].to_h { |name| [name, ENV[name]] }
+          {
+            'git' => git_environment,
+            'ruby' => RUBY_DESCRIPTION,
+            'ruby_engine' => defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby',
+            'ruby_version' => RUBY_VERSION,
+            'rubygems' => Gem::VERSION,
+            'bundler' => Gem.loaded_specs['bundler']&.version&.to_s,
+            'platform' => RUBY_PLATFORM,
+            'host_os' => RbConfig::CONFIG['host_os'],
+            'host_cpu' => RbConfig::CONFIG['host_cpu'],
+            'allowlisted_env' => allowlisted
+          }
+        end
+
+        def git_environment
+          executable, = Open3.capture2('sh', '-c', 'command -v git')
+          version, status = Open3.capture2('git', '--version')
+          return { 'available' => false } unless status.success?
+
+          path = Pathname(executable.strip)
+          {
+            'available' => true,
+            'path' => path.to_s,
+            'version' => version.strip,
+            'sha256' => path.file? ? Digest::SHA256.file(path).hexdigest : nil
+          }
+        rescue SystemCallError
+          { 'available' => false }
+        end
+
+        def canonical_digest(value)
+          Digest::SHA256.hexdigest(JSON.generate(deep_sort(value)))
+        end
+
         def competitor_provenance
           @competitor_provenance ||= @competitor_paths.to_h do |id, path|
             metadata = @benchmark.document.fetch('competitors').fetch(id)
             capture = timed_capture(oracle_free_env, path.to_s, '--version', chdir: path.dirname)
             error!("#{id} version probe failed: #{capture[:stderr].strip}") unless capture[:status].zero?
-            expected = "#{metadata.fetch('adapter_id')} #{metadata.fetch('version')}"
+            expected = if id == 'git'
+                         "#{metadata.fetch('adapter_id')} version #{metadata.fetch('version')}"
+                       else
+                         "#{metadata.fetch('adapter_id')} #{metadata.fetch('version')}"
+                       end
             error!("#{id} version differs: #{capture[:stdout].strip}") unless capture[:stdout].strip == expected
 
             [id, metadata.merge(
@@ -1066,12 +1839,18 @@ module Ast
         def build
           pairs = @results.group_by { |result| result['case_id'] }.values.map { |items| transition(items) }
           false_auto_merges = candidate_eligible.select { |item| item['outcome'] == 'false_auto_merge' }
+          preservation_failures = candidate_eligible.select do |item|
+            item.dig('dimensions', 'preservation', 'violations').any? ||
+              item.dig('dimensions', 'preservation', 'unverified').any?
+          end
+          unexpected_errors = candidate_results.select { |item| item['outcome'] == 'error' }
           {
             'schema_version' => 'structuredmerge.benchmark.report/v1',
             'kind' => 'paired_aggregate_report',
             'corpus_id' => @run['corpus_id'],
             'corpus_digest' => @run['corpus_digest'],
             'selection' => @run['selection'],
+            'run_manifest' => @run.fetch('run_manifest'),
             'cache_identity' => @run['cache_identity'],
             'dimensions' => {
               'safety' => {
@@ -1082,15 +1861,20 @@ module Ast
               },
               'effectiveness' => outcome_counts,
               'preservation' => {
-                'eligible' => eligible.length,
-                'violation_result_ids' => eligible.filter_map do |item|
+                'eligible' => candidate_eligible.length,
+                'violation_result_ids' => candidate_eligible.filter_map do |item|
                   item['id'] if item.dig('dimensions', 'preservation', 'violations').any?
-                end
+                end,
+                'unverified_result_ids' => candidate_eligible.filter_map do |item|
+                  item['id'] if item.dig('dimensions', 'preservation', 'unverified').any?
+                end,
+                'gate' => preservation_failures.empty? ? 'pass' : 'fail'
               },
               'performance' => performance,
-              'reliability' => { 'error_result_ids' => @results.filter_map do |item|
-                item['id'] if item['outcome'] == 'error'
-              end },
+              'reliability' => {
+                'error_result_ids' => unexpected_errors.map { |item| item['id'] },
+                'gate' => unexpected_errors.empty? ? 'pass' : 'fail'
+              },
               'coverage' => coverage,
               'competitive' => competitive
             },
@@ -1099,7 +1883,7 @@ module Ast
             'newly_passing_case_ids' => pairs.filter_map { |pair| pair['case_id'] if pair['newly_passing'] },
             'newly_failing_case_ids' => pairs.filter_map { |pair| pair['case_id'] if pair['newly_failing'] },
             'changed_conflict_case_ids' => pairs.filter_map { |pair| pair['case_id'] if pair['changed_conflict'] },
-            'hard_gate_failed' => false_auto_merges.any?,
+            'hard_gate_failed' => false_auto_merges.any? || preservation_failures.any? || unexpected_errors.any?,
             'scalar_score' => nil
           }
         end
@@ -1114,6 +1898,10 @@ module Ast
           eligible.select { |item| item['adapter_role'] == 'candidate' }
         end
 
+        def candidate_results
+          @results.select { |item| item['adapter_role'] == 'candidate' }
+        end
+
         def outcome_counts
           %w[correct_clean false_conflict true_conflict false_auto_merge error unsupported
              excluded_ambiguous].to_h do |outcome|
@@ -1130,8 +1918,10 @@ module Ast
             'candidate_result_id' => candidate['id'],
             'from' => baseline['outcome'],
             'to' => candidate['outcome'],
-            'newly_passing' => !SUCCESS.include?(baseline['outcome']) && SUCCESS.include?(candidate['outcome']),
-            'newly_failing' => SUCCESS.include?(baseline['outcome']) && !SUCCESS.include?(candidate['outcome']),
+            'newly_passing' => !unsupported?(candidate) &&
+              !SUCCESS.include?(baseline['outcome']) && SUCCESS.include?(candidate['outcome']),
+            'newly_failing' => !unsupported?(candidate) &&
+              SUCCESS.include?(baseline['outcome']) && !SUCCESS.include?(candidate['outcome']),
             'changed_conflict' => conflict?(baseline) && conflict?(candidate) &&
               baseline.dig('raw', 'output', 'sha256') != candidate.dig('raw', 'output', 'sha256')
           }
@@ -1141,6 +1931,10 @@ module Ast
           %w[false_conflict true_conflict].include?(result['outcome'])
         end
 
+        def unsupported?(result)
+          result['outcome'] == 'unsupported'
+        end
+
         def performance
           @results.group_by { |item| item['adapter_id'] }.transform_values do |items|
             values = items.filter_map { |item| item.dig('runtime', 'duration_ns') }
@@ -1160,9 +1954,24 @@ module Ast
 
         def competitive
           results = @results.select { |item| item['adapter_role'] == 'competitor' }
+          adapters = results.group_by { |item| item['adapter_id'] }.transform_values do |items|
+            unsupported = items.select { |item| item['outcome'] == 'unsupported' }
+            supported = items - unsupported
+            eligible = supported.count { |item| item['score_eligible'] }
+            selected = items.map { |item| item['case_id'] }.uniq.length
+            {
+              'selected_cases' => selected,
+              'supported_cases' => supported.length,
+              'eligible_cases' => eligible,
+              'coverage' => coverage_ratio(eligible, selected),
+              'unsupported_case_ids' => unsupported.map { |item| item['case_id'] },
+              'outcomes' => items.group_by { |item| item['outcome'] }.transform_values(&:length)
+            }
+          end
           {
             'configured' => @run.fetch('competitors'),
             'outcomes' => results.group_by { |item| item['outcome'] }.transform_values(&:length),
+            'adapters' => adapters,
             'unsupported_case_ids' => results.filter_map do |item|
               item['case_id'] if item['outcome'] == 'unsupported'
             end,
@@ -1173,6 +1982,14 @@ module Ast
           }
         end
 
+        def coverage_ratio(numerator, denominator)
+          {
+            'numerator' => numerator,
+            'denominator' => denominator,
+            'percent' => denominator.zero? ? nil : (numerator * 100.0 / denominator).round(2)
+          }
+        end
+
         def strata
           case_results = @results.select { |item| item['adapter_role'] == 'candidate' }
           tag_fields = %w[operation partition family provider dialect false_auto_merge_severity]