evilution 1.1.0 → 1.3.0

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/coverage_gap_grouper.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../result"
 require_relative "coverage_gap"
 
 class Evilution::Result::CoverageGapGrouper

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,38 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+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/baseline_runner.rb

@@ -60,18 +60,15 @@ class Evilution::Runner::BaselineRunner
     return nil unless config.baseline? && subjects.any?
 
     log_start
-    baseline = Evilution::Baseline.new(
-      timeout: config.timeout,
-      test_files: config.spec_files.empty? ? nil : config.spec_files,
-      **integration_class.baseline_options
-    )
-    result = baseline.call(subjects)
+    result = build_baseline.call(subjects)
     log_complete(result)
     result
   end
 
+  # The same selector the baseline resolves with, so a surviving mutation is
+  # matched against exactly the spec files the baseline ran.
   def neutralization_resolver
-    integration_class.baseline_options[:spec_resolver] || Evilution::SpecResolver.new
+    config.spec_selector
   end
 
   def neutralization_fallback_dir
@@ -82,6 +79,19 @@ class Evilution::Runner::BaselineRunner
 
   attr_reader :config, :hooks
 
+  # Resolves through config.spec_selector -- the object `run` uses, so
+  # spec_mappings / spec_pattern apply -- and skips unresolved sources unless
+  # the run falls back to the full suite.
+  def build_baseline
+    Evilution::Baseline.new(
+      timeout: config.timeout,
+      test_files: config.spec_files.empty? ? nil : config.spec_files,
+      spec_selector: config.spec_selector,
+      fallback_to_full_suite: config.fallback_to_full_suite?,
+      **integration_class.baseline_options
+    )
+  end
+
   def build_example_filter
     return nil unless config.example_targeting?
 

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/isolation_resolver.rb

@@ -6,6 +6,7 @@ require_relative "../isolation/in_process"
 require_relative "../rails_detector"
 require_relative "../gem_detector"
 require_relative "../integration/loading/test_load_path"
+require_relative "../rails_warmup"
 
 class Evilution::Runner::IsolationResolver
   PRELOAD_CANDIDATES = [
@@ -48,6 +49,7 @@ class Evilution::Runner::IsolationResolver
     prepare_load_path_for_preload(path)
     prepare_integration_for_preload
     require File.expand_path(path)
+    warm_up_rails
   rescue Evilution::ConfigError
     raise
   rescue ScriptError, StandardError => e
@@ -61,6 +63,21 @@ class Evilution::Runner::IsolationResolver
 
   attr_reader :config, :hooks
 
+  # Runs only after a preload (which is what loads Rails). This is primarily an
+  # optimisation for :fork isolation, where children inherit the warmed state.
+  def warm_up_rails
+    return unless config.warmup == :rails
+
+    application = ::Rails.application if defined?(::Rails) && ::Rails.respond_to?(:application)
+    unless application
+      warn_message = "[evilution] warmup: rails requested but Rails is not loaded (or has no application) after preload; skipping"
+      Evilution::Diagnostic.warn(warn_message)
+      return
+    end
+
+    Evilution::RailsWarmup.new(application).call
+  end
+
   # Under :fork, allow preloading — caller resolves whether a path exists (an
   # explicit --preload / preload: value, or an auto-detected rails_helper) and
   # bails early when none does. Under :in_process, only allow preloading when
@@ -131,7 +148,11 @@ class Evilution::Runner::IsolationResolver
   #   have both (a bare `require "support/foo"` must still resolve from spec/).
   # - minitest/test-unit: a test/test_helper.rb doing a non-relative
   #   `require "support/..."` needs test/ on $LOAD_PATH. Route through
-  #   TestLoadPath -- the same policy the per-mutation test load uses  -- so preload and mutation paths agree.
+  #   TestLoadPath, the policy the per-mutation test load uses, with one
+  #   deliberate difference: outside_root_dirs: false. A resolved test file
+  #   outside test/ and spec/ keeps its own directory, but a preload there
+  #   (config/evilution_preload.rb) must not, or config/ lands ahead of the
+  #   gems and config/puma.rb shadows the puma gem (GH #1597).
   def prepare_load_path_for_preload(preload_path)
     if config.integration == :rspec
       prepare_rspec_preload_load_path
@@ -148,7 +169,7 @@ class Evilution::Runner::IsolationResolver
 
   def prepare_test_preload_load_path(preload_path)
     base = detected_rails_root || Evilution.project_base_dir
-    Evilution::Integration::Loading::TestLoadPath.add!([preload_path], base: base)
+    Evilution::Integration::Loading::TestLoadPath.add!([preload_path], base: base, outside_root_dirs: false)
   end
 
   def resolve_spec_dir

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

data/lib/evilution/runner/mutation_executor/neutralizer/baseline_failed.rb

@@ -2,6 +2,7 @@
 
 require_relative "../neutralizer"
 require_relative "../../../result/mutation_result"
+require_relative "../../../result/neutral_reason"
 
 class Evilution::Runner::MutationExecutor::Neutralizer::BaselineFailed
   def initialize(config:, spec_resolver:, fallback_dir:)
@@ -13,27 +14,39 @@ class Evilution::Runner::MutationExecutor::Neutralizer::BaselineFailed
   def call(result, baseline_result:)
     return result unless result.survived? && baseline_result && baseline_result.failed?
 
-    if @config.spec_files.any?
-      should_neutralize = true
-    else
-      spec_file = @spec_resolver.call(result.mutation.file_path) || @fallback_dir
-      should_neutralize = baseline_result.failed_spec_files.include?(spec_file)
-    end
-    return result unless should_neutralize
+    return neutralize(result, nil) if @config.spec_files.any?
 
-    neutralize(result)
+    failed = baseline_result.failed_spec_files
+    spec_file = covering_specs(result.mutation.file_path).find { |spec| failed.include?(spec) }
+    return result unless spec_file
+
+    neutralize(result, spec_file)
   end
 
   private
 
-  def neutralize(result)
+  # The spec files the baseline ran for this source: every file the resolver
+  # returns (a spec_selector may map one source to several), or the fallback
+  # directory when nothing resolves -- but only if the run falls back to the
+  # full suite; otherwise the baseline never ran it.
+  def covering_specs(file_path)
+    specs = Array(@spec_resolver.call(file_path))
+    return specs unless specs.empty?
+
+    @config.fallback_to_full_suite? ? [@fallback_dir] : []
+  end
+
+  # The spec that was already red is the fact a reader needs: it says what to
+  # fix before the run can say anything about these mutations.
+  def neutralize(result, spec_file)
     Evilution::Result::MutationResult.new(
       mutation: result.mutation,
       status: :neutral,
       duration: result.duration,
       test_command: result.test_command,
       memory: result.memory,
-      error: result.error
+      error: result.error,
+      neutral_reason: Evilution::Result::NeutralReason.baseline_failure(spec_file)
     )
   end
 end

data/lib/evilution/runner/mutation_executor/neutralizer/infra_error.rb

@@ -2,6 +2,7 @@
 
 require_relative "../neutralizer"
 require_relative "../../../result/mutation_result"
+require_relative "../../../result/neutral_reason"
 
 # Reclassify results as :neutral when the failure was caused by test
 # infrastructure rather than by the mutation. Two independent paths:
@@ -33,6 +34,21 @@ class Evilution::Runner::MutationExecutor::Neutralizer::InfraError
   ].freeze
   private_constant :INFRA_ERROR_CLASSES, :INFRA_BACKTRACE_PATHS, :INFRA_CRASH_CLASSES
 
