henitai 0.5.1 → 0.6.0

data/lib/henitai/coverage_bootstrapper.rb

@@ -32,18 +32,22 @@ module Henitai
     # @param config       [Configuration]
     # @param integration  [Integration::Base]
     # @param test_files   [Array<String>, nil] test files to run; defaults to
-    #                     all files reported by the integration when nil
+    #                     all files reported by the integration when nil.
+    #                     Either way, `config.test_excludes` matches are dropped.
+    # @raise [ConfigurationError] when the excludes leave no test file to run
     def ensure!(source_files:, config:, integration:, test_files: nil)
       return if source_files.empty?
 
-      resolved_test_files = resolve_test_files(integration, test_files)
+      resolved_test_files = resolve_test_files(integration, test_files, config)
 
       # Skip the bootstrap only when the coverage artifacts are both newer than
       # all watched files and actually cover the configured sources. A fresh
       # but irrelevant report (e.g. from a different working directory) must
       # still trigger a re-bootstrap rather than silently proceeding with no
       # usable coverage.
-      unless coverage_ready?(source_files, config, integration, resolved_test_files)
+      if flaky_detection?(config)
+        run_flaky_baseline(integration, config, resolved_test_files)
+      elsif !coverage_ready?(source_files, config, integration, resolved_test_files)
         bootstrap_coverage(integration, config, resolved_test_files)
       end
 
@@ -67,7 +71,25 @@ module Henitai
     def coverage_ready?(source_files, config, integration, test_files)
       coverage_fresh?(source_files, config, test_files) &&
         coverage_available?(source_files, config) &&
-        per_test_coverage_ready?(source_files, config, integration, test_files)
+        per_test_coverage_ready?(source_files, config, integration, test_files) &&
+        boot_seconds_ready?(config, integration)
+    end
+
+    # Timeout calibration reads the boot time the per-test collector writes
+    # next to the coverage artifacts, so a missing boot file means the
+    # baseline must run again to measure it.
+    def boot_seconds_ready?(config, integration)
+      return true unless calibration_enabled?(config) && per_test_coverage_supported?(integration)
+
+      File.exist?(boot_seconds_report_path(config))
+    end
+
+    def calibration_enabled?(config)
+      config.respond_to?(:timeout_configured?) && !config.timeout_configured?
+    end
+
+    def boot_seconds_report_path(config)
+      File.join(reports_dir(config), PerTestCoverageCollector::BOOT_FILE_NAME)
     end
 
     def covered_source_files(source_files, coverage_lines)
@@ -133,19 +155,25 @@ module Henitai
             return
           end
 
-          raise CoverageError, build_bootstrap_error(result)
+          raise CoverageError, BootstrapErrorMessage.build(result)
         end
       end
     end
 
-    def build_bootstrap_error(result)
-      return "Configured test suite failed while generating coverage" unless result.respond_to?(:log_path)
+    # Flaky detection needs two complete baseline runs, so the existing
+    # coverage is never reused in this mode.
+    def flaky_detection?(config)
+      config.respond_to?(:flaky_detection) && config.flaky_detection
+    end
 
-      tail = result.tail(12).strip
-      message = +"Configured test suite failed while generating coverage"
-      message << " (see #{result.log_path})"
-      message << "\n#{tail}" unless tail.empty?
-      message
+    def run_flaky_baseline(integration, config, test_files)
+      with_reports_dir(config) do
+        with_coverage_dir(config) do
+          FlakyDetectionBaseline.new(reports_dir: reports_dir(config))
+                                .run(integration:, test_files:)
+          record_dependency_manifest(config)
+        end
+      end
     end
 
     def with_coverage_dir(config)
@@ -225,10 +253,24 @@ module Henitai
       Array(source_files) + Array(test_files) + VerdictFingerprint.dependency_files
     end
 
