evilution 1.0.0 → 1.2.0

data/lib/evilution/reporter/cli/line_formatters/infra_retry_notice.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+# EV-j0bv / GH #1607: parallel workers contending on shared infrastructure — a
+# database file, a lock — crash the test process in a way that says nothing
+# about the mutation. Those mutations are re-run serially once the pool is
+# done, and the run says so, because the alternative is a neutral count that
+# moves with --jobs on identical input with no explanation.
+class Evilution::Reporter::CLI::LineFormatters::InfraRetryNotice
+  def format(summary)
+    count = summary.infra_retried
+    return nil if count.zero?
+
+    noun = count == 1 ? "mutation" : "mutations"
+    pronoun = count == 1 ? "it" : "them"
+    "! #{count} #{noun} hit infrastructure errors under parallel workers; re-ran #{pronoun} serially."
+  end
+end

data/lib/evilution/reporter/cli/line_formatters/result_line.rb

@@ -3,18 +3,42 @@
 require_relative "../line_formatters"
 require_relative "../pct"
 
+# The threshold comes from the run's own configuration. Printing a verdict
+# against a default the exit code did not share is what made a 0% score report
+# `FAIL` and exit 0 (EV-39t1 / GH #1604); with no minimum configured the line
+# states the score and says so, rather than implying a gate that is not armed.
 class Evilution::Reporter::CLI::LineFormatters::ResultLine
-  DEFAULT_MIN_SCORE = 0.8
-
-  def initialize(pct: Evilution::Reporter::CLI::Pct.new, min_score: DEFAULT_MIN_SCORE)
+  def initialize(pct: Evilution::Reporter::CLI::Pct.new, min_score: nil)
     @pct = pct
     @min_score = min_score
   end
 
   def format(summary)
+    return unresolved_targets_line(summary) if summary.unresolved_targets?
+    return no_threshold_line(summary) unless gate?
+
     pass_fail = summary.success?(min_score: @min_score) ? "PASS" : "FAIL"
     score_pct = @pct.format(summary.score)
     threshold_pct = @pct.format(@min_score)
     "Result: #{pass_fail} (score #{score_pct} #{pass_fail == "PASS" ? ">=" : "<"} #{threshold_pct})"
   end
+
+  private
+
+  # A minimum of zero passes every score, so it is not a gate either.
+  def gate?
+    !@min_score.nil? && @min_score.positive?
+  end
+
+  def no_threshold_line(summary)
+    "Result: #{@pct.format(summary.score)} (no minimum score set)"
+  end
+
+  # The score covers only the files that resolved to a spec, so reporting it
+  # against the threshold here would name the wrong problem.
+  def unresolved_targets_line(summary)
+    count = summary.unresolved_target_files.length
+    subject = count == 1 ? "target file has" : "target files have"
+    "Result: FAIL (#{count} #{subject} no resolvable spec)"
+  end
 end

data/lib/evilution/reporter/cli/line_formatters/score.rb

@@ -3,12 +3,30 @@
 require_relative "../line_formatters"
 require_relative "../pct"
 
+# The score covers only the mutations that got a verdict. Where a run left some
+# out — neutral, unresolved, equivalent, errored — full marks over a fraction of
+# it reads as a verdict on the whole, so the line says how much it covered
+# (EV-5pob / GH #1606).
 class Evilution::Reporter::CLI::LineFormatters::Score
   def initialize(pct: Evilution::Reporter::CLI::Pct.new)
     @pct = pct
   end
 
   def format(summary)
-    "Score: #{@pct.format(summary.score)} (#{summary.killed}/#{summary.score_denominator})"
+    "Score: #{@pct.format(summary.score)} (#{counts(summary)})"
+  end
+
+  private
+
+  def counts(summary)
+    verified = summary.score_denominator
+    pair = "#{summary.killed}/#{verified}"
+    return pair if verified == summary.total
+
+    "#{pair} verified of #{summary.total} mutations#{neutral_note(summary)}"
+  end
+
+  def neutral_note(summary)
+    summary.neutral.positive? ? ", #{summary.neutral} neutral" : ""
   end
 end

