evilution 0.31.0 → 0.33.0

data/lib/evilution/parallel/work_queue/dispatcher.rb

@@ -38,24 +38,47 @@ class Evilution::Parallel::WorkQueue::Dispatcher
     end
   end
 
+  # Each worker carries its own deadline (set when it goes busy, refreshed on
+  # every result). The select blocks only until the nearest worker deadline,
+  # so a single stuck worker is reaped in isolation -- its in-flight item gets
+  # the WorkQueue::TIMED_OUT sentinel and the worker is recycled -- instead of
+  # the old pool-wide watchdog that SIGKILLed every worker and aborted the run.
   def collect
     io_to_worker = @workers.to_h { |w| [w.res_io, w] }
     result_ios = io_to_worker.keys
 
     while @state.in_flight.positive?
-      readable, = IO.select(result_ios, nil, nil, @item_timeout)
-      if readable.nil?
-        record_timeout
-        break
-      end
+      readable, = IO.select(result_ios, nil, nil, select_timeout)
+      reap_timed_out(io_to_worker, result_ios)
+      next if readable.nil?
 
-      readable.each { |io| process_readable(io, io_to_worker, result_ios) }
+      readable.each do |io|
+        process_readable(io, io_to_worker, result_ios) if result_ios.include?(io)
+      end
     end
   end
 
-  def record_timeout
-    terminate_stuck
-    @state.first_error ||= Evilution::Error.new("worker timed out after #{@item_timeout}s")
+  def select_timeout
+    return @item_timeout unless @item_timeout
+
+    deadlines = @workers.filter_map(&:deadline)
+    return @item_timeout if deadlines.empty?
+
+    [deadlines.min - monotonic, 0].max
+  end
+
+  def reap_timed_out(io_to_worker, result_ios)
+    return unless @item_timeout
+
+    now = monotonic
+    stuck = @workers.select { |w| w.deadline && w.deadline <= now && w.pending.positive? }
+    stuck.each { |w| time_out_worker(w, io_to_worker, result_ios) }
+  end
+
+  def time_out_worker(worker, io_to_worker, result_ios)
+    worker.kill
+    mark_unfinished(worker, Evilution::Parallel::WorkQueue::TIMED_OUT)
+    retire_or_replace(worker, io_to_worker, result_ios)
   end
 
   def process_readable(io, io_to_worker, result_ios)
@@ -65,7 +88,7 @@ class Evilution::Parallel::WorkQueue::Dispatcher
 
   def handle(worker, io_to_worker, result_ios)
     message = worker.read_result
-    return handle_dead(worker) if message.nil?
+    return handle_dead(worker, io_to_worker, result_ios) if message.nil?
 
     record(message, worker)
     return false if recycle_and_dispatch(worker, io_to_worker, result_ios)
@@ -82,13 +105,24 @@ class Evilution::Parallel::WorkQueue::Dispatcher
     @state.in_flight -= 1
     worker.pending -= 1
     worker.items_completed += 1
+    worker.in_flight_indices.delete(index)
+    worker.deadline = next_deadline(worker)
   end
 
-  def handle_dead(worker)
-    @state.first_error ||= Evilution::Error.new("worker process exited unexpectedly")
+  # A worker that exited without replying loses only its in-flight item(s)
+  # (marked :died) and is recycled; the run continues rather than aborting.
+  def handle_dead(worker, io_to_worker, result_ios)
+    mark_unfinished(worker, Evilution::Parallel::WorkQueue::DIED)
+    retire_or_replace(worker, io_to_worker, result_ios)
+    false
+  end
+
+  def mark_unfinished(worker, sentinel)
+    worker.in_flight_indices.each { |index| @state.results[index] = sentinel }
     @state.in_flight -= worker.pending
     worker.pending = 0
-    false
+    worker.in_flight_indices.clear
+    worker.deadline = nil
   end
 
   def draining_for_recycle?(worker)
@@ -113,28 +147,66 @@ class Evilution::Parallel::WorkQueue::Dispatcher
   end
 
   def recycle(old_worker, io_to_worker, result_ios)