-    def resolve_test_files(integration, test_files)
-      return test_files unless test_files.nil?
+    # Excluded tests are dropped here rather than in `bootstrap_coverage`, so
+    # the same filtered list feeds both the suite run and the freshness watch
+    # list: a test that no longer contributes to the baseline must not
+    # invalidate it either.
+    def resolve_test_files(integration, test_files, config)
+      candidates = test_files.nil? ? integration.test_files : test_files
+      patterns = configured_test_excludes(config)
+      retained = ExcludedTestFilter.new(patterns:).reject(candidates)
+      return retained unless retained.empty? && candidates.any?
+
+      raise ConfigurationError,
+            "test_excludes #{Array(patterns).inspect} excludes every test file; " \
+            "coverage cannot be generated"
+    end
 
-      integration.test_files
+    # Specs pass bare config doubles exposing only what the example needs.
+    def configured_test_excludes(config)
+      config.respond_to?(:test_excludes) ? config.test_excludes : nil
     end
 
     def reports_dir(config)

data/lib/henitai/coverage_formatter.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "henitai/per_test_coverage_collector"
+require "henitai/test_file_outcomes"
+require "henitai/rspec_outcomes"
 
 module Henitai
   # Collects per-test coverage data for static filtering heuristics.
@@ -8,8 +10,14 @@ module Henitai
     REPORT_DIR_ENV = PerTestCoverageCollector::REPORT_DIR_ENV
     REPORT_FILE_NAME = PerTestCoverageCollector::REPORT_FILE_NAME
 
-    def initialize(_output)
-      @collector = PerTestCoverageCollector.new
+    def initialize(_output, boot_clock: SuiteBootClock.from_env(ENV))
+      @collector = PerTestCoverageCollector.new(boot_clock:)
+      @outcomes = TestFileOutcomes.new
+      @outcome_listener = RspecOutcomes::Listener.new(@outcomes)
+    end
+
+    def example_started(_notification)
+      @collector.test_started
     end
 
     def example_finished(notification)
@@ -18,10 +26,25 @@ module Henitai
         example.metadata[:file_path],
         duration: example.execution_result.run_time
       )
+      @outcome_listener.example_finished(notification)
+    end
+
+    def example_group_started(notification)
+      @outcome_listener.example_group_started(notification)
+    end
+
+    def example_group_finished(notification)
+      @outcome_listener.example_group_finished(notification)
+    end
+
+    def message(notification)
+      @outcome_listener.message(notification)
     end
 
-    def dump_summary(_summary)
+    def dump_summary(summary)
+      @outcome_listener.dump_summary(summary)
       @collector.write_report
+      @outcomes.write(TestFileOutcomes.default_report_path)
     end
   end
 end

data/lib/henitai/coverage_report_reader.rb

@@ -7,6 +7,7 @@ module Henitai
   class CoverageReportReader
     DEFAULT_COVERAGE_REPORT_PATH = "coverage/.resultset.json"
     DEFAULT_PER_TEST_COVERAGE_REPORT_PATH = "coverage/henitai_per_test.json"
+    DEFAULT_SUITE_BOOT_REPORT_PATH = "coverage/henitai_suite_boot.json"
 
     def coverage_lines_by_file(path = DEFAULT_COVERAGE_REPORT_PATH)
       return {} unless File.exist?(path)
@@ -37,6 +38,26 @@ module Henitai
       end.to_h
     end
 
+    # Suite boot seconds (loading helpers, spec files and before(:suite)).
+    # Missing or malformed reports yield 0.0, the value for "unknown".
+    def boot_seconds(path = DEFAULT_SUITE_BOOT_REPORT_PATH)
+      return 0.0 unless File.exist?(path)
+
+      parsed = JSON.parse(File.read(path))
+      parsed.is_a?(Hash) ? usable_boot_seconds(parsed["boot_seconds"]) : 0.0
+    rescue JSON::ParserError, ArgumentError, TypeError
+      0.0
+    end
+
+    # Only a finite, non-negative number is a usable measurement; anything
+    # else is treated as unknown.
+    def usable_boot_seconds(value)
+      return 0.0 unless value.is_a?(Numeric)
+
+      seconds = Float(value)
+      seconds.finite? && seconds >= 0 ? seconds : 0.0
+    end
+
     private
 
     def per_test_report(path)