data/lib/evilution/reporter/cli/line_formatters/unresolved_targets.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+# EV-p4sm / GH #1603: a target file that resolves to no test file contributes
+# only a handful of `unresolved` mutations, which UnresolvedRateWarning dilutes
+# against every other file in the run — 14 unresolved out of 98 sits under its
+# threshold and says nothing at all. This formatter reports the stronger,
+# per-file fact instead, and names the files so the reader knows which of the
+# paths they passed was never tested.
+class Evilution::Reporter::CLI::LineFormatters::UnresolvedTargets
+  def format(summary)
+    return nil unless summary.unresolved_targets?
+
+    files = summary.unresolved_target_files
+    listing = files.map { |path| "    #{path}" }.join("\n")
+    "! #{headline(files.length, summary.target_file_count)}:\n#{listing}"
+  end
+
+  private
+
+  # The ratio is dropped rather than guessed when the run's target count is
+  # unknown, which is how a summary restored from a saved session arrives. The
+  # noun agrees with whichever number it follows ("1 of 2 target files has",
+  # "1 target file has"), the verb with how many were unresolved.
+  def headline(unresolved_count, target_file_count)
+    noun_count = target_file_count.nil? ? unresolved_count : target_file_count
+    noun = noun_count == 1 ? "target file" : "target files"
+    verb = unresolved_count == 1 ? "has" : "have"
+    tail = unresolved_count == 1 ? "it was never tested" : "they were never tested"
+    scope = target_file_count.nil? ? unresolved_count.to_s : "#{unresolved_count} of #{target_file_count}"
+
+    "#{scope} #{noun} #{verb} no resolvable spec — #{tail}"
+  end
+end

data/lib/evilution/reporter/cli/metrics_block.rb

@@ -5,6 +5,8 @@ require_relative "line_formatters/mutations"
 require_relative "line_formatters/score"
 require_relative "line_formatters/error_rate_warning"
 require_relative "line_formatters/unresolved_rate_warning"
+require_relative "line_formatters/unresolved_targets"
+require_relative "line_formatters/infra_retry_notice"
 require_relative "line_formatters/duration"
 require_relative "line_formatters/efficiency"
 require_relative "line_formatters/peak_memory"
@@ -15,6 +17,8 @@ class Evilution::Reporter::CLI::MetricsBlock
     Evilution::Reporter::CLI::LineFormatters::Score.new,
     Evilution::Reporter::CLI::LineFormatters::ErrorRateWarning.new,
     Evilution::Reporter::CLI::LineFormatters::UnresolvedRateWarning.new,
+    Evilution::Reporter::CLI::LineFormatters::UnresolvedTargets.new,
+    Evilution::Reporter::CLI::LineFormatters::InfraRetryNotice.new,
     Evilution::Reporter::CLI::LineFormatters::Duration.new,
     Evilution::Reporter::CLI::LineFormatters::Efficiency.new,
     Evilution::Reporter::CLI::LineFormatters::PeakMemory.new

data/lib/evilution/reporter/cli/trailer.rb

@@ -6,14 +6,18 @@ require_relative "line_formatters/result_line"
 require_relative "line_formatters/feedback_footer"
 
 class Evilution::Reporter::CLI::Trailer
-  DEFAULT_LINES = [
-    Evilution::Reporter::CLI::LineFormatters::TruncationNotice.new,
-    Evilution::Reporter::CLI::LineFormatters::ResultLine.new,
-    Evilution::Reporter::CLI::LineFormatters::FeedbackFooter.new
-  ].freeze
+  def self.default_lines(min_score: nil)
+    [
+      Evilution::Reporter::CLI::LineFormatters::TruncationNotice.new,
+      Evilution::Reporter::CLI::LineFormatters::ResultLine.new(min_score: min_score),
+      Evilution::Reporter::CLI::LineFormatters::FeedbackFooter.new
+    ]
+  end
+
+  DEFAULT_LINES = default_lines.freeze
 
-  def initialize(lines: DEFAULT_LINES)
-    @lines = lines
+  def initialize(lines: nil, min_score: nil)
+    @lines = lines || self.class.default_lines(min_score: min_score)
   end
 
   def call(summary)

data/lib/evilution/reporter/cli.rb

