ast-merge-git 7.1.7 → 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
@@ -39,6 +40,12 @@ module Ast
           '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
 
@@ -88,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,
@@ -120,7 +135,7 @@ module Ast
             end,
             'budgets' => definition.fetch('budgets'),
             'explanation' => explanation(
-              profile,
+              definition.fetch('selection_mode'),
               inferred: inferred,
               direct: direct,
               sentinels: sentinels,
@@ -137,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
 
@@ -332,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],
@@ -374,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',
@@ -388,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
 
           {
@@ -412,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|
@@ -434,6 +705,7 @@ 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'
@@ -441,6 +713,54 @@ module Ast
           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)
@@ -454,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)
@@ -589,6 +936,7 @@ module Ast
             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
@@ -599,6 +947,14 @@ module Ast
           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'))
@@ -864,9 +1220,12 @@ module Ast
         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
@@ -878,7 +1237,7 @@ module Ast
         end
 
         def expected_error_diagnostic?(status, stderr)
-          status >= 2 && /\Aast-merge-git: parse_error:/i.match?(stderr.to_s)
+          status >= 2 && /\A[^:\r\n]+: (?:destination_)?parse_error:/i.match?(stderr.to_s)
         end
 
         def equivalence_checks(item, output)
@@ -908,6 +1267,7 @@ module Ast
           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,
@@ -944,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')
           {
@@ -960,6 +1348,7 @@ module Ast
             'preservation' => {
               'eligible' => eligible,
               'requirements' => item['preservation_policy'],
+              'agreement' => checks['agreement'],
               'violations' => checks.fetch('preservation_violations', []),
               'unverified' => checks.fetch('preservation_unverified', [])
             },
@@ -1060,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
@@ -1085,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'],
@@ -1116,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(
@@ -1184,6 +1850,7 @@ module Ast
             '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' => {
@@ -1251,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')
           }
@@ -1262,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') }
@@ -1281,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,
@@ -1294,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]