henitai 0.5.1 → 0.6.0

data/lib/henitai/rspec_outcomes.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "henitai/test_file_outcomes"
+
+module Henitai
+  # Records the outcome of each finished RSpec example per spec file.
+  #
+  # Failures outside an example produce no failed example. A hook error in
+  # `before(:context)` fails the group's examples, so it is attributed
+  # already; an `after(:context)` error is announced as a message while its
+  # group is open and is attributed to that group's file. Everything else
+  # counted by `errors_outside_of_examples_count` (a spec file that fails to
+  # load, `before(:suite)`) has no file and is recorded as unattributed.
+  module RspecOutcomes
+    EVENTS = %i[example_finished example_group_started example_group_finished message dump_summary].freeze
+    HOOK_ERROR = "An error occurred in "
+
+    # RSpec drops finished examples from its groups after a run, so
+    # outcomes are collected as the reporter announces them.
+    class Listener
+      def initialize(outcomes)
+        @outcomes = outcomes
+        @open_group_files = []
+        @attributed_errors = 0
+      end
+
+      def example_finished(notification)
+        RspecOutcomes.record(@outcomes, notification.example)
+      end
+
+      def example_group_started(notification)
+        @open_group_files.push(RspecOutcomes.group_file(notification.group))
+      end
+
+      def example_group_finished(_notification)
+        @open_group_files.pop
+      end
+
+      def message(notification)
+        file = @open_group_files.last
+        return unless file && notification.message.strip.start_with?(HOOK_ERROR)
+
+        @outcomes.record(file, failed: true)
+        @attributed_errors += 1
+      end
+
+      def dump_summary(summary)
+        return unless summary.errors_outside_of_examples_count > @attributed_errors
+
+        @outcomes.record_unattributed_failure
+      end
+    end
+
+    module_function
+
+    def register(outcomes, reporter)
+      reporter.register_listener(Listener.new(outcomes), *EVENTS)
+    end
+
+    def group_file(group)
+      metadata = group.metadata
+      metadata[:absolute_file_path] || metadata[:file_path]
+    end
+
+    def record(outcomes, example)
+      status = example.execution_result.status
+      return if status.nil?
+
+      outcomes.record(example.metadata[:file_path], failed: status == :failed)
+    end
+  end
+end

data/lib/henitai/runner.rb

@@ -11,16 +11,20 @@ module Henitai
   #
   #   Gate 2 — Mutant generation
   #     Apply operators to each Subject's AST. Filter arid (non-productive)
-  #     nodes via ignore_patterns. Produces the initial mutant list.
+  #     nodes from the built-in catalog. Produces the initial mutant list.
   #
   #   Gate 3 — Static filtering
-  #     Remove ignored mutants (pattern matches), compile-time errors.
+  #     Mark mutants whose original start line matches an ignore_patterns
+  #     entry as :ignored, and remove compile-time errors.
   #     Apply per-test coverage data: mark :no_coverage for uncovered mutants.
   #
   #   Gate 4 — Mutant execution
   #     Run surviving mutants in isolated child processes (fork isolation).
-  #     Each child process loads the test suite with the mutated method
-  #     injected via Module#define_method. Collect kill/survive/timeout results.
+  #     Each child process loads the test suite, then re-evaluates the
+  #     subject's own `def` with the mutation spliced in, inside its original
+  #     module/class openers (ADR-13). Module#define_method is only the fallback
+  #     for subjects that cannot be reopened by name. Collect kill/survive/
+  #     timeout results.
   #
   #   Gate 5 — Reporting
   #     Write results to configured reporters (terminal, html, json, dashboard).
@@ -29,7 +33,8 @@ module Henitai
     attr_reader :config, :result
 
     # @param mode [Hash] execution-mode flags: +dry_run:+ stops before Gate 4,
-    #   +incremental:+ reuses still-valid Killed verdicts from history.
+    #   +incremental:+ reuses still-valid Killed verdicts from history,
+    #   +force:+ disables the verdict reuse that survivor reruns apply.
     # +deps+ is assigned in the body, not defaulted in the signature: the
     # default needs @config, and `config:` itself defaults to a load.
     #
@@ -45,6 +50,7 @@ module Henitai
       @survivors_from = survivors_from
       @dry_run        = mode.fetch(:dry_run, false)
       @incremental    = mode.fetch(:incremental, false)
+      @force          = mode.fetch(:force, false)
     end
 
     # Entry point — runs the full pipeline and returns a Result.