data/lib/henitai/equivalence_detector/operand_predicates.rb

@@ -27,8 +27,24 @@ module Henitai
       # Multiplicative identity: `x * 1`, `x / 1` and `x ** 1` all reduce to `x`.
       def one_operand?(node) = numeric_operand?(node, 1)
 
+      # The identities above only hold when the receiver is a number. For an
+      # unknown receiver `"ab" * 1` is `"ab"` while `"ab" / 1` raises, and a
+      # custom object may define its own operators. Negative zero is excluded
+      # because `-0.0 + 0` is `0.0` while `-0.0 - 0` is `-0.0`.
+      def numeric_receiver?(node)
+        return false unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :int then true
+        when :float then !negative_zero?(node.children.first)
+        else false
+        end
+      end
+
       private
 
+      def negative_zero?(value) = value.zero? && (1.0 / value).negative?
+
       # Reads the right-hand operand of a binary send. Guards against a
       # malformed node whose operand is a bare Ruby value rather than an AST
       # node -- that shape does not occur in parsed source, but the detector

data/lib/henitai/equivalence_detector.rb

@@ -6,9 +6,25 @@ require_relative "equivalence_detector/operand_predicates"
 module Henitai
   # Detects obvious equivalent mutants before execution.
   #
-  # The detector is intentionally conservative: it only marks mutations as
-  # equivalent when the AST shape and the operand literals make the equivalence
-  # obvious enough to be useful.
+  # The detector is intentionally conservative: it only marks a mutation as
+  # equivalent when the AST shape and the literal operands prove the
+  # equivalence for every runtime value. Each rule below states the argument
+  # that makes it sound; a rule that cannot state one is not implemented.
+  #
+  # Rules:
+  #   * Additive identity, `n + 0` <-> `n - 0`, when `n` is an Integer literal
+  #     or a non-negative-zero Float literal. Both return `n`.
+  #   * Multiplicative identity, `n * 1` <-> `n / 1` <-> `n ** 1`, under the
+  #     same receiver condition. Both return `n`.
+  #   * Left-literal logical identity, `false || x` -> `x` and `true && x` -> `x`.
+  #     `false || x` is `x` for every `x`, and `true && x` is `x` for every `x`.
+  #     The right-literal forms are unsound: `nil || false` is `false` and
+  #     `5 && true` is `true`.
+  #   * Singleton equality, `s == v` <-> `s.equal?(v)` when `s` and `v` are
+  #     Symbol, nil, true or false literals. These values are unique instances,
+  #     so `==` reduces to identity.
+  #   * String equality, `"a" == "b"` <-> `"a".eql?("b")` when both operands are
+  #     String literals. Both compare type and value for two Strings.
   class EquivalenceDetector
     def analyze(mutant)
       return mutant unless equivalent_mutation?(mutant)
@@ -48,14 +64,16 @@ module Henitai
       additive_operator?(original.children[1]) &&
         additive_operator?(mutated.children[1]) &&
         zero_operand?(original) &&
-        zero_operand?(mutated)
+        zero_operand?(mutated) &&
+        numeric_receiver?(original)
     end
 
     def multiplicative_equivalent?(original, mutated)
       multiplicative_operator?(original.children[1]) &&
         multiplicative_operator?(mutated.children[1]) &&
         one_operand?(original) &&
-        one_operand?(mutated)
+        one_operand?(mutated) &&
+        numeric_receiver?(original)
     end
 
     def equivalent_logical_mutation?(mutant)
@@ -71,28 +89,23 @@ module Henitai
     end
 
     def logical_identity_equivalent?(original, mutated)