@@ -6,11 +6,12 @@ class Evilution::Reporter::CLI
   SEPARATOR = "=" * 44
 
   def initialize(
+    min_score: nil,
     header: LineFormatters::Header.new,
     metrics_block: MetricsBlock.new,
     section_renderer: SectionRenderer.new,
     sections: DEFAULT_SECTIONS,
-    trailer: Trailer.new
+    trailer: Trailer.new(min_score: min_score)
   )
     @header = header
     @metrics_block = metrics_block
@@ -46,6 +47,9 @@ require_relative "cli/line_formatters/result_line"
 require_relative "cli/line_formatters/feedback_footer"
 require_relative "cli/item_formatters/coverage_gap"
 require_relative "cli/item_formatters/result_location"
+require_relative "cli/item_formatters/neutral_group"
+require_relative "cli/item_formatters/subject_score"
+require_relative "cli/item_formatters/subject_score_group"
 require_relative "cli/item_formatters/error"
 require_relative "cli/item_formatters/disabled"
 require_relative "cli/metrics_block"
@@ -60,9 +64,21 @@ Evilution::Reporter::CLI.const_set(
       formatter: Evilution::Reporter::CLI::ItemFormatters::CoverageGap.new
     ),
     Evilution::Reporter::CLI::Section.new(
-      title: "Neutral mutations (test already failing):",
-      fetcher: lambda(&:neutral_results),
-      formatter: Evilution::Reporter::CLI::ItemFormatters::ResultLocation.new
+      title: lambda { |groups|
+        subjects = groups.sum(&:length)
+        "Subjects needing attention (#{subjects} subject#{"s" unless subjects == 1} " \
+          "in #{groups.length} file#{"s" unless groups.length == 1}):"
+      },
+      fetcher: lambda(&:subjects_needing_attention_by_file),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::SubjectScoreGroup.new
+    ),
+    Evilution::Reporter::CLI::Section.new(
+      title: lambda { |groups|
+        count = groups.sum { |(_reason, results)| results.length }
+        "Neutral mutations (#{count}, not verified):"
+      },
+      fetcher: lambda(&:neutral_results_by_reason),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::NeutralGroup.new
     ),
     Evilution::Reporter::CLI::Section.new(
       title: "Equivalent mutations (provably identical behavior):",

data/lib/evilution/reporter/json/subjects.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../json"
+
+# The per-subject rows of a JSON report.
+#
+# Every subject is listed, whether or not it needs attention: a consumer that
+# wants only the gaps filters on `reached` and `score`, while one asserting that
+# a method is covered at all needs to see the rest (EV-nlx1 / GH #1605).
+class Evilution::Reporter::JSON::Subjects
+  def call(summary)
+    summary.subject_scores.map { |score| row(score) }
+  end
+
+  private
+
+  def row(score)
+    {
+      name: score.name,
+      file: score.file_path,
+      total: score.total,
+      killed: score.killed,
+      verified: score.verified,
+      survived: score.survived,
+      score: score.score.round(4),
+      reached: score.reached?
+    }
+  end
+end

data/lib/evilution/reporter/json.rb

@@ -8,8 +8,9 @@ require_relative "../reporter"
 require_relative "../session/schema"
 
 class Evilution::Reporter::JSON
-  def initialize(suggest_tests: false, integration: :rspec)
+  def initialize(suggest_tests: false, integration: :rspec, subjects: Subjects.new)
     @suggestion = Evilution::Reporter::Suggestion.new(suggest_tests: suggest_tests, integration: integration)
+    @subjects = subjects
   end
 
   def call(summary)
@@ -25,6 +26,7 @@ class Evilution::Reporter::JSON
       timestamp: Time.now.iso8601,
       summary: build_summary(summary),
       coverage_gaps: build_coverage_gaps(summary),
+      subjects: @subjects.call(summary),
       **result_categories(summary)
     }
     append_disabled_to_report(report, summary)
@@ -94,12 +96,20 @@ class Evilution::Reporter::JSON
   end
 
   def append_optional_summary_fields(data, summary)
+    append_diagnostic_summary_fields(data, summary)
     data[:truncated] = true if summary.truncated?
     data[:skipped] = summary.skipped if summary.skipped.positive?
     peak = summary.peak_memory_mb
     data[:peak_memory_mb] = peak.round(1) if peak
   end
 