-    io_to_worker.delete(old_worker.res_io)
-    result_ios.delete(old_worker.res_io)
-    @retired << old_worker.retire
-
+    index = @workers.index(old_worker)
+    detach(old_worker, io_to_worker, result_ios)
     new_worker = @recycle_factory.call(old_worker)
-    @workers[@workers.index(old_worker)] = new_worker
-    io_to_worker[new_worker.res_io] = new_worker
-    result_ios << new_worker.res_io
+    @workers[index] = new_worker
+    attach(new_worker, io_to_worker, result_ios)
     new_worker
   end
 
+  # Shared failure-path recovery: retire the worker, and as long as work
+  # remains spin up a replacement to keep the pool full and hand it the next
+  # item. When the queue is already drained, just drop the worker.
+  def retire_or_replace(worker, io_to_worker, result_ios)
+    index = @workers.index(worker)
+    detach(worker, io_to_worker, result_ios)
+
+    if more_to_send? && @state.first_error.nil?
+      new_worker = @recycle_factory.call(worker)
+      @workers[index] = new_worker
+      attach(new_worker, io_to_worker, result_ios)
+      send_item(new_worker)
+    else
+      @workers.delete_at(index)
+    end
+  end
+
+  def detach(worker, io_to_worker, result_ios)
+    io_to_worker.delete(worker.res_io)
+    result_ios.delete(worker.res_io)
+    @retired << worker.retire
+  end
+
+  def attach(worker, io_to_worker, result_ios)
+    io_to_worker[worker.res_io] = worker
+    result_ios << worker.res_io
+  end
+
   def send_item(worker)
     worker.send_item(@state.next_index, @items[@state.next_index])
     @state.next_index += 1
     @state.in_flight += 1
+    start_deadline(worker)
+  end
+
+  def start_deadline(worker)
+    return unless @item_timeout
+
+    worker.deadline ||= monotonic + @item_timeout
+  end
+
+  def next_deadline(worker)
+    return nil unless @item_timeout && worker.pending.positive?
+
+    monotonic + @item_timeout
   end
 
   def more_to_send?
     @state.next_index < @items.length
   end
 
-  def terminate_stuck
-    @workers.each(&:kill)
+  def monotonic
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 end

data/lib/evilution/parallel/work_queue/worker.rb

@@ -4,12 +4,13 @@ require_relative "../work_queue"
 require_relative "../../child_output"
 require_relative "channel"
 require_relative "channel/frame"
+require_relative "worker_registry"
 
 class Evilution::Parallel::WorkQueue::Worker
   Timing = Data.define(:busy, :wall)
 
-  attr_reader :pid, :worker_index
-  attr_accessor :items_completed, :pending, :busy_time, :wall_time
+  attr_reader :pid, :worker_index, :in_flight_indices
+  attr_accessor :items_completed, :pending, :busy_time, :wall_time, :deadline
 
   def self.spawn(worker_index:, hooks:, &block)
     cmd_read, cmd_write = IO.pipe
@@ -26,7 +27,36 @@ class Evilution::Parallel::WorkQueue::Worker
 
     cmd_read.close
     res_write.close
-    new(pid: pid, cmd_write: cmd_write, res_read: res_read, worker_index: worker_index)
+    # Register BEFORE isolating so the trap can never observe a worker that is
+    # already its own group leader yet missing from the registry (EV-jwao race,
+    # GH #1333 review): the spawn runs on the same main thread the trap
+    # interrupts, so a signal arriving between setpgid and register would
+    # otherwise leak a leader the trap cannot reach. Ordering register first
+    # leaves only safe windows -- pre-setpgid the child still shares the parent
+    # group and receives the terminal signal directly; once it is its own
+    # leader the registry already lists it. Registering unconditionally is safe
+    # because signal_all's kill(-pid) is a no-op (Errno::ESRCH) for a pid that
+    # never became a group leader (setpgid failed).
+    Evilution::Parallel::WorkQueue::WorkerRegistry.register(pid)
+    isolate_process_group(pid)
+    new(pid:, cmd_write:, res_read:, worker_index:)
+  end
+
+  # EV-cnx8 / GH #1324: make the worker its own process-group leader so #kill
+  # can signal the whole subtree. A mutation's spec may fork a grandchild that
+  # blocks (e.g. ConditionVariable#wait); when the dispatcher SIGKILLs a stuck
+  # worker, that grandchild must die with it rather than orphan to init holding
+  # memory/fds/connections. Done parent-side (before the child forks anything)
+  # so a failure is visible here instead of being swallowed in the child.
+  def self.isolate_process_group(pid)
+    Process.setpgid(pid, pid)
+  rescue Errno::EACCES, Errno::ESRCH
+    # EACCES: child already exec'd/changed group; ESRCH: child already exited.
+    # Both are benign -- reaping handles the child either way.
+    nil
+  rescue SystemCallError => e
+    warn "evilution: could not isolate worker #{pid} into its own process " \
+         "group (#{e.class}: #{e.message}); grandchildren may survive a kill."
   end
 
   # EV-kdns / GH #817: translate 0-based worker slot to parallel_tests'