-      case original.type
-      when :or
+      if original.type == :or
         false_identity_equivalent?(original, mutated)
-      when :and
-        true_identity_equivalent?(original, mutated)
       else
-        false
+        true_identity_equivalent?(original, mutated)
       end
     end
 
+    # `false || x` is `x` for every `x`. The right-literal form `x || false` is
+    # not: `nil || false` is `false`, not `nil`.
     def false_identity_equivalent?(original, mutated)
-      return true if false_operand?(original.children[0]) && same_node?(mutated, original.children[1])
-      return true if false_operand?(original.children[1]) && same_node?(mutated, original.children[0])
-
-      false
+      false_operand?(original.children[0]) && same_node?(mutated, original.children[1])
     end
 
+    # `true && x` is `x` for every `x`. The right-literal form `x && true` is
+    # not: `5 && true` is `true`, not `5`.
     def true_identity_equivalent?(original, mutated)
-      return true if true_operand?(original.children[0]) && same_node?(mutated, original.children[1])
-      return true if true_operand?(original.children[1]) && same_node?(mutated, original.children[0])
-
-      false
+      true_operand?(original.children[0]) && same_node?(mutated, original.children[1])
     end
 
     def false_operand?(node)
@@ -121,6 +134,8 @@ module Henitai
 
     def one_operand?(node) = operand_predicates.one_operand?(node)
 
+    def numeric_receiver?(node) = operand_predicates.numeric_receiver?(node.children[0])
+
     def operand_predicates = @operand_predicates ||= OperandPredicates.new
 
     # Detects `lhs == <singleton>` mutated to `lhs.equal?(<singleton>)` (or the
@@ -146,28 +161,27 @@ module Henitai
         equality_operators?(original.children[1], mutated.children[1])
     end
 
-    # Detects `lhs == rhs` mutated to `lhs.eql?(rhs)` (or the reverse) when at
-    # least one operand is a string literal.
+    # Detects `lhs == rhs` mutated to `lhs.eql?(rhs)` (or the reverse) when both
+    # operands are string literals.
     #
-    # String#eql? is documented to compare both type and value. Since String#==
-    # also compares type and value (it returns false for any non-String argument
-    # without invoking the other object's #==), the two methods are equivalent
-    # for all possible inputs whenever at least one operand is statically known
-    # to be a String — proven here by the presence of a :str literal on the
-    # receiver or the argument side.
-    #
-    # When no operand is a string literal we conservatively leave the mutant
-    # pending: the receiver could be any object whose custom #== diverges from
-    # its #eql?.
+    # With two String literals, neither `==` nor `eql?` can reach a custom
+    # method, so both compare type and value and return the same result. A
+    # single string literal is not enough: an unknown receiver can override
+    # `==`, and `"a" == obj` calls `obj == "a"` when obj responds to `to_str`.
     def equivalent_string_eql_mutation?(mutant)
       original = mutant.original_node
       mutated  = mutant.mutated_node
 
+      string_eql_swap?(original, mutated) &&
+        string_literal?(original.children[0]) &&
+        string_literal?(original.children[2])
+    end
+
+    def string_eql_swap?(original, mutated)
       string_eql_send?(original) && string_eql_send?(mutated) &&
         same_receiver?(original, mutated) &&
         string_eql_operators?(original.children[1], mutated.children[1]) &&
-        same_rhs?(original, mutated) &&
-        string_operand?(original)
+        same_rhs?(original, mutated)
     end
 
     def string_eql_send?(node)
@@ -189,12 +203,6 @@ module Henitai
       same_node?(original.children[2], mutated.children[2])
     end
 
-    # Returns true when at least one operand is a string literal, giving static
-    # proof that the comparison is string-typed on at least one side.
-    def string_operand?(node)
-      string_literal?(node.children[0]) || string_literal?(node.children[2])
-    end
-
     def string_literal?(node)
       node.is_a?(Parser::AST::Node) && node.type == :str
     end