+  # What the run had to say about itself rather than about the mutations: a
+  # target that was never tested, work that had to be redone serially.
+  def append_diagnostic_summary_fields(data, summary)
+    data[:unresolved_target_files] = summary.unresolved_target_files if summary.unresolved_targets?
+    data[:infra_retried] = summary.infra_retried if summary.infra_retried.positive?
+  end
+
   def build_mutation_detail(result)
     mutation = result.mutation
     detail = base_mutation_fields(mutation, result)
@@ -107,9 +117,19 @@ class Evilution::Reporter::JSON
     detail[:test_command] = result.test_command if result.test_command
     append_memory_fields(detail, result)
     append_error_fields(detail, result)
+    append_neutral_reason(detail, result)
     detail
   end
 
+  # Why a neutral was recorded — a red baseline and an infrastructure crash want
+  # opposite responses, and both land in the same bucket (EV-5pob / GH #1606).
+  def append_neutral_reason(detail, result)
+    reason = result.neutral_reason
+    return unless reason
+
+    detail[:neutral_reason] = { kind: reason.kind.to_s, detail: reason.detail }
+  end
+
   def base_mutation_fields(mutation, result)
     {
       operator: mutation.operator_name,
@@ -161,3 +181,5 @@ class Evilution::Reporter::JSON
     }
   end
 end
+
+require_relative "json/subjects"

data/lib/evilution/result/mutation_result.rb

@@ -7,10 +7,10 @@ require_relative "memory_stats"
 class Evilution::Result::MutationResult
   STATUSES = %i[killed survived timeout error neutral equivalent unresolved unparseable].freeze
 
-  attr_reader :mutation, :status, :duration, :killing_test, :test_command, :memory, :error
+  attr_reader :mutation, :status, :duration, :killing_test, :test_command, :memory, :error, :neutral_reason
 
   def initialize(mutation:, status:, duration: 0.0, killing_test: nil,
-                 test_command: nil, memory: nil, error: nil)
+                 test_command: nil, memory: nil, error: nil, neutral_reason: nil)
     raise ArgumentError, "invalid status: #{status}" unless STATUSES.include?(status)
 
     @mutation = mutation
@@ -20,6 +20,7 @@ class Evilution::Result::MutationResult
     @test_command = test_command
     @memory = memory
     @error = error
+    @neutral_reason = neutral_reason
     freeze
   end
 

data/lib/evilution/result/neutral_reason.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+
+# Why a mutation was recorded neutral.
+#
+# Neutral covers two unrelated situations, and they call for opposite responses:
+# a spec file that was already red before any mutation ran, and a test process
+# that died on infrastructure rather than on the mutation. Without the reason
+# they are indistinguishable in a report, and a run can print full marks while
+# the neutral bucket quietly holds what would otherwise be survivors
+# (EV-5pob / GH #1606).
+Evilution::Result::NeutralReason = Data.define(:kind, :detail) do
+  def self.baseline_failure(spec_file)
+    new(kind: :baseline_failure, detail: spec_file)
+  end
+
+  def self.infra_error(error_class)
+    new(kind: :infra_error, detail: error_class)
+  end
+
+  def to_s
+    detail ? "#{label} (#{detail})" : label
+  end
+
+  private
+
+  def label
+    case kind
+    when :baseline_failure then "baseline already failing"
+    when :infra_error then "infrastructure error"
+    else kind.to_s
+    end
+  end
+end

data/lib/evilution/result/subject_score.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+
+# What one subject — a single method — scored, alongside the counts behind it.
+#
+# The run's own score is computed per file, so a well-tested file that gains new
+# untested methods still reports 100%: whatever the resolved spec reaches is all
+# the number ever describes (EV-nlx1 / GH #1605). Per subject the picture
+# separates: a method whose mutations were never reached scores nothing and says
+# so, instead of disappearing into the file's total.
+Evilution::Result::SubjectScore = Data.define(:name, :file_path, :total, :killed, :verified, :survived) do
+  # Killed over what actually got a verdict, the same denominator the run uses.
+  def score
+    return 0.0 if verified.zero?
+
+    killed.to_f / verified
+  end
+
+  # Whether any mutation of this subject got a verdict at all.
+  def reached?
+    verified.positive?
+  end
+
+  def fully_verified?
+    reached? && killed == verified
+  end
+end