@@ -46,6 +76,8 @@ class Evilution::Parallel::WorkQueue::Worker
     @pending = 0
     @busy_time = 0.0
     @wall_time = 0.0
+    @in_flight_indices = []
+    @deadline = nil
   end
 
   def res_io
@@ -55,6 +87,7 @@ class Evilution::Parallel::WorkQueue::Worker
   def send_item(index, item)
     Evilution::Parallel::WorkQueue::Channel.write(@cmd_write, [index, item])
     @pending += 1
+    @in_flight_indices << index
   end
 
   def read_result
@@ -67,7 +100,16 @@ class Evilution::Parallel::WorkQueue::Worker
     nil
   end
 
+  # SIGKILL the worker's whole process group (negative pid), reaping any
+  # grandchildren it forked. Falls back to the single pid if the group is gone
+  # -- already reaped, or setpgid did not take in the child.
   def kill
+    Process.kill("KILL", -@pid)
+  rescue Errno::ESRCH
+    kill_pid
+  end
+
+  def kill_pid
     Process.kill("KILL", @pid)
   rescue Errno::ESRCH
     nil
@@ -82,6 +124,10 @@ class Evilution::Parallel::WorkQueue::Worker
     Process.wait(@pid)
   rescue Errno::ECHILD
     nil
+  ensure
+    # Drop the pgid once the leader is reaped so the trap never signals a group
+    # whose pid the OS may have recycled. No-op if it was never registered.
+    Evilution::Parallel::WorkQueue::WorkerRegistry.unregister(@pid)
   end
 
   def retire

data/lib/evilution/parallel/work_queue/worker_registry.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../work_queue"
+
+# Process-global registry of live worker process-group ids (pgids).
+#
+# EV-jwao / GH #1332: EV-cnx8 made each Worker its own process-group leader so a
+# stuck worker's whole subtree can be group-killed. Side effect: a terminal
+# Ctrl-C delivers SIGINT only to the parent's foreground group, so workers (now
+# in their own groups) no longer receive it -- and the parent's fatal-signal
+# death skips work_queue#map's `ensure cleanup_workers`, leaking any worker that
+# was actively running a (possibly blocking) mutation at interrupt time.
+#
+# Runner#install_signal_handler reads this registry from inside the trap and
+# forwards INT/TERM to each worker group before re-raising to DEFAULT.
+#
+# Signal-safety: under MRI a trap handler runs on the main thread between VM
+# instructions, so it must not acquire a Mutex (the main thread may hold it ->
+# deadlock). register/unregister therefore swap @pgids for a freshly built
+# frozen array via a single atomic reference assignment (copy-on-write). The
+# trap reads the current reference once and iterates that complete, immutable
+# snapshot -- no torn reads, no lock.
+module Evilution::Parallel::WorkQueue::WorkerRegistry
+  @pgids = [].freeze
+
+  class << self
+    # Frozen snapshot. Safe to read from a signal handler.
+    attr_reader :pgids
+
+    def register(pgid)
+      @pgids = (@pgids + [pgid]).freeze
+    end
+
+    def unregister(pgid)
+      @pgids = @pgids.reject { |existing| existing == pgid }.freeze
+    end
+
+    def signal_all(sig)
+      @pgids.each do |pgid|
+        Process.kill(sig, -pgid)
+      rescue Errno::ESRCH
+        # Group already gone (worker + subtree reaped) -- nothing to signal.
+        nil
+      end
+    end
+  end
+end