data/lib/henitai/example_summary.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Reads whether a test run's output says that no example ran.
+  #
+  # Both texts are matched at the start of a line only, and only the last
+  # summary line counts: failure output may quote either text, indented, from
+  # the test source, and the tests themselves may print summaries of nested
+  # runs before the run's own.
+  module ExampleSummary
+    NO_EXAMPLES_FOUND = /^No examples found\.$/
+    SUMMARY = /^(\d+) (?:examples?, \d+ failures?|runs?, \d+ assertions?)/
+
+    module_function
+
+    def none_ran?(output)
+      text = output.to_s
+      summaries = text.scan(SUMMARY)
+      return NO_EXAMPLES_FOUND.match?(text) if summaries.empty?
+
+      summaries.last == ["0"]
+    end
+  end
+end

data/lib/henitai/execution_engine/fork_server_scope.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../fork_server"
+
+module Henitai
+  class ExecutionEngine
+    # Opt-in fork-server execution (`mutation.fork_server`, ADR-15) for the
+    # engine's linear path. While the block runs, @fork_server_runner (when a
+    # server booted) runs the mutants; it is nil when the flag is off, the
+    # integration cannot boot once, or the server failed to boot, and the
+    # integration then boots per mutant.
+    module ForkServerScope
+      private
+
+      def with_fork_server(mutants, integration, config)
+        @fork_server_runner = start_fork_server(mutants, integration, config)
+        yield
+      ensure
+        @fork_server_runner&.stop
+        @fork_server_runner = nil
+      end
+
+      def start_fork_server(mutants, integration, config)
+        return unless fork_server_requested?(config)
+        return warn_fork_server_unsupported unless fork_server_supported?(integration)
+
+        test_files = mutants.flat_map { |mutant| prioritized_tests_for(mutant, integration, config) }.uniq
+        return if test_files.empty?
+
+        ForkServer.start(integration:, mutants:, test_files:, log_path: fork_server_log_path(config),
+                         fallback_timeout: ->(files) { resolved_timeout(files, config) })
+      end
+
+      def fork_server_requested?(config)
+        config.respond_to?(:fork_server) && config.fork_server ? true : false
+      end
+
+      def fork_server_supported?(integration)
+        integration.respond_to?(:fork_server_supported?) && integration.fork_server_supported?
+      end
+
+      def warn_fork_server_unsupported
+        warn("henitai: mutation.fork_server is not supported for this integration; using per-mutant boot")
+        nil
+      end
+
+      # The scheduler learns of served processes' exits through the server.
+      def parallel_runtime_options
+        @fork_server_runner&.active? ? { runtime: @fork_server_runner.runtime } : {}
+      end
+
+      def fork_server_log_path(config)
+        File.join(config.reports_dir, "mutation-logs", "fork-server.log")
+      end
+    end
+  end
+end

data/lib/henitai/execution_engine.rb

@@ -2,11 +2,13 @@
 
 require_relative "process_worker_runner"
 require_relative "execution_engine/env_scope"
+require_relative "execution_engine/fork_server_scope"
 
 module Henitai
   # Runs pending mutants through the selected integration.
   class ExecutionEngine
     include EnvScope
+    include ForkServerScope
 
     def run(mutants, integration, config, progress_reporter: nil)
       with_reports_dir(config) do
@@ -23,17 +25,36 @@ module Henitai
     private
 
     def execute(mutants, integration, config, progress_reporter)
-      @flaky_retry_count = 0
       pending_mutants = Array(mutants).select(&:pending?)
       mutex = Mutex.new