data/lib/evilution/result/subject_scorer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "subject_score"
+
+# Groups mutation results by the subject they belong to and scores each one.
+#
+# Same denominator as the run's own score: statuses that carry no verdict
+# (unresolved, neutral, equivalent, errored, unparseable) are left out of it, so
+# a subject those account for entirely reports as unreached rather than as a
+# perfect score over nothing.
+class Evilution::Result::SubjectScorer
+  VERDICT_STATUSES = %i[killed survived timeout].freeze
+  private_constant :VERDICT_STATUSES
+
+  def call(results)
+    grouped = results.group_by { |result| [result.mutation.file_path, result.mutation.subject.name] }
+
+    grouped
+      .map { |(file_path, name), subject_results| score_for(name, file_path, subject_results) }
+      .sort_by { |score| [score.file_path, score.name] }
+  end
+
+  private
+
+  def score_for(name, file_path, results)
+    verdicts = results.count { |result| VERDICT_STATUSES.include?(result.status) }
+
+    Evilution::Result::SubjectScore.new(
+      name: name,
+      file_path: file_path,
+      total: results.length,
+      killed: results.count(&:killed?),
+      verified: verdicts,
+      survived: results.count(&:survived?)
+    )
+  end
+end

data/lib/evilution/result/summary.rb

@@ -2,19 +2,57 @@
 
 require_relative "../result"
 require_relative "coverage_gap_grouper"
+require_relative "subject_scorer"
 
 class Evilution::Result::Summary
-  attr_reader :results, :duration, :skipped, :disabled_mutations
+  attr_reader :results, :duration, :skipped, :disabled_mutations, :unresolved_target_files,
+              :target_file_count, :infra_retried
 
-  def initialize(results:, duration: 0.0, truncated: false, skipped: 0, disabled_mutations: [])
+  def initialize(results:, duration: 0.0, truncated: false, skipped: 0, disabled_mutations: [],
+                 unresolved_target_files: [], target_file_count: nil, infra_retried: 0)
     @results = results
     @duration = duration
     @truncated = truncated
     @skipped = skipped
     @disabled_mutations = disabled_mutations
+    @unresolved_target_files = unresolved_target_files.freeze
+    @target_file_count = target_file_count
+    @infra_retried = infra_retried
     freeze
   end
 
+  # Neutral results gathered by the reason they were recorded, which is what the
+  # report needs to say which kind of neutral a reader is looking at
+  # (EV-5pob / GH #1606).
+  def neutral_results_by_reason
+    neutral_results.group_by(&:neutral_reason).to_a
+  end
+
+  # What each subject — each method — scored on its own. The run's score is
+  # computed per file, which says nothing about a method inside it that no
+  # example reaches (EV-nlx1 / GH #1605).
+  def subject_scores
+    Evilution::Result::SubjectScorer.new.call(results)
+  end
+
+  # The subjects the file-level score does not speak for: something survived, or
+  # nothing reached them at all.
+  def subjects_needing_attention
+    subject_scores.reject(&:fully_verified?)
+  end
+
+  # The same subjects, gathered under the file they live in, which is how the
+  # report lists them.
+  def subjects_needing_attention_by_file
+    subjects_needing_attention.group_by(&:file_path).values
+  end
+
+  # Files evilution was pointed at that resolved to no test file, so nothing
+  # about them was ever measured (EV-p4sm / GH #1603).
+  def unresolved_targets?
+    !unresolved_target_files.empty?
+  end
+
   def truncated?
     @truncated
   end
@@ -66,7 +104,11 @@ class Evilution::Result::Summary
     killed.to_f / denominator
   end
 
+  # A target file that was never tested fails the run on its own: the score
+  # only speaks for the files that did resolve to a spec.
   def success?(min_score: 1.0)
+    return false if unresolved_targets?
+
     score >= min_score
   end
 

data/lib/evilution/runner/canary.rb

@@ -34,7 +34,7 @@ class Evilution::Runner::Canary
       test_command: ->(mutation) { build_integration(spec_path).call(mutation) },
       timeout: @config.timeout
     )
-    raise Failed, failure_message(result.status) unless result.status == :survived
+    raise Failed, failure_message(result) unless result.status == :survived
 
     nil
   ensure
@@ -146,12 +146,59 @@ class Evilution::Runner::Canary
     @integration_class.new(test_files: [spec_path], hooks: @hooks)
   end
 