data/lib/evilution/parallel/work_queue.rb

@@ -9,6 +9,14 @@ class Evilution::Parallel::WorkQueue
 
   TIMING_GRACE_PERIOD = 5
 
+  # Sentinel results for items whose worker never produced a value. The
+  # dispatcher writes these into the results array (instead of aborting the
+  # whole run) so a single stuck/dead worker only loses its own in-flight
+  # item(s). Mutation-aware callers translate the reason into a status.
+  Unfinished = Data.define(:reason)
+  TIMED_OUT = Unfinished.new(reason: :timeout)
+  DIED = Unfinished.new(reason: :died)
+
   def initialize(size:, hooks: nil, prefetch: 1, item_timeout: nil, worker_max_items: nil)
     Validators::PositiveInt.call!(:size, size)
     Validators::PositiveInt.call!(:prefetch, prefetch)

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+# EV-z7f5 / GH #1325: unresolved mutations are excluded from
+# `score_denominator`, so a run whose specs could not be auto-resolved
+# collapses to a bare "Score: 0.00% (0/0)" that reads like a genuine
+# mutation-quality failure. This formatter surfaces a loud, actionable
+# warning when the unresolved rate is high — and a distinct message when
+# the denominator hit zero (nothing was measured at all) — so the user
+# knows to pass --spec instead of trusting the 0.0.
+#
+# Sibling of ErrorRateWarning (EV-nrgw / GH #1168).
+class Evilution::Reporter::CLI::LineFormatters::UnresolvedRateWarning
+  DEFAULT_THRESHOLD = 0.25
+  HINT = "Pass --spec to point evilution at the test file(s)."
+
+  def initialize(threshold: DEFAULT_THRESHOLD)
+    @threshold = threshold
+  end
+
+  def format(summary)
+    return nil if summary.total.zero?
+    return nil if summary.unresolved.zero?
+
+    rate = summary.unresolved.to_f / summary.total
+    return nil if rate <= @threshold
+
+    fraction = "#{summary.unresolved}/#{summary.total}"
+    pct = (rate * 100).round(1)
+    warning(summary, fraction, pct)
+  end
+
+  private
+
+  def warning(summary, fraction, pct)
+    if summary.unresolved == summary.total
+      "! No matching tests resolved: all #{fraction} mutations unresolved — " \
+        "no mutations were measured, so the score is not meaningful. #{HINT}"
+    elsif summary.score_denominator.zero?
+      # Denominator can also hit zero with a mix of unresolved + errors /
+      # neutral / equivalent, so do not attribute it solely to missing tests.
+      "! No mutations were measured (score not meaningful): " \
+        "#{fraction} (#{pct}%) mutations were unresolved. #{HINT}"
+    else
+      "! High unresolved rate: #{fraction} (#{pct}%) mutations had no matching " \
+        "test — score may be unreliable. #{HINT}"
+    end
+  end
+end

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

@@ -4,6 +4,7 @@ require_relative "../cli"
 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/duration"
 require_relative "line_formatters/efficiency"
 require_relative "line_formatters/peak_memory"
@@ -13,6 +14,7 @@ class Evilution::Reporter::CLI::MetricsBlock
     Evilution::Reporter::CLI::LineFormatters::Mutations.new,
     Evilution::Reporter::CLI::LineFormatters::Score.new,
     Evilution::Reporter::CLI::LineFormatters::ErrorRateWarning.new,
+    Evilution::Reporter::CLI::LineFormatters::UnresolvedRateWarning.new,
     Evilution::Reporter::CLI::LineFormatters::Duration.new,
     Evilution::Reporter::CLI::LineFormatters::Efficiency.new,
     Evilution::Reporter::CLI::LineFormatters::PeakMemory.new

data/lib/evilution/runner/baseline_runner.rb

@@ -5,6 +5,7 @@ require_relative "../baseline"
 require_relative "../spec_resolver"
 require_relative "../integration/rspec"
 require_relative "../integration/minitest"
+require_relative "../integration/test_unit"
 require_relative "../example_filter"
 require_relative "../spec_ast_cache"
 require_relative "../source_ast_cache"
@@ -12,7 +13,8 @@ require_relative "../source_ast_cache"
 unless defined?(Evilution::Runner::INTEGRATIONS)
   Evilution::Runner::INTEGRATIONS = {
     rspec: Evilution::Integration::RSpec,
-    minitest: Evilution::Integration::Minitest
+    minitest: Evilution::Integration::Minitest,
+    test_unit: Evilution::Integration::TestUnit
   }.freeze
 end
 

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

@@ -1,8 +1,18 @@
 # frozen_string_literal: true
 
 require_relative "../strategy"
+require_relative "../../../parallel/work_queue"
 
 class Evilution::Runner::MutationExecutor::Strategy::Parallel
+  # Compact result for a worker that exited unexpectedly (:error is not cached,
+  # so the 0.0 duration is never persisted).
+  DIED_COMPACT = {
+    status: :error,
+    duration: 0.0,
+    error_message: "worker process exited unexpectedly",
+    error_class: "Evilution::Error"
+  }.freeze
+
   def initialize(cache:, isolator:, packer:, pipeline:, notifier:, pool_factory:, config:, diagnostics: nil)
     @cache = cache
     @isolator = isolator
@@ -71,11 +81,28 @@ class Evilution::Runner::MutationExecutor::Strategy::Parallel
     return [] if uncached_indices.empty?
 
     uncached = uncached_indices.map { |i| batch[i] }
-    pool.map(uncached) do |mutation|
+    worker_results = pool.map(uncached) do |mutation|
       test_command = ->(m) { integration.call(m) }
       result = @isolator.call(mutation: mutation, test_command: test_command, timeout: @config.timeout)
       @packer.compact(result)
     end
+    worker_results.map { |r| unpack_unfinished(r) }
+  end
+
+  def unpack_unfinished(result)
+    return result unless result.is_a?(Evilution::Parallel::WorkQueue::Unfinished)
+
+    case result.reason
+    when :timeout then timeout_compact
+    when :died then DIED_COMPACT
+    end
+  end
+
+  # A :timeout result is cacheable, so give it a realistic duration: the stuck
+  # worker exhausted the dispatcher's item_timeout (config.timeout * 2) before
+  # being killed. A 0.0 here would be cached and skew summaries/reuse.
+  def timeout_compact
+    { status: :timeout, duration: @config.timeout * 2.0 }
   end
 
   def merge(batch, uncached_indices, cached_results, worker_results)

data/lib/evilution/runner.rb

@@ -154,7 +154,12 @@ class Evilution::Runner
       return
     end
 
-    dir = config.quiet_children_dir
+    # Resolve to absolute now — fork children chdir into a per-mutation
+    # sandbox (EV-wqxu / GH #1278) before suppress_child_output runs, so a
+    # relative log_dir would reopen $stdout/$stderr at <sandbox>/<log_dir>
+    # which does not exist and the child dies with Errno::ENOENT before
+    # marshaling any result back.
+    dir = File.expand_path(config.quiet_children_dir)
     begin
       FileUtils.rm_rf(dir)
       FileUtils.mkdir_p(dir)
@@ -173,6 +178,11 @@ class Evilution::Runner
   def install_signal_handler(sig)
     prev_handler = Signal.trap(sig) do
       Evilution::TempDirTracker.cleanup_all
+      # EV-jwao / GH #1332: workers are their own process-group leaders, so a
+      # terminal Ctrl-C reaches only the parent's group. Forward to each worker
+      # group here -- the parent's fatal-signal death skips work_queue#map's
+      # `ensure cleanup_workers`, so this trap is the reliable forwarding hook.
+      Evilution::Parallel::WorkQueue::WorkerRegistry.signal_all(sig)
 
       case prev_handler
       when Proc, Method
@@ -221,6 +231,7 @@ require_relative "result/summary"
 require_relative "baseline"
 require_relative "cache"
 require_relative "parallel/pool"
+require_relative "parallel/work_queue/worker_registry"
 require_relative "session/store"
 require_relative "temp_dir_tracker"
 require_relative "rails_detector"

data/lib/evilution/spec_resolver.rb

@@ -3,6 +3,11 @@
 class Evilution::SpecResolver
   STRIPPABLE_PREFIXES = %w[lib/ app/].freeze
   CONTROLLER_PREFIX = "controllers/"
+  # Conventional test subdirectories appended to @test_dir. Real-world gems
+  # frequently park specs under spec/unit or spec/lib (test/unit, test/lib)
+  # rather than mirroring the lib/ tree 1:1 (EV-z7f5 / GH #1325).
+  CONVENTIONAL_SUBDIRS = %w[unit lib].freeze
+  MINITEST_SUFFIX = "_test.rb"
 
   def initialize(test_dir: "spec", test_suffix: "_spec.rb", request_dir: "requests")
     @test_dir = test_dir
@@ -23,8 +28,38 @@ class Evilution::SpecResolver
     Array(source_paths).filter_map { |path| call(path) }.uniq
   end
 
+  # Best-guess candidate for an unresolved source, found by basename glob
+  # rather than the deterministic path mirroring used by #call. Used only to
+  # enrich the "no matching test" hint (EV-z7f5 / GH #1325) — never to pick a
+  # test to run — so a fuzzy substring match is acceptable here. Returns the
+  # shallowest match, or nil when nothing resembles the basename.
+  def suggest(source_path)
+    return nil if source_path.nil? || source_path.empty?
+
+    stem = File.basename(normalize_path(source_path), ".rb")
+    return nil if stem.empty?
+
+    suggestion_globs(stem).flat_map { |glob| glob_relative(glob) }.uniq.min_by(&:length)
+  end
+
   private
 
+  # Glob for project-relative paths. Mirrors #call's project_relative_exists?
+  # contract: when run inside an isolated worker chdir'd into a sandbox, glob
+  # against PROJECT_ROOT so suggestions still find real project files. base:
+  # already yields paths relative to the root, matching the CWD-glob shape.
+  def glob_relative(glob)
+    return Dir.glob(glob) unless Evilution.in_isolated_worker?
+
+    Dir.glob(glob, base: Evilution::PROJECT_ROOT)
+  end
+
+  def suggestion_globs(stem)
+    globs = ["#{@test_dir}/**/*#{stem}*#{@test_suffix}"]
+    globs << "#{@test_dir}/**/test_#{stem}.rb" if @test_suffix == MINITEST_SUFFIX
+    globs
+  end
+
   # Existence check that succeeds against the current CWD. When the caller
   # is an isolated worker that chdir'd into a per-mutation sandbox (Evilution
   # signals this via in_isolated_worker?), also try PROJECT_ROOT so the
@@ -52,18 +87,55 @@ class Evilution::SpecResolver
   def candidate_test_paths(source_path)
     base = source_path.sub(/\.rb\z/, @test_suffix)
     prefix = STRIPPABLE_PREFIXES.find { |p| source_path.start_with?(p) }
+    stripped = prefix ? base.delete_prefix(prefix) : base
+
+    primary = mirror_candidates(stripped)
+    primary.unshift(controller_to_request_test(stripped)) if prefix
+    primary.compact!
 
-    candidates = if prefix
-                   stripped = base.delete_prefix(prefix)
-                   request_test = controller_to_request_test(stripped)
-                   [request_test, "#{@test_dir}/#{stripped}", "#{@test_dir}/#{base}"].compact
-                 else
-                   ["#{@test_dir}/#{base}"]
-                 end
+    fallbacks = primary.flat_map { |c| parent_fallback_candidates(c) }
 
-    fallbacks = candidates.flat_map { |c| parent_fallback_candidates(c) }.uniq
+    (primary + fallbacks + prefix_convention_candidates(stripped)).uniq
+  end
+
+  # Conventional roots that may hold tests: the mirrored root plus the common
+  # spec/unit, spec/lib (test/unit, test/lib) buckets.
+  def roots
+    [@test_dir, *CONVENTIONAL_SUBDIRS.map { |d| "#{@test_dir}/#{d}" }]
+  end
+
+  # Cross every conventional root with every layout variant of the stripped
+  # source path: the full mirror, the mirror with the leading gem-namespace
+  # dir dropped, and the bare basename. Full mirrors rank above dropped ones
+  # so a 1:1 layout always wins when present.
+  def mirror_candidates(stripped)
+    mirror_variants(stripped).flat_map do |variant|
+      roots.map { |root| "#{root}/#{variant}" }
+    end
+  end
 
-    candidates + fallbacks
+  def mirror_variants(stripped)
+    segments = stripped.split("/")
+    variants = [stripped]
+    variants << segments[1..].join("/") if segments.length > 1
+    variants << segments.last if segments.length > 2
+    variants.uniq
+  end
+
+  # Test::Unit / minitest gems frequently name files with a `test_` PREFIX
+  # (test/test_connection_pool.rb) instead of the mirrored `_test.rb` suffix.
+  # Only meaningful when resolving against the minitest suffix.
+  def prefix_convention_candidates(stripped)
+    return [] unless @test_suffix == MINITEST_SUFFIX
+
+    mirror_variants(stripped).flat_map do |variant|
+      dir, _, file = variant.rpartition("/")
+      name = file.delete_suffix(@test_suffix)
+      next [] if name.empty?
+
+      relative = dir.empty? ? "test_#{name}.rb" : "#{dir}/test_#{name}.rb"
+      roots.map { |root| "#{root}/#{relative}" }
+    end
   end
 
   def controller_to_request_test(stripped_path)

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "0.31.0"
+  VERSION = "0.33.0"
 end

data/lib/evilution.rb

@@ -157,6 +157,17 @@ module Evilution
     @in_isolated_worker = previous
   end
 
+  # Base directory for resolving project-relative paths. An isolated worker
+  # has chdir'd into a per-mutation sandbox (EV-wqxu / GH #1278), so callers
+  # in that context must anchor against PROJECT_ROOT rather than Dir.pwd —
+  # otherwise spec files, source eval __FILE__, and $LOAD_PATH entries
+  # resolve into the sandbox and break the run. In any other context (normal
+  # use, tests that intentionally chdir into a fixture project layout, etc.)
+  # the caller's Dir.pwd remains the truth.
+  def self.project_base_dir
+    in_isolated_worker? ? PROJECT_ROOT : Dir.pwd
+  end
+
   class Error < StandardError
     attr_reader :file
 

data/lib/tasks/stress.rake

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
+
+# RUN_STRESS lifts the default :stress exclusion in spec_helper. Set via a
+# prerequisite so it runs before the RSpec task, without polluting other tasks.
+task :stress_env do
+  ENV["RUN_STRESS"] = "1"
+end
+
+desc "Run parallel/isolation stress + load specs (tagged :stress, slow)"
+RSpec::Core::RakeTask.new(stress: :stress_env) do |t|
+  t.pattern = "spec/evilution/parallel/stress_spec.rb"
+  t.rspec_opts = "--tag stress"
+end

data/script/run_self_baseline

@@ -38,7 +38,7 @@ dirs.each do |dir|
   end
 
   log = File.join(LOG_DIR, "#{dir}.self.log")
-  cmd = [WRAPPER, "--strict", "--jobs=4", "--timeout=15", "--quiet-children", *files]
+  cmd = [WRAPPER, "--strict", "--jobs=4", "--timeout=15", "--quiet-children", "--isolation=fork", *files]
   puts "==> #{dir} (#{files.length} files)"
   pid = spawn(*cmd, out: log, err: %i[child out])
   Process.wait(pid)
@@ -53,7 +53,7 @@ toplevel_files = Dir.glob(File.join(ROOT, "lib", "evilution", "*.rb"))
 toplevel_files.reject! { |f| SKIP_FILES.include?(f) }
 unless toplevel_files.empty?
   log = File.join(LOG_DIR, "toplevel.self.log")
-  cmd = [WRAPPER, "--strict", "--jobs=4", "--timeout=15", "--quiet-children", *toplevel_files]
+  cmd = [WRAPPER, "--strict", "--jobs=4", "--timeout=15", "--quiet-children", "--isolation=fork", *toplevel_files]
   puts "==> toplevel (#{toplevel_files.length} files)"
   pid = spawn(*cmd, out: log, err: %i[child out])
   Process.wait(pid)