-      if parallel_execution?(config, pending_mutants)
-        run_parallel(pending_mutants, integration, config, progress_reporter)
-      else
-        run_linear(pending_mutants, integration, config, progress_reporter, mutex)
+      @flaky_tests = flaky_tests_for(config)
+      @retrier = FlakyMutantRetrier.new(flaky_tests: @flaky_tests, max_retries: max_flaky_retries(config))
+      run_pending(pending_mutants, integration, config, progress_reporter, mutex)
+      warn_flaky_mutants
+      verify_controls(pending_mutants, integration, config)
+      mutants
+    end
+
+    def run_pending(pending_mutants, integration, config, progress_reporter, mutex)
+      with_fork_server(pending_mutants, integration, config) do
+        if parallel_execution?(config, pending_mutants)
+          run_parallel(pending_mutants, integration, config, progress_reporter)
+        else
+          run_linear(pending_mutants, integration, config, progress_reporter, mutex)
+          @flaky_retry_count = @retrier.retried_count
+        end
       end
+    end
 
-      warn_flaky_mutants(pending_mutants.size)
-      mutants
+    def verify_controls(mutants, integration, config)
+      return unless config.respond_to?(:control_runs) && config.control_runs
+
+      timeout_for = ->(test_files) { resolved_timeout(test_files, config) }
+      stats = ControlRun.new(integration:, timeout_for:).verify(mutants)
+      return if stats[:failed].zero?
+
+      warn format("henitai: control runs failed for %<failed>d of %<verified>d subjects; " \
+                  "%<reclassified>d detected verdicts reclassified as CompileError", **stats)
     end
 
     def parallel_execution?(config, mutants)
@@ -57,10 +78,14 @@ module Henitai
     end
 
     def run_parallel(mutants, integration, config, progress_reporter)