-  def failure_message(status)
+  # When the child reported an error, that error IS the diagnosis -- naming it
+  # beats guessing. The speculative list stays only for the cases that carry no
+  # error at all (:killed, :timeout), where guesses are the only help there is.
+  # Diagnosing GH #1581 meant rebuilding this canary by hand to read the field
+  # this message used to drop, and none of the four guesses was the cause.
+  # EV-65nf / GH #1586.
+  def failure_message(result)
+    "#{failure_preamble(result.status)} #{diagnosis(result)} " \
+      "Re-run with --no-canary to bypass this check."
+  end
+
+  def failure_preamble(status)
     "evilution proof-of-life canary failed: a guaranteed-unobservable synthetic " \
       "mutation was scored #{status.inspect} instead of :survived. The mutation " \
-      "pipeline is misreporting — every score this run would produce is unreliable. " \
-      "Likely causes: Rails/Zeitwerk autoloading breaking child eval; an env-specific " \
+      "pipeline is misreporting — every score this run would produce is unreliable."
+  end
+
+  def diagnosis(result)
+    reported = reported_error(result)
+    return speculative_causes if reported.nil?
+
+    "The child reported: #{reported}"
+  end
+
+  def reported_error(result)
+    message = result.error_message
+    return nil if message.nil? || message.empty?
+
+    described = with_class_prefix(message, result.error_class)
+    frame = first_frame(result)
+    frame.nil? ? described : "#{described} (at #{frame})"
+  end
+
+  # MutationApplier already prefixes the class onto the message it packs
+  # ("#{e.class}: #{e.message}"), while other paths pack the bare message and
+  # leave the class in its own field. Prefixing unconditionally would print
+  # "NameError: NameError: ..." for the former.
+  def with_class_prefix(message, klass)
+    return message if klass.nil? || klass.empty? || message.start_with?("#{klass}:")
+
+    "#{klass}: #{message}"
+  end
+
+  def first_frame(result)
+    backtrace = result.error_backtrace
+    return nil if backtrace.nil? || backtrace.empty?
+
+    backtrace.first
+  end
+
+  def speculative_causes
+    "Likely causes: Rails/Zeitwerk autoloading breaking child eval; an env-specific " \
       "RSpec config (e.g. fail_if_no_examples); a classify_status fallback defect; or " \
-      "an isolation-mode defect. Re-run with --no-canary to bypass this check."
+      "an isolation-mode defect."
   end
 end

data/lib/evilution/runner/mutation_executor/infra_retry.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+require_relative "neutralizer/infra_error"
+
+# Re-runs, one at a time, the mutations a parallel pass could not judge because
+# the test process crashed on infrastructure — a database lock, a statement
+# timeout — rather than on the mutation itself.
+#
+# Those crashes are demoted to `:neutral` so they do not inflate the kill count
+# (EV-toid / GH #814), which leaves the neutral bucket swinging with `--jobs`
+# on identical input: the contention that causes them only exists while several
+# workers run at once. Re-running them after the pool is done removes the
+# contention, so the verdict matches what a serial run would have produced
+# (EV-j0bv / GH #1607).
+#
+# Only mutations neutralised by an infra crash are re-run. A neutral from a
+# failing baseline is a real statement about the spec, and re-running it would
+# say the same thing again.
+class Evilution::Runner::MutationExecutor::InfraRetry
+  attr_reader :retried_count
+
+  def initialize(runner:, pipeline:)
+    @runner = runner
+    @pipeline = pipeline
+    @retried_count = 0
+  end
+
+  def call(results, baseline_result:, integration:)
+    @retried_count = 0
+
+    results.map do |result|
+      next result unless retryable?(result)
+
+      @retried_count += 1
+      rerun(result, baseline_result: baseline_result, integration: integration)
+    end
+  end
+
+  private
+
+  def retryable?(result)
+    Evilution::Runner::MutationExecutor::Neutralizer::InfraError.infra_neutral?(result)
+  end
+
+  # The parallel pass keeps the sources of a retryable mutation alive so it can
+  # be applied again; they are released here, once it has been.
+  def rerun(result, baseline_result:, integration:)
+    mutation = result.mutation
+    rerun_result = @runner.call(mutation, integration: integration)
+    mutation.strip_sources!
+    @pipeline.call(rerun_result, baseline_result: baseline_result)
+  end
+end