+  # Whether a crash class is one of the infrastructure failures that say
+  # nothing about the mutation. The parallel strategy asks this before the
+  # neutralisation pipeline has run, while the result is still a `:killed`
+  # crash (EV-j0bv / GH #1607).
+  def self.infra_crash_class?(error_class)
+    INFRA_CRASH_CLASSES.include?(error_class)
+  end
+
+  # Whether this result is a kill that was demoted because the test process
+  # crashed on infrastructure rather than on the mutation. Such a mutation got
+  # no verdict, so a parallel run can re-run it once the contention is over.
+  def self.infra_neutral?(result)
+    result.neutral? && infra_crash_class?(result.error_class)
+  end
+
   def call(result, **_ctx)
     return neutralize(result) if infra_crash?(result)
     return result unless result.error?
@@ -62,7 +78,8 @@ class Evilution::Runner::MutationExecutor::Neutralizer::InfraError
       duration: result.duration,
       test_command: result.test_command,
       memory: result.memory,
-      error: result.error
+      error: result.error,
+      neutral_reason: Evilution::Result::NeutralReason.infra_error(result.error_class)
     )
   end
 end

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

@@ -2,6 +2,7 @@
 
 require_relative "../mutation_executor"
 require_relative "../../result/mutation_result"
+require_relative "neutralizer/infra_error"
 
 class Evilution::Runner::MutationExecutor::ResultCache
   CACHEABLE_STATUSES = %i[killed timeout].freeze
@@ -32,6 +33,7 @@ class Evilution::Runner::MutationExecutor::ResultCache
   def store(mutation, result)
     return unless @backend
     return unless result.killed? || result.timeout?
+    return if infra_crash?(result)
 
     @backend.store(mutation,
                    status: result.status,
@@ -40,6 +42,15 @@ class Evilution::Runner::MutationExecutor::ResultCache
                    test_command: result.test_command)
   end
 
+  # A kill that came from an infrastructure crash is not a verdict about the
+  # mutation, and the cache keeps no error class to tell them apart later. It
+  # is left out so the next fetch does not hand back a plain `:killed`, which
+  # would defeat both the demotion to neutral and the serial retry
+  # (EV-j0bv / GH #1607).
+  def infra_crash?(result)
+    Evilution::Runner::MutationExecutor::Neutralizer::InfraError.infra_crash_class?(result.error_class)
+  end
+
   def partition(batch, packer:)
     uncached_indices = []
     cached_results = {}

data/lib/evilution/runner/mutation_executor/strategy/parallel.rb

@@ -65,10 +65,28 @@ class Evilution::Runner::MutationExecutor::Strategy::Parallel
     compact_results = merge(batch, partition.uncached_indices, partition.cached_results, worker_results)
     batch_results = rebuild_results(batch, compact_results)
     cache_results(batch_results, partition.uncached_indices)
-    batch.each(&:strip_sources!)
+    release_sources(batch, batch_results)
     batch_results
   end
 
+  # Sources are dropped as soon as a mutation has been judged, to keep a long
+  # run's memory flat. A mutation the workers could not judge because of
+  # infrastructure contention is re-run serially once the pool is done
+  # (InfraRetry), which needs its sources, so it keeps them until then. The
+  # neutralisation pipeline has not run yet here, so the crash is still a kill.
+  def release_sources(batch, batch_results)
+    batch.each_with_index do |mutation, index|
+      result = batch_results[index]
+      next if result && infra_crash?(result)
+
+      mutation.strip_sources!
+    end
+  end
+
+  def infra_crash?(result)
+    Evilution::Runner::MutationExecutor::Neutralizer::InfraError.infra_crash_class?(result.error_class)
+  end
+
   def rebuild_results(batch, compact_results)
     batch.zip(compact_results).map { |m, h| @packer.rebuild(m, h) }
   end