-      runner = ProcessWorkerRunner.new(worker_count: worker_count(config))
+      runner = ProcessWorkerRunner.new(
+        worker_count: worker_count(config),
+        flaky_tests: @flaky_tests,
+        **parallel_runtime_options
+      )
       results = runner.run(
         mutants,
-        integration,
+        @fork_server_runner || integration,
         config,
         progress_reporter,
         test_file_resolver: ->(mutant) { prioritized_tests_for(mutant, integration, config) },
@@ -75,8 +100,12 @@ module Henitai
       record_test_files(mutant, test_files)
       return record_no_coverage(mutant, progress_reporter, mutex) if test_files.empty?
 
-      scenario_result = run_with_flaky_retry(mutant, integration, config, test_files, mutex)
+      scenario_result = @retrier.run(
+        mutant: mutant, integration: @fork_server_runner || integration, test_files: test_files,
+        timeout: resolved_timeout(test_files, config)
+      )
       mutant.status = scenario_status(scenario_result)
+      ScenarioExecutionResult.copy_reason(scenario_result, mutant)
 
       report_progress(mutant, scenario_result, progress_reporter, mutex)
     end
@@ -92,19 +121,15 @@ module Henitai
     end
 
     def report_progress(mutant, scenario_result, progress_reporter, mutex)
-      if mutex
-        mutex.synchronize { progress_reporter&.progress(mutant, scenario_result:) }
-      else
-        progress_reporter&.progress(mutant, scenario_result:)
-      end
+      mutex.synchronize { progress_reporter&.progress(mutant, scenario_result:) }
     end
 
     def prioritized_tests_for(mutant, integration, config)
-      tests = reject_excluded_tests(integration.select_tests(mutant.subject), config)
-      tests = per_test_coverage_selector.filter(
-        tests,
+      tests = per_test_coverage_selector.select(
         mutant,
-        reports_dir: config.reports_dir
+        reports_dir: config.reports_dir,
+        test_files: -> { reject_excluded_tests(integration.test_files, config) },
+        fallback: -> { reject_excluded_tests(integration.select_tests(mutant.subject), config) }
       )
       test_prioritizer(config).sort(tests, mutant, test_history(config))
     end
@@ -133,11 +158,21 @@ module Henitai
     def resolved_timeout(test_files, config)
       return config.timeout unless calibration_enabled?(config)
 
-      calibrated = timeout_calibrator(config).timeout_for(test_files)
-      return [calibrated, max_timeout(config)].min if calibrated
+      calibrator = timeout_calibrator(config)
+      calibrated = calibrator.timeout_for(test_files)
+      unless calibrated
+        warn_timeout_fallback_once
+        return Configuration::DEFAULT_TIMEOUT
+      end
 
-      warn_timeout_fallback_once
-      Configuration::DEFAULT_TIMEOUT
+      timeout_ceiling(config).cap(calibrated, calibrator.baseline_for(test_files))
+    end
+
+    def timeout_ceiling(config)
+      @timeout_ceiling ||= TimeoutCeiling.new(
+        ceiling: max_timeout(config),
+        warner: ->(message) { warn(message) }
+      )
     end
 
     # Ceiling on the auto-calibrated timeout so a runaway mutant is killed in
@@ -153,13 +188,21 @@ module Henitai
       config.respond_to?(:timeout_configured?) && !config.timeout_configured?
     end
 
+    # Boot stays in the timeout even with a fork server: served mutants still
+    # run the suite's before(:suite) hooks, which the boot measurement includes.
     def timeout_calibrator(config)
       @timeout_calibrator ||= TimeoutCalibrator.new(
         timing_source: timing_source(config),
-        multiplier: config.timeout_multiplier
+        multiplier: config.timeout_multiplier,
+        boot_seconds: -> { boot_seconds(config) }
       )
     end
 
+    def boot_seconds(config)
+      path = File.join(config.reports_dir, PerTestCoverageCollector::BOOT_FILE_NAME)
+      CoverageReportReader.new.boot_seconds(path)
+    end
+
     def warn_timeout_fallback_once
       return if @warned_timeout_fallback
 
@@ -178,34 +221,9 @@ module Henitai
       config.history || {}
     end
 
-    # Retry logic is kept in one place to preserve the status transition flow.
-    # The retry budget is configurable because repeated survivors can multiply
-    # runtime on real CI workloads.
-    # rubocop:disable Metrics/MethodLength
-    def run_with_flaky_retry(mutant, integration, config, test_files, mutex)
-      timeout = resolved_timeout(test_files, config)
-      scenario_result = integration.run_mutant(
-        mutant:,
-        test_files:,
-        timeout: timeout
-      )
-      return scenario_result unless scenario_status(scenario_result) == :survived
-
-      retries = 0
-      max_flaky_retries(config).times do
-        retries += 1
-        scenario_result = integration.run_mutant(
-          mutant:,
-          test_files:,
-          timeout: timeout
-        )
-        break unless scenario_status(scenario_result) == :survived
-      end
-
-      mutex.synchronize { @flaky_retry_count += 1 } if retries.positive?
-      scenario_result
+    def flaky_tests_for(config)
+      FlakyTestRegistry.for_config(config)
     end
-    # rubocop:enable Metrics/MethodLength
 
     def scenario_status(result)
       return result if result.is_a?(Symbol)
@@ -213,17 +231,14 @@ module Henitai
       result.status
     end
 
-    def warn_flaky_mutants(total_mutants)
-      return if total_mutants.zero?
-
-      flaky_ratio = @flaky_retry_count.to_f / total_mutants
-      return unless flaky_ratio > 0.05
+    def warn_flaky_mutants
+      return if @flaky_retry_count.to_i.zero?
 
       warn format(
-        "Flaky-test mitigation: %<flaky>d/%<total>d mutants required retries (%<ratio>.2f%%)",
-        flaky: @flaky_retry_count,
-        total: total_mutants,
-        ratio: flaky_ratio * 100.0
+        "Flaky-test mitigation: %<count>d killed mutant(s) were re-checked because their killing tests " \
+        "are flaky (%<files>s)",
+        count: @flaky_retry_count,
+        files: @flaky_tests.all.join(", ")
       )
     end