@@ -76,6 +82,9 @@ module Henitai
     # static/skip/arid/stillborn filtering — everything short of execution.
     def pipeline_mutants
       if survivor_rerun? && (fast_mutants = survivor_strategy.try_recipe_run)
+        # Gate 0 still runs: test selection reads the per-test map, which must
+        # include new or edited tests.
+        bootstrap_coverage(fast_mutants.filter_map { |mutant| mutant.subject.source_file }.uniq)
         return fast_mutants
       end
 
@@ -104,8 +113,9 @@ module Henitai
       )
     end
 
+    # A survivor rerun must see every prior survivor, so it never samples.
     def generate_mutants(subjects)
-      mutant_generator.generate(subjects, operators, config:)
+      mutant_generator.generate(subjects, operators, config:, sample: !survivor_rerun?)
     end
 
     def filter_mutants(mutants)
@@ -116,25 +126,26 @@ module Henitai
       bootstrap_thread = bootstrap_mutants(source_files)
       mutants = generate_mutants(subjects)
       bootstrap_thread.value
-      filtered = apply_incremental_filter(filter_mutants(mutants))
-      return filtered unless survivor_rerun?
+      filtered = filter_mutants(mutants)
+      return apply_incremental_filter(filtered) unless survivor_rerun?
 
-      survivor_strategy.apply_selection(filtered)
+      survivor_strategy.apply_selection(filtered, reuse_filter: @force ? nil : reuse_filter)
     end
 
-    # Opt-in verdict reuse (`--incremental`): still-valid Killed and Survived
-    # verdicts from the history store are marked with their stored status +
-    # from_cache before execution. The filter is only ever constructed when
-    # the flag is set; it runs after the coverage bootstrap join in
-    # mutants_for, so the live per-test map it reads is never mid-write.
+    # Verdict reuse (opt-in `--incremental`; always for `--survivors-from`
+    # reruns, where it runs on the selected survivors): still-valid Killed and
+    # Survived verdicts from the history store are marked with their stored
+    # status + from_cache before execution. It runs after the coverage
+    # bootstrap join in mutants_for, so the live per-test map it reads is never
+    # mid-write.
     def apply_incremental_filter(mutants)
       return mutants unless @incremental
 
-      IncrementalFilter.new(history_store:, per_test_coverage:,
-                            dependency_fingerprint: VerdictFingerprint.dependency_fingerprint)
-                       .apply(mutants)
+      reuse_filter.apply(mutants)
     end
 
+    def reuse_filter = deps.reuse_filter
+
     def bootstrap_mutants(source_files) = Thread.new { bootstrap_coverage(source_files) }
 
     def execute_mutants(mutants)
@@ -150,12 +161,16 @@ module Henitai
       Reporter.run_all(names: config.reporters, result:, config:, history_store:)
     end
 
+    # History is an auxiliary trend artifact: a corrupt or locked database
+    # must not discard the run's verdicts, so the reports are still written.
     def persist_history(result, recorded_at)
       history_store.record(
         result,
         version: Henitai::VERSION,
         recorded_at:
       )
+    rescue StandardError => e
+      warn "henitai: could not record mutation history (#{e.class}: #{e.message}); reports are still written"
     end
 
     def build_result(mutants, started_at, finished_at)
@@ -177,10 +192,33 @@ module Henitai
         git_sha: safe_head_sha,
         source_provider: source_provider,
         authoritative: full_run?,
-        since: @since
+        since: @since,
+        complete_files: complete_files,
+        sampling: result_sampling
       )
     end
 
+    # Files whose every subject this run mutated: no subject patterns and no
+    # survivor rerun (a --since run still selects whole changed files).
+    def complete_files
+      return [] if Array(@subjects).any? || survivor_rerun?
+
+      source_files
+    end
+
+    # Records the sampling that actually shaped the mutant set, with the
+    # default seed filled in so the report is reproducible on its own.
+    def result_sampling
+      sampling = optional_config(:sampling)
+      return nil if survivor_rerun? || !(sampling && sampling[:ratio])
+
+      {
+        strategy: (sampling[:strategy] || "stratified").to_s,
+        ratio: sampling[:ratio],
+        seed: sampling[:seed] || SamplingStrategy::DEFAULT_SEED
+      }
+    end
+
     def safe_head_sha
       git_diff_analyzer.head_sha
     rescue StandardError
@@ -205,6 +243,7 @@ module Henitai
     def operators = deps.operators
     def history_store = deps.history_store
     def per_test_coverage = deps.per_test_coverage
+    def source_selection_coverage = deps.source_selection_coverage
     def source_provider = deps.source_provider
 
     def progress_reporter = deps.progress_reporter(full_run: full_run?)
@@ -216,7 +255,7 @@ module Henitai
     def source_file_selection
       @source_file_selection ||= SourceFileSelection.new(
         config: config, since: @since,
-        git_diff_analyzer: git_diff_analyzer, per_test_coverage: per_test_coverage
+        git_diff_analyzer: git_diff_analyzer, per_test_coverage: source_selection_coverage
       )
     end
 

data/lib/henitai/runner_dependencies.rb

@@ -12,6 +12,10 @@ module Henitai
   # {#per_test_coverage} and {#history_store}: the incremental filter proves
   # survivor reuse against the same live coverage map the history store records
   # its intersection set from. Two instances would be two snapshots.
+  #
+  # {#source_selection_coverage} is deliberately a *different* instance: Gate 1
+  # reads the map as it was before this run's coverage bootstrap rewrote it, and
+  # a shared instance would memoize that stale snapshot for the reuse decisions.
   class RunnerDependencies
     def initialize(config:)
       @config = config
@@ -36,10 +40,27 @@ module Henitai
       @per_test_coverage ||= PerTestCoverage.new(reports_dir: @config.reports_dir)
     end
 
+    def source_selection_coverage
+      @source_selection_coverage ||= PerTestCoverage.new(reports_dir: @config.reports_dir)
+    end
+
     def history_store
       @history_store ||= MutantHistoryStore.new(
         path: File.join(@config.reports_dir, Henitai::HISTORY_STORE_FILENAME),
-        per_test_coverage: per_test_coverage
+        per_test_coverage: per_test_coverage,
+        reuse_context: reuse_context
+      )
+    end
+
+    # Shared by the incremental filter and the history store: verdicts are
+    # recorded under exactly the context they are later checked against.
+    def reuse_context
+      @reuse_context ||= ReuseContext.new(config: @config)
+    end
+
+    def reuse_filter
+      IncrementalFilter.new(
+        history_store: history_store, per_test_coverage: per_test_coverage, reuse_context: reuse_context
       )
     end
 

data/lib/henitai/sampling_strategy.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
+require "digest"
 module Henitai
-  # Samples mutants in a strategy-aware, deterministic way.
+  # Samples mutants deterministically, stratified by operator within each subject.
+  #
+  # Per subject, the sample size is ceil(size * ratio), at least one and at most
+  # size. Mutants are grouped into strata by operator. Each stratum is ordered by
+  # a seeded SHA256 key derived from the mutant's stable id, so a mutant's rank
+  # does not depend on other mutants. Strata are then visited round-robin, which
+  # spreads the sample across operators and positions. Kept mutants are returned
+  # in their input order.
   class SamplingStrategy
-    def sample(mutants, ratio:, strategy: :stratified)
+    DEFAULT_SEED = 0
+
+    def sample(mutants, ratio:, strategy: :stratified, seed: DEFAULT_SEED)
       strategy = strategy.to_sym if strategy.respond_to?(:to_sym)
 
       case strategy
       when :stratified
-        stratified_sample(Array(mutants), ratio:)
+        stratified_sample(Array(mutants), ratio:, seed:)
       else
         raise ArgumentError, "Unsupported sampling strategy: #{strategy}"
       end
@@ -16,12 +26,32 @@ module Henitai
 
     private
 
-    def stratified_sample(mutants, ratio:)
+    def stratified_sample(mutants, ratio:, seed:)
       return [] if ratio.to_f <= 0.0
 
-      mutants.group_by { |mutant| mutant.subject.expression }.flat_map do |_subject, group|
-        group.take(sample_count(group.size, ratio))
+      kept = Set.new.compare_by_identity
+      mutants.group_by { |mutant| mutant.subject.expression }.each_value do |group|
+        select_within_subject(group, ratio:, seed:).each { |mutant| kept << mutant }
       end
+      mutants.select { |mutant| kept.include?(mutant) }
+    end
+
+    def select_within_subject(group, ratio:, seed:)
+      strata = group.group_by { |mutant| mutant.operator.to_s }.sort.map do |_operator, members|
+        members.sort_by { |mutant| sort_key(mutant, seed) }
+      end
+
+      round_robin(strata, sample_count(group.size, ratio))
+    end
+
+    def round_robin(strata, count)
+      depth = strata.map(&:size).max || 0
+
+      (0...depth).flat_map { |index| strata.filter_map { |stratum| stratum[index] } }.first(count)
+    end
+
+    def sort_key(mutant, seed)
+      Digest::SHA256.hexdigest("#{seed}\0#{mutant.stable_id}")
     end
 
     def sample_count(size, ratio)

data/lib/henitai/scenario_execution_result.rb

@@ -3,7 +3,7 @@
 module Henitai
   # Captures the result of one baseline or mutant test run.
   class ScenarioExecutionResult
-    attr_reader :status, :stdout, :stderr, :exit_status, :log_path
+    attr_reader :status, :status_reason, :stdout, :stderr, :exit_status, :log_path, :killing_tests
 
     def self.build(wait_result:, stdout:, stderr:, log_path:)
       new(
@@ -15,12 +15,32 @@ module Henitai
       )
     end
 
-    def initialize(status:, stdout:, stderr:, log_path:, exit_status: nil)
+    # Copies the reason behind a harness status onto the mutant the result was
+    # produced for. Tolerates results and mutants that carry no reason.
+    def self.copy_reason(result, mutant)
+      return unless result.respond_to?(:status_reason) && mutant.respond_to?(:status_reason=)
+
+      mutant.status_reason = result.status_reason
+    end
+
+    # Classifies a mutant run from the child's report (see MutantVerdict).
+    def self.build_for_mutant(wait_result:, report:, stdout:, stderr:, log_path:)
+      verdict = MutantVerdict.new(wait_result:, report:, stdout:, stderr:)
+      status, status_reason = verdict.to_a
+      new(status:, status_reason:, stdout:, stderr:, log_path:, exit_status: exit_status_for(wait_result),
+          killing_tests: verdict.killing_tests)
+    end
+
+    # rubocop:disable Metrics/ParameterLists -- one keyword per captured field
+    def initialize(status:, stdout:, stderr:, log_path:, exit_status: nil, status_reason: nil, killing_tests: [])
+      # rubocop:enable Metrics/ParameterLists
       @status = status
+      @status_reason = status_reason
       @stdout = stdout.to_s
       @stderr = stderr.to_s
       @log_path = log_path
       @exit_status = exit_status
+      @killing_tests = killing_tests
     end
 
     # Frees the captured child output once it has been consumed (e.g. by the
@@ -107,14 +127,17 @@ module Henitai
       end
 
       def no_examples_found?(stdout, stderr)
-        stdout.to_s.include?("No examples found.") || stderr.to_s.include?("No examples found.")
+        output = [stdout.to_s, stderr.to_s].join("\n")
+        return false unless ExampleSummary::NO_EXAMPLES_FOUND.match?(output)
+
+        last_summary = output.scan(ExampleSummary::SUMMARY).last
+        last_summary.nil? || last_summary == ["0"]
       end
 
       def zero_examples_failure?(wait_result, stdout, stderr)
         return false unless exit_status_for(wait_result) == 1
 
-        output = [stdout.to_s, stderr.to_s].join("\n")
-        output.include?("0 examples, 0 failures")
+        ExampleSummary.none_ran?([stdout.to_s, stderr.to_s].join("\n"))
       end
     end
 

data/lib/henitai/signature_line.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Whether a mutant sits on its subject's def (signature) line. Line coverage
+  # credits that line only to the test that loaded the file, so the tests that
+  # exercise it are not knowable from the per-test map alone.
+  module SignatureLine
+    module_function
+
+    # A subject without a source range (a recipe stub) has an unknown def
+    # line, so it is treated as one: that only widens test selection and
+    # blocks verdict reuse.
+    def on?(mutant)
+      subject = mutant.respond_to?(:subject) ? mutant.subject : nil
+      return false unless subject.respond_to?(:source_range)
+
+      range = subject.source_range
+      range.nil? || range.begin == mutant.location[:start_line]
+    end
+  end
+end

data/lib/henitai/slot_scheduler/draining.rb

@@ -80,9 +80,17 @@ module Henitai
         end
       end
 
+      # Unrelated events (CHLD of another slot, server traffic) wake the select
+      # early; the SIGTERM grace window must still run its full length.
       def wait_for_drain_window
-        wakeup&.wait(PROCESS_DRAIN_WINDOW)
-        wakeup&.drain
+        return unless wakeup
+
+        deadline = monotonic_time + PROCESS_DRAIN_WINDOW
+        while (remaining = deadline - monotonic_time).positive?
+          woken = wakeup.wait(remaining)
+          wakeup.drain
+          break unless woken
+        end
       end
 
       def signal_draining_slots(draining)
@@ -115,6 +123,7 @@ module Henitai
       def reap_and_finalize_slot(slot)
         _, final_status = wnohang_reap(slot.pid)
         reap_pid(slot.pid) unless final_status
+        tear_down_process_group(slot.pid)
 
         slot_table.release_pid(slot.pid)
         slot_table.delete(slot.slot_id)
@@ -128,6 +137,7 @@ module Henitai
       def record_drain_result(slot, final_status)
         result = drain_verdict.build(slot, final_status)
         slot.mutant.status = result.status
+        ScenarioExecutionResult.copy_reason(result, slot.mutant)
         results << result
         progress_reporter&.progress(slot.mutant, scenario_result: result)
       end

data/lib/henitai/slot_scheduler/process_control.rb

@@ -8,6 +8,9 @@ module Henitai
     # scheduler remains the single caller of the process table. Mixed into
     # {SlotScheduler}; relies on its +runtime+ reader.
     module ProcessControl
+      GROUP_POLL_INTERVAL = 0.02
+      GROUP_POLL_COUNT = 10
+
       private
 
       def monotonic_time
@@ -33,6 +36,36 @@ module Henitai
         end
       end
 
+      # Terminates whatever a finished child left behind in its process group
+      # (daemons, grandchildren). Waits at most PROCESS_DRAIN_WINDOW for them to
+      # exit on SIGTERM before escalating to SIGKILL.
+      def tear_down_process_group(pid)
+        signal_process_group(pid, :SIGTERM)
+        return unless group_members_remain?(pid)
+
+        signal_process_group(pid, :SIGKILL)
+      end
+
+      def group_members_remain?(pid)
+        GROUP_POLL_COUNT.times do
+          return false unless process_group_alive?(pid)
+
+          runtime.pause(GROUP_POLL_INTERVAL)
+        end
+        process_group_alive?(pid)
+      end
+
+      # Signal 0 probes existence only. ESRCH means the group is empty; EPERM
+      # means members exist but belong to someone else.
+      def process_group_alive?(pid)
+        runtime.kill(0, -pid)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      end
+
       def reap_pid(pid)
         runtime.wait(pid)
       rescue Errno::ECHILD, Errno::ESRCH

data/lib/henitai/slot_scheduler/retry_policy.rb

@@ -4,17 +4,19 @@ module Henitai
   class SlotScheduler
     # Decides whether a finished slot earns another attempt.
     #
-    # A survived verdict is the only retryable one: it is the verdict a flaky
-    # test can fake, whereas a kill cannot be faked by flakiness. A requested
-    # shutdown vetoes retries outright — respawning children while tearing the
-    # run down would leak processes past the drain window.
+    # The rule itself lives in FlakyRetryDecision; this class adds the shutdown
+    # veto. A requested shutdown vetoes retries outright — respawning children
+    # while tearing the run down would leak processes past the drain window.
     class RetryPolicy
-      def initialize(max_retries:)
+      def initialize(max_retries:, flaky_tests: FlakyTestRegistry.new([]))
         @max_retries = max_retries.to_i
+        @decision = FlakyRetryDecision.new(flaky_tests: flaky_tests, max_retries: @max_retries)
       end
 
       def retry?(slot:, result:, shutdown:)
-        !shutdown && result.survived? && slot.retry_count < @max_retries
+        return false if shutdown || result.status != :killed
+
+        @decision.retry?(status: :killed, killing_tests: result.killing_tests, attempts: slot.retry_count)
       end
     end
   end

data/lib/henitai/slot_scheduler.rb

@@ -51,7 +51,8 @@ module Henitai
     # rubocop:disable Metrics/ParameterLists -- every one of these is a distinct
     # collaborator supplied by ProcessWorkerRunner; bundling them into a context
     # object would only move the list.
-    def initialize(integration:, config:, progress_reporter:, options:, host:, slot_table: SlotTable.new)
+    def initialize(integration:, config:, progress_reporter:, options:, host:, slot_table: SlotTable.new,
+                   flaky_tests: nil)
       # rubocop:enable Metrics/ParameterLists
       @integration = integration
       @config = config
@@ -59,6 +60,7 @@ module Henitai
       @options = options
       @host = host
       @slot_table = slot_table
+      @injected_flaky_tests = flaky_tests
       @pending = []
       @results = []
       @flaky_retry_count = 0
@@ -119,7 +121,7 @@ module Henitai
       worker_index = slot_table.next_free_worker_index(worker_count)
       with_worker_slot(worker_index) do
         handle = integration.spawn_mutant(mutant: mutant, test_files: test_files)
-        register_slot(handle, mutant, worker_index, slot_timeout(mutant, test_files))
+        register_slot(handle, mutant, worker_index, handle.timeout || slot_timeout(mutant, test_files))
       end
     rescue StandardError => e
       record_spawn_failure(mutant, e)
@@ -154,14 +156,21 @@ module Henitai
       resolver ? resolver.call(mutant, test_files) : config.timeout
     end
 
+    # Every path that reaps a mutant child ends here, so this is the single
+    # place that tears down the child's process group. A reaped pid that owns
+    # no slot (wait2(-1) can reap any helper child) is never signalled.
     def complete_slot(pid, wait_result)
       slot_id = slot_table.release_pid(pid)
       return unless slot_id
 
+      tear_down_process_group(pid)
+
       slot = slot_table.fetch(slot_id)
       return unless slot
 
       Integration::SchedulerDiagnostics.child_ended(pid)
+      return rerun_lost_slot(slot) if lost?(wait_result)
+
       result = integration.build_result(wait_result, slot.log_paths)
       dispatch_slot_result(slot, result)
     end
@@ -175,6 +184,7 @@ module Henitai
     def finalize_slot(slot, result)
       slot_table.delete(slot.slot_id)
       slot.mutant.status = result.status
+      ScenarioExecutionResult.copy_reason(result, slot.mutant)
       results << result
       progress_reporter&.progress(slot.mutant, scenario_result: result)
       result.release_output! if result.respond_to?(:release_output!)
@@ -184,7 +194,13 @@ module Henitai
     # the runner builds when nothing is pending) pass `config: nil`, and this
     # is only reached once a slot has actually finished.
     def retry_policy
-      @retry_policy ||= RetryPolicy.new(max_retries: config.max_flaky_retries)
+      @retry_policy ||= RetryPolicy.new(max_retries: config.max_flaky_retries, flaky_tests: flaky_tests)
+    end
+
+    def flaky_tests
+      return @injected_flaky_tests if @injected_flaky_tests
+
+      FlakyTestRegistry.for_config(config)
     end
 
     def drain_verdict
@@ -199,20 +215,43 @@ module Henitai
       @test_file_selection ||= TestFileSelection.new(options: options, integration: integration)
     end
 
+    # The fork server died while the mutant ran, so nothing is known about
+    # it. It is run again on the local path and never becomes a verdict.
+    def lost?(wait_result)
+      wait_result.respond_to?(:lost?) && wait_result.lost?
+    end
+
+    def rerun_lost_slot(slot)
+      return slot_table.delete(slot.slot_id) if shutdown?
+
+      respawn_slot(slot) { |handle| restart_slot(slot, handle) }
+    end
+
     def retry_slot(slot)
-      test_files = test_file_selection.for(slot.mutant)
-      with_worker_slot(slot.worker_index) do
-        handle = integration.spawn_mutant(mutant: slot.mutant, test_files: test_files)
-        finish_retry(slot, handle)
-      end
+      respawn_slot(slot) { |handle| finish_retry(slot, handle) }
+    end
+
+    def respawn_slot(slot)
+      with_worker_slot(slot.worker_index) { yield respawn_handle(slot) }
     rescue StandardError => e
       slot_table.delete(slot.slot_id)
       record_spawn_failure(slot.mutant, e)
     end
 
+    def respawn_handle(slot)
+      test_files = test_file_selection.for(slot.mutant)
+      handle = integration.spawn_mutant(mutant: slot.mutant, test_files: test_files)
+      slot.timeout = handle.timeout || slot_timeout(slot.mutant, test_files)
+      handle
+    end
+
     def finish_retry(slot, handle)
       @flaky_retry_count += 1 if slot.retry_count.zero?
       slot.retry_count += 1
+      restart_slot(slot, handle)
+    end
+
+    def restart_slot(slot, handle)
       reset_slot_for_retry(slot, handle)
       slot_table.register_pid(handle.pid, slot.slot_id)
       Integration::SchedulerDiagnostics.child_started(handle.pid)

data/lib/henitai/source_file_selection.rb

@@ -58,7 +58,7 @@ module Henitai
     # dirty and untracked files): the working tree is what gets tested, so it is
     # always part of "changed since REF".
     def changed_paths_since
-      @git_diff_analyzer.changed_files(from: @since, to: "HEAD") +
+      @git_diff_analyzer.changed_files_since(@since) +
         @git_diff_analyzer.working_tree_changed_files
     end