evilution 0.32.0 → 0.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc948250a218198fef7420e04ab49e5a2f8e01ff50ae279f5299bb85db07ab77
-  data.tar.gz: df6e3a2ea4ee5512f9c946f4df514f8a1a2df8308ac77236ceafa3de81b435d8
+  metadata.gz: 07051270c176d0d26e28c2978c6bfa2eb0d76dd2e6ba453387f9731f04a0d79b
+  data.tar.gz: 1562d91a064d05af5b6264c89eacf93077630bc09b4a149010d6e4e5514409ed
 SHA512:
-  metadata.gz: 43c08e6baa4904c1122d639c957cc1139c9e4760e3e38aed8664a70ff46388aab91b64924816739d4c7a9f00abb049f2da579c50f3b5a585c49b2175f3461dff
-  data.tar.gz: e30f5845c332781de9431c9a4238df1ac9048960d3ef36323dac0a8beaf2f5c5d56eb1d3132d618a7e076bb7547520286fc127347499b0b95640331e16912fb8
+  metadata.gz: 9957755214557a006e461cadd076d57b5c1d55536e9cec5105df1b1b37580150a6ff5fc8a33c816c0356a8e890eab1ac8e5fcfccac1acb6a46e18c76ba8ec909
+  data.tar.gz: 8a2a4000adbaf10f178cbed4cb117644d25bd27ec2730fb02024fa68b3cf8424181b0d5e45bbfbe53b3c9a9a37266e306de7592f16443d0d8545ad46f878f4af

data/.beads/interactions.jsonl

@@ -409,3 +409,15 @@
 {"id":"int-c7bcc360","kind":"field_change","created_at":"2026-05-31T03:12:47.029582311Z","actor":"Denis Kiselev","issue_id":"EV-6az9","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
 {"id":"int-fa3ade4f","kind":"field_change","created_at":"2026-05-31T08:47:32.000198989Z","actor":"Denis Kiselev","issue_id":"EV-d3av","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
 {"id":"int-b1831323","kind":"field_change","created_at":"2026-05-31T08:47:50.244781995Z","actor":"Denis Kiselev","issue_id":"EV-d7re","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Closed"}}
+{"id":"int-6325348d","kind":"field_change","created_at":"2026-06-05T17:09:56.549588702Z","actor":"Denis Kiselev","issue_id":"EV-rxob","extra":{"field":"status","new_value":"in_progress","old_value":"closed"}}
+{"id":"int-2cd0e23a","kind":"field_change","created_at":"2026-06-06T03:49:11.649710835Z","actor":"Denis Kiselev","issue_id":"EV-axze","extra":{"field":"priority","new_value":"1","old_value":"3"}}
+{"id":"int-586865ca","kind":"field_change","created_at":"2026-06-06T03:49:12.267581064Z","actor":"Denis Kiselev","issue_id":"EV-axze","extra":{"field":"priority","new_value":"2","old_value":"1"}}
+{"id":"int-c295efed","kind":"field_change","created_at":"2026-06-06T03:56:26.595461244Z","actor":"Denis Kiselev","issue_id":"EV-gl1e","extra":{"field":"status","new_value":"in_progress","old_value":"open"}}
+{"id":"int-552b93f8","kind":"field_change","created_at":"2026-06-06T06:34:06.544071647Z","actor":"Denis Kiselev","issue_id":"EV-cnx8","extra":{"field":"status","new_value":"in_progress","old_value":"open"}}
+{"id":"int-38e50f55","kind":"field_change","created_at":"2026-06-06T06:34:58.433491242Z","actor":"Denis Kiselev","issue_id":"EV-gl1e","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Merged via PR #1329"}}
+{"id":"int-121d6c46","kind":"field_change","created_at":"2026-06-06T07:31:53.274033616Z","actor":"Denis Kiselev","issue_id":"EV-cnx8","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Merged via PR #1331"}}
+{"id":"int-17dbc619","kind":"field_change","created_at":"2026-06-06T08:17:59.133451819Z","actor":"Denis Kiselev","issue_id":"EV-jwao","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Merged via PR #1333. Forward INT/TERM to worker process groups before parent dies; WorkerRegistry (lock-free COW pgid registry, signal-safe), register-before-isolate (race fix from review), unregister on reap. Specs + e2e green."}}
+{"id":"int-9eb0b37f","kind":"field_change","created_at":"2026-06-06T10:31:43.322237231Z","actor":"Denis Kiselev","issue_id":"EV-2sh8","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Merged via PR #1335. Mutation child setpgid(0,0) as own group leader; terminate_child group-kills via signal_tree(-pid + pid) on TERM/KILL ladder; sweeps blocking grandchildren on inner timeout. Specs green, memory:check PASS. Flaky-test review hardened (timeout 3s, atomic pid write)."}}
+{"id":"int-cdc02b29","kind":"field_change","created_at":"2026-06-06T15:19:26.153490037Z","actor":"Denis Kiselev","issue_id":"EV-dlnn","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Merged via PR #1344. Flaky /tmp glob replaced with parent-side sandbox capture (spy Dir.mktmpdir, assert the evilution-run dir gone after timeout). Deterministic, fork.rb untouched."}}
+{"id":"int-af4ca762","kind":"field_change","created_at":"2026-06-06T17:23:17.168065946Z","actor":"Denis Kiselev","issue_id":"EV-dwqw","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Merged via PR #1345. Real carrier was RSpec.configuration @preferred_options (color_mode getter reads it first); inner Runner.run --no-color force-merges color_mode=:off in place. StateGuard::ConfigurationState snapshots @preferred_options by dup + stream ivars and restores them; in-process example re-enabled. Visual dots green, suite 4881 green."}}
+{"id":"int-f7253919","kind":"field_change","created_at":"2026-06-07T04:14:56.864785049Z","actor":"Denis Kiselev","issue_id":"EV-z7f5","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Merged PR #1347 (master). opt1+2+3 + Copilot review fixes. Empirical 4-repro re-run remains under EV-rxob canary harness (the dep)."}}

data/.rubocop_todo.yml

@@ -12,6 +12,7 @@ Metrics/ClassLength:
     - "lib/evilution/isolation/fork.rb"
     - "lib/evilution/integration/minitest.rb"
     - "lib/evilution/mcp/mutate_tool.rb"
+    - "lib/evilution/parallel/work_queue/dispatcher.rb"
     - "lib/evilution/runner.rb"
     - "lib/evilution/runner/isolation_resolver.rb"
 

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 Versioning policy: see [docs/versioning.md](docs/versioning.md).
 
+## [0.33.0] - 2026-06-07
+
+### Added
+
+- **Auto spec-resolution now finds specs in non-mirrored test layouts (`spec/unit`, `spec/lib`, `test/unit`, `test/lib`) instead of scoring 0% out of the box** — when `--spec` is omitted, `Evilution::SpecResolver` previously only resolved tests that mirrored the `lib/` tree 1:1 (`lib/foo/bar.rb` → `spec/foo/bar_spec.rb`). Projects that park their suites under a `unit`/`lib` bucket (`spec/unit/foo/bar_spec.rb`, `test/unit/foo/bar_test.rb` — a very common convention) resolved nothing, so every mutation reported `:unresolved` and the score collapsed to 0.0 with no actionable signal. The resolver now layers conventional-subdir candidates (`CONVENTIONAL_SUBDIRS = %w[unit lib]`) and parent-directory fallbacks on top of the deterministic mirror, ranking full mirrors above dropped-namespace and bare-basename guesses. When mutations still cannot be paired with a spec, a new **unresolved-rate warning** surfaces in both CLI (`reporter/cli/line_formatters/unresolved_rate_warning.rb`) and HTML (`reporter/html/sections/unresolved_details.rb`) output with a best-guess suggestion per source file, so a high unresolved rate reads as a resolution problem to fix (pass `--spec`, adjust layout) rather than a silently meaningless 0%. Repros that went 0.0 → real scores out of the box: webmock, doorkeeper, concurrent-ruby (EV-z7f5, PR #1347, GH #1325)
+- **Opt-in parallel/isolation stress + load suite (`rake stress`) plus a weekly CI guardrail** — a new `:stress`-tagged spec (`spec/evilution/parallel/stress_spec.rb`) drives `Evilution::Parallel::WorkQueue` and `Evilution::Isolation::Fork` far past the per-class fixtures: 10k items at `-j8` with worker recycling, simultaneous worker-timeout and worker-death cascades (folding the EV-gl1e per-item-timeout recovery regression), deadline precision under scheduling churn, sustained-load RSS bounds, and hundreds of real forked mutation runs mixing fast and blocking children. It asserts the invariants that matter under load — correct ordered results, no deadlocks (every run is `Timeout`-wrapped), no zombie/unreaped workers (non-blocking `waitpid(WNOHANG)`), no FD leaks, bounded memory growth. Excluded from the default run; lifted by `RUN_STRESS=1` (set automatically by `rake stress`). A scheduled `.github/workflows/stress.yml` runs it weekly (Mondays 06:00 UTC) and on demand with CI-tuned scale knobs (`STRESS_JOBS`/`STRESS_ITEMS`/`STRESS_FORK_MUTS`/`STRESS_RUN_TIMEOUT`). The full-scale run surfaced no new defects — the EV-gl1e/EV-cnx8/EV-jwao/EV-2sh8 isolation hardening below holds under load (EV-axze, PR #1348, GH #861)
+
+### Fixed
+
+- **A single stuck or dead worker no longer aborts the entire parallel run** — `Evilution::Parallel::WorkQueue::Dispatcher` enforced timeouts with a coarse pool-wide watchdog: one mutation that blocked past `item_timeout` (e.g. a checkout-breaking mutation that stalls a child in `ConditionVariable#wait`) raised `"worker timed out after Ns"` as the run's `first_error` and tore down every worker, and a worker that exited unexpectedly (`handle_dead`) did the same. The dispatcher now tracks a **per-worker deadline**: it kills and recycles only the stuck worker, marks just that worker's in-flight item with a `WorkQueue::TIMED_OUT` / `DIED` sentinel, and continues the remaining work. `Strategy::Parallel` translates the sentinels into `:timeout` / `:error` `MutationResult`s. connection_pool jobs=4 (which previously whole-run-aborted) now completes with the stuck mutation scored `:timed_out` and a real non-zero score (EV-gl1e, PR #1329, GH #1324)
+- **Worker SIGKILL now reaps grandchild processes instead of orphaning them** — when the dispatcher SIGKILLed a stuck pool worker, any grandchildren the worker had forked (the per-mutation test subprocess and anything *it* spawned) were left orphaned to init, leaking processes across a long run. Each worker now makes itself a process-group leader (`Process.setpgid(pid, pid)` in `Worker.spawn`) and `Worker#kill` signals the whole group (`-pid`) with a single-pid fallback, so killing a worker takes its entire subtree down (EV-cnx8, PR #1331, GH #1327)
+- **Terminal interrupts (Ctrl-C) now forward to worker process groups instead of leaking them** — once workers ran in their own process groups (above), a SIGINT/SIGTERM to the evilution parent no longer reached the workers' groups, so an interrupted parallel run could leave workers and their mutation children alive. A new `WorkerRegistry` tracks live worker pgids; the `Runner` signal handler forwards the terminating signal to every registered group. The worker registers its pgid **before** `setpgid` to close a trap race where a signal could arrive after the child had changed groups but before the registry knew about it (EV-jwao, PR #1333, GH #1332)
+- **A mutation that blocks a grandchild no longer hangs the per-mutation timeout** — `Evilution::Isolation::Fork` makes the per-mutation child its own process-group leader (`Process.setpgid(0, 0)`) before running the test command, so when the mutation spawns a grandchild that blocks (or traps interrupts), the timeout's TERM → KILL ladder reaches the whole subtree and the child is bounded rather than wedged behind a blocking grandchild (EV-2sh8, PR #1335, GH #1330)
+- **Minitest / test-unit projects whose test helper is loaded via `require "test_helper"` no longer error every mutation with `LoadError`** — the mutation child did not place the project's test root on `$LOAD_PATH`, so a suite that does a bare `require "test_helper"` (the standard Minitest convention) raised `LoadError` and every mutation reported `:error`, collapsing the run. A new `Evilution::Integration::Loading::TestLoadPath` prepends the relevant test directories to `$LOAD_PATH` for the load, and restores it afterward; the Minitest and Test::Unit integrations both route their test-file loads through it. Repro: state_machines (EV-52hf, PR #1341, GH #1326)
+- **In-process isolation no longer leaks RSpec global configuration into the host process** — an `--isolation=in_process` run mutates `RSpec.configuration` while dispatching each mutation, and two of those fields (`color_mode` and `output_stream`) were left mutated after the run, bleeding RSpec's color setting and redirected output stream into the host process that invoked evilution. A new `ConfigurationState` strategy (wired into `StateGuard`) snapshots and restores the affected configuration fields around each in-process run, so the host's RSpec state is unchanged afterward (EV-dwqw, PR #1345/#1346, GH #1343)
+- **Flaky `fork_spec` sandbox-cleanup example decoupled from global `/tmp`** — the spec asserting that a child timeout cleans up its sandbox temp directory keyed off the shared `/tmp`, so concurrent activity made it intermittently fail. It now scopes to its own directory, removing the false negative (test-only) (EV-dlnn, PR #1344, GH #1342)
+
 ## [0.32.0] - 2026-05-31
 
 ### Added

data/README.md

@@ -375,7 +375,7 @@ Compatibility policy for the `1.x` gem line:
 | `unresolved` | No spec file resolved for the mutated source — **coverage gap, not a failure**. Use `--fallback-full-suite` to run the full suite instead. | excluded |
 | `unparseable` | Mutated source failed to parse (e.g. dangling heredoc opener after `method_body_replacement`). Short-circuited — never executed. | excluded |
 
-Unresolved mutations indicate a missing test mapping — the file has no corresponding test file that the resolver could find (for example, an RSpec `_spec.rb` file or a Minitest `_test.rb` file, depending on configuration). They are reported separately so you can act on them (add a test, adjust test naming, or opt in to the full-suite fallback) without inflating the error count.
+Unresolved mutations indicate a missing test mapping — the file has no corresponding test file that the resolver could find (for example, an RSpec `_spec.rb` file or a Minitest `_test.rb` file, depending on configuration). The resolver searches both the `lib/`-mirrored path and common non-mirrored buckets (`spec/unit`, `spec/lib`, `test/unit`, `test/lib`), so a high unresolved rate usually means a genuinely missing or unconventionally-placed test; a run that leaves many mutations unresolved prints an unresolved-rate warning with a best-guess spec path per source file. They are reported separately so you can act on them (add a test, adjust test naming, pass `--spec`, or opt in to the full-suite fallback) without inflating the error count.
 
 ## Mutation Operators (74 total)
 

data/docs/integrations.md

@@ -76,6 +76,21 @@ For controllers, the resolver tries the request-spec / integration-test
 location first, then falls back to the controller-spec / controller-test
 location.
 
+### Non-mirrored layouts
+
+Many projects do not mirror the `lib/` tree 1:1 — they park suites under a
+`unit` or `lib` bucket (`spec/unit/foo/bar_spec.rb`, `test/unit/foo/bar_test.rb`,
+`spec/lib/...`, `test/lib/...`). On top of the deterministic mirror above, the
+resolver also tries these conventional sub-directories plus parent-directory
+fallbacks, ranking the full mirror highest and bare-basename guesses lowest. So
+a `spec/unit`-style layout resolves out of the box without `--spec`.
+
+If mutations still cannot be paired with a spec, the run prints an
+**unresolved-rate warning** (and an "unresolved" section in HTML output) with a
+best-guess candidate per source file — so a high unresolved count reads as a
+resolution problem to fix (pass `--spec`, or adjust the layout) rather than a
+silently meaningless 0% score.
+
 ## Suggest-tests caveat
 
 The `--suggest-tests` mode emits ready-to-paste test snippets for survived

data/docs/isolation.md

@@ -130,6 +130,21 @@ On by default; toggle with `--[no-]canary` or `canary: true|false` in
 `.evilution.yml`. The canary mirrors the configured `--isolation` so
 isolation-specific defects are caught too.
 
+## Parallel run resilience (`--jobs N`)
+
+Under `--jobs N` a stuck or crashed worker no longer takes the whole run down.
+The work-queue dispatcher tracks a per-worker deadline: if one mutation blocks
+past its timeout (e.g. a mutation that wedges a child in `ConditionVariable#wait`)
+or a worker exits unexpectedly, only that worker is killed and recycled, its
+single in-flight mutation is recorded as `:timeout` / `:error`, and the run
+continues with the remaining work. A single pathological mutation costs you one
+result, not the entire run.
+
+Each worker is also its own process-group leader, so killing a worker reaps the
+mutation subprocess and any grandchildren it spawned rather than orphaning them,
+and a terminal interrupt (Ctrl-C) is forwarded to every worker group — an
+aborted parallel run leaves no stray worker or mutation processes behind.
+
 ## Related flags
 
 - `--timeout N` sets the per-mutation time limit. Under `fork`, this drives

data/lib/evilution/baseline.rb

@@ -113,11 +113,18 @@ class Evilution::Baseline
     warned = Set.new
     subjects.map do |s|
       resolved = @spec_resolver.call(s.file_path)
-      if resolved.nil? && warned.add?(s.file_path)
-        warn "[evilution] No matching test found for #{s.file_path}, running full suite. " \
-             "Use --spec to specify the test file."
-      end
+      warn_no_matching_test(s.file_path) if resolved.nil? && warned.add?(s.file_path)
       resolved || @fallback_dir
     end.uniq
   end
+
+  def warn_no_matching_test(file_path)
+    suggestion = @spec_resolver.suggest(file_path)
+    hint = if suggestion
+             "Pass --spec #{suggestion} (best guess) or the correct test file."
+           else
+             "Use --spec to specify the test file."
+           end
+    warn "[evilution] No matching test found for #{file_path}, running full suite. #{hint}"
+  end
 end

data/lib/evilution/integration/loading/test_load_path.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Mirrors `ruby -Itest` / `-Ispec` for in-process test loading.
+#
+# evilution loads resolved test files with Kernel#load instead of shelling out,
+# so the `-Itest` shown in the displayed command string is never actually
+# applied to $LOAD_PATH. Minitest and Test::Unit suites near-universally
+# `require "test_helper"` (which the suite's own runner satisfies via -Itest);
+# without the test root on $LOAD_PATH that bare require raises LoadError and
+# every mutation errors with score 0.0 (EV-52hf / GH #1326).
+#
+# Anchors against Evilution.project_base_dir, which resolves to PROJECT_ROOT
+# inside an isolated worker (EV-wqxu / GH #1278) and Dir.pwd otherwise, so the
+# same call works on both the baseline (parent) and mutation (child) paths.
+module Evilution::Integration::Loading::TestLoadPath
+  ROOT_NAMES = %w[test spec].freeze
+
+  module_function
+
+  # Prepend every relevant test directory to $LOAD_PATH (idempotently).
+  # Iterate in reverse so the first entry from #dirs_for ends up frontmost,
+  # preserving its order (mirrors how `ruby -Ia -Ib` lands a before b).
+  def add!(files, base: Evilution.project_base_dir)
+    dirs_for(files, base).reverse_each do |dir|
+      $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+    end
+  end
+
+  # The directories to put on $LOAD_PATH for the given resolved test files:
+  # the conventional test/ and spec/ roots under base, each file's own
+  # directory, and the topmost test/spec ancestor of each file (covers nested
+  # layouts like test/unit, spec/lib, spec/unit). Existing directories only,
+  # and only those inside the project base -- never a broad outside-project dir
+  # (e.g. a /tmp test file), which would over-widen $LOAD_PATH for the whole
+  # process (the baseline runs in the long-lived parent).
+  def dirs_for(files, base)
+    base = File.expand_path(base)
+    dirs = conventional_roots(base)
+    Array(files).each do |file|
+      file_dir = File.dirname(File.expand_path(file, base))
+      dirs << file_dir
+      root = root_ancestor(file_dir, base)
+      dirs << root if root
+    end
+    dirs.uniq.select { |dir| File.directory?(dir) && within?(dir, base) }
+  end
+
+  def within?(dir, base)
+    dir == base || dir.start_with?("#{base}/")
+  end
+
+  def conventional_roots(base)
+    ROOT_NAMES.map { |name| File.join(base, name) }
+  end
+
+  # Walk from `dir` up to `base`, returning the highest ancestor whose basename
+  # is a conventional test root (test/spec). Highest, so test/unit/foo_test.rb
+  # yields `test` (matching -Itest), not the intermediate test/unit.
+  def root_ancestor(dir, base)
+    base = File.expand_path(base)
+    found = nil
+    current = File.expand_path(dir)
+    loop do
+      found = current if ROOT_NAMES.include?(File.basename(current))
+      break if current == base
+
+      parent = File.dirname(current)
+      break if parent == current
+
+      current = parent
+    end
+    found
+  end
+end

data/lib/evilution/integration/minitest.rb

@@ -3,6 +3,7 @@
 require "stringio"
 require_relative "base"
 require_relative "minitest_crash_detector"
+require_relative "loading/test_load_path"
 require_relative "../spec_resolver"
 require_relative "../spec_selector"
 
@@ -18,7 +19,9 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     require "stringio"
     stub_autorun!
     ::Minitest::Runnable.runnables.clear
-    baseline_test_files(test_file).each { |f| load(File.expand_path(f)) }
+    files = baseline_test_files(test_file)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
+    files.each { |f| load(File.expand_path(f)) }
     run_baseline_minitest
   end
 
@@ -128,6 +131,7 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
   end
 
   def execute_minitest(mutation, files, command)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
     files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
 
     detector = reset_crash_detector

data/lib/evilution/integration/rspec/state_guard/configuration_state.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+
+# Restores the RSpec.configuration state that ::RSpec::Core::Runner.run mutates
+# on the shared singleton during an in-process mutation run (EV-dwqw / GH #1343).
+#
+# The visible symptom was every SUBSEQUENT host example rendering its progress
+# dots without color (white instead of green). Root cause: the run's args carry
+# "--no-color", and ConfigurationOptions#configure applies it via
+# Configuration#force, which does `@preferred_options.merge!(:color_mode => :off)`
+# IN PLACE. `Configuration#color_mode` reads `@preferred_options.fetch(:color_mode)`
+# first, so the host's color setting stays :off for the rest of the process.
+# Separately, Runner#setup points `output_stream`/`error_stream` (attr_writers,
+# i.e. the @output_stream/@error_stream ivars) at the run's throwaway StringIOs.
+#
+# Forked runs never leak these (the mutation happens in a child that dies); only
+# the in-process isolation path mutates the host's own configuration.
+#
+# @preferred_options is mutated in place, so it is snapshotted by DUP and put
+# back by replacing the ivar; the stream ivars are reassigned during the run,
+# so capturing the original references is enough.
+class Evilution::Integration::RSpec::StateGuard::ConfigurationState
+  PREFERRED_OPTIONS = :@preferred_options
+  STREAM_IVARS = %i[@output_stream @error_stream].freeze
+  ALL_IVARS = [PREFERRED_OPTIONS, *STREAM_IVARS].freeze
+
+  # configuration is injectable for isolated unit testing; production uses the
+  # shared RSpec.configuration singleton.
+  def initialize(configuration: nil)
+    @configuration = configuration
+  end
+
+  def snapshot
+    config = configuration
+    state = {}
+    capture_preferred_options(config, state)
+    STREAM_IVARS.each do |ivar|
+      state[ivar] = config.instance_variable_get(ivar) if config.instance_variable_defined?(ivar)
+    end
+    state
+  end
+
+  # Restore exactly the pre-run state: ivars present at snapshot get their value
+  # back; ivars created by the run but absent before are removed, so nothing the
+  # run introduced can leak into the host either.
+  def release(captured)
+    return unless captured
+
+    config = configuration
+    ALL_IVARS.each do |ivar|
+      if captured.key?(ivar)
+        config.instance_variable_set(ivar, captured[ivar])
+      elsif config.instance_variable_defined?(ivar)
+        config.remove_instance_variable(ivar)
+      end
+    end
+  end
+
+  private
+
+  def configuration
+    @configuration || ::RSpec.configuration
+  end
+
+  def capture_preferred_options(config, state)
+    return unless config.instance_variable_defined?(PREFERRED_OPTIONS)
+
+    value = config.instance_variable_get(PREFERRED_OPTIONS)
+    state[PREFERRED_OPTIONS] = value.is_a?(Hash) ? value.dup : value
+  end
+end

data/lib/evilution/integration/rspec/state_guard/configuration_streams.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+require_relative "internals"
+
+# Restores the RSpec.configuration fields that ::RSpec::Core::Runner.run mutates
+# on the shared singleton during an in-process mutation run (EV-dwqw / GH #1343):
+#
+#   - @color_mode    -- the run's args carry "--no-color", flipping it to :off,
+#                       which makes every SUBSEQUENT host example render its
+#                       progress dots without color (white instead of green).
+#   - @output_stream -- Runner#setup swaps it to the run's StringIO whenever the
+#                       host's was $stdout.
+#   - @error_stream  -- likewise pointed at the run's StringIO.
+#
+# Forked runs never leak these (the mutation happens in a child that dies), but
+# the in-process isolation path mutates the host's own configuration. Restore by
+# writing the ivars directly: configuration#output_stream= is guarded (it warns
+# and no-ops once a reporter exists), so the public setter cannot put it back.
+class Evilution::Integration::RSpec::StateGuard::ConfigurationStreams
+  IVARS = %i[@color_mode @output_stream @error_stream].freeze
+
+  def snapshot
+    config = ::RSpec.configuration
+    IVARS.each_with_object({}) do |ivar, acc|
+      acc[ivar] = config.instance_variable_get(ivar) if config.instance_variable_defined?(ivar)
+    end
+  end
+
+  # Restore exactly the pre-run state: ivars present at snapshot get their value
+  # back; ivars that were absent before but created by the run are removed, so a
+  # newly-defined ivar can't leak into the host either.
+  def release(captured)
+    return unless captured
+
+    config = ::RSpec.configuration
+    IVARS.each do |ivar|
+      if captured.key?(ivar)
+        config.instance_variable_set(ivar, captured[ivar])
+      elsif config.instance_variable_defined?(ivar)
+        config.remove_instance_variable(ivar)
+      end
+    end
+  end
+end

data/lib/evilution/integration/rspec/state_guard.rb

@@ -7,6 +7,7 @@ require_relative "state_guard/world_sources_by_path"
 require_relative "state_guard/world_filtered_examples"
 require_relative "state_guard/reporter_arrays"
 require_relative "state_guard/example_groups_constants"
+require_relative "state_guard/configuration_state"
 
 class Evilution::Integration::RSpec::StateGuard
   DEFAULT_STRATEGIES = [
@@ -15,7 +16,8 @@ class Evilution::Integration::RSpec::StateGuard
     WorldSourcesByPath.new,
     WorldFilteredExamples.new,
     ReporterArrays.new,
-    ExampleGroupsConstants.new
+    ExampleGroupsConstants.new,
+    ConfigurationState.new
   ].freeze
 
   def initialize(strategies: DEFAULT_STRATEGIES)

data/lib/evilution/integration/test_unit.rb

@@ -2,6 +2,7 @@
 
 require_relative "base"
 require_relative "test_unit_crash_detector"
+require_relative "loading/test_load_path"
 require_relative "../spec_resolver"
 require_relative "../spec_selector"
 
@@ -40,8 +41,10 @@ class Evilution::Integration::TestUnit < Evilution::Integration::Base
     require_relative "test_unit/subject_class_registry"
     require_relative "test_unit/dispatcher"
     FrameworkLoader.new.call
+    files = baseline_test_files(test_file)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
     new_classes = SubjectClassRegistry.newly_loaded do
-      baseline_test_files(test_file).each { |f| load(File.expand_path(f)) }
+      files.each { |f| load(File.expand_path(f)) }
     end
     Dispatcher.call(new_classes, name: "evilution baseline").passed?
   end
@@ -89,9 +92,7 @@ class Evilution::Integration::TestUnit < Evilution::Integration::Base
   end
 
   def execute_test_unit(files, command)
-    new_classes = SubjectClassRegistry.newly_loaded do
-      files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
-    end
+    new_classes = load_test_classes(files)
     return ResultBuilder.no_tests_ran(command) if Dispatcher.test_method_count(new_classes).zero?
 
     detector = reset_crash_detector
@@ -100,6 +101,13 @@ class Evilution::Integration::TestUnit < Evilution::Integration::Base
     ResultBuilder.call(passed: result.passed?, command: command, detector: detector)
   end
 
+  def load_test_classes(files)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
+    SubjectClassRegistry.newly_loaded do
+      files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
+    end
+  end
+
   # Test::Unit has no public registry-clear analogous to
   # Minitest::Runnable.runnables.clear. SubjectClassRegistry's newly_loaded
   # block scopes each dispatch to classes loaded in *this* round, so stale

data/lib/evilution/isolation/fork.rb

@@ -48,6 +48,7 @@ class Evilution::Isolation::Fork
 
   def fork_child(read_io, write_io, sandbox_dir, mutation, test_command)
     ::Process.fork do
+      isolate_into_own_process_group
       ENV["TMPDIR"] = sandbox_dir
       # Path-relativizing mutations (e.g. File.join(dir, name) -> name) would
       # otherwise write into the parent's CWD (typically the repo root) and
@@ -70,6 +71,21 @@ class Evilution::Isolation::Fork
     end
   end
 
+  # EV-2sh8 / GH #1330: make the mutation child its own process-group leader as
+  # its very first act, before it runs test_command (which may fork blocking
+  # grandchildren -- e.g. connection_pool / ractor / thread subject specs).
+  # Grandchildren then inherit this group, so terminate_child can group-kill the
+  # whole subtree on timeout. Without it, a blocking grandchild orphans to init
+  # and survives the rest of the run -- the inner path never SIGKILLs the worker,
+  # so EV-cnx8's outer process-group kill never sweeps it. Done child-side (not
+  # parent-side as in Worker) because the per-mutation timeout fires seconds
+  # later, long after this line has run, so no fork-before-setpgid race exists.
+  def isolate_into_own_process_group
+    ::Process.setpgid(0, 0)
+  rescue SystemCallError
+    nil
+  end
+
   def cleanup_resources(read_io, write_io, pid, sandbox_dir)
     read_io.close unless read_io.nil?
     write_io.close unless write_io.nil?
@@ -216,7 +232,7 @@ class Evilution::Isolation::Fork
   end
 
   def terminate_child(pid)
-    Evilution::ProcessCleanup.safe_kill("TERM", pid)
+    signal_tree("TERM", pid)
     _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
     return if status
 
@@ -224,10 +240,20 @@ class Evilution::Isolation::Fork
     _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
     return if status
 
-    Evilution::ProcessCleanup.safe_kill("KILL", pid)
+    signal_tree("KILL", pid)
     Evilution::ProcessCleanup.safe_wait(pid)
   end
 
+  # Signal the child's whole process group (-pid) to sweep any grandchildren it
+  # forked, then the bare pid as a fallback for the case where setpgid failed
+  # (no group exists, so the group signal is a harmless Errno::ESRCH). Only the
+  # leader pid is reaped here -- group-killed grandchildren are not our direct
+  # children, so init reaps them once they die.
+  def signal_tree(sig, pid)
+    Evilution::ProcessCleanup.safe_kill(sig, -pid)
+    Evilution::ProcessCleanup.safe_kill(sig, pid)
+  end
+
   def classify_status(result)
     return :timeout if result[:timeout]
     return :killed if result[:test_crashed]

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/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

@@ -178,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
@@ -226,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.32.0"
+  VERSION = "0.33.0"
 end

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 0.32.0
+  version: 0.33.0
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-31 00:00:00.000000000 Z
+date: 2026-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -223,6 +223,7 @@ files:
 - lib/evilution/integration/loading/redefinition_recovery.rb
 - lib/evilution/integration/loading/source_evaluator.rb
 - lib/evilution/integration/loading/syntax_validator.rb
+- lib/evilution/integration/loading/test_load_path.rb
 - lib/evilution/integration/minitest.rb
 - lib/evilution/integration/minitest_crash_detector.rb
 - lib/evilution/integration/rspec.rb
@@ -232,6 +233,8 @@ files:
 - lib/evilution/integration/rspec/framework_loader.rb
 - lib/evilution/integration/rspec/result_builder.rb
 - lib/evilution/integration/rspec/state_guard.rb
+- lib/evilution/integration/rspec/state_guard/configuration_state.rb
+- lib/evilution/integration/rspec/state_guard/configuration_streams.rb
 - lib/evilution/integration/rspec/state_guard/example_groups_constants.rb
 - lib/evilution/integration/rspec/state_guard/internals.rb
 - lib/evilution/integration/rspec/state_guard/object_space_example_groups.rb
@@ -371,6 +374,7 @@ files:
 - lib/evilution/parallel/work_queue/validators/positive_int.rb
 - lib/evilution/parallel/work_queue/worker.rb
 - lib/evilution/parallel/work_queue/worker/loop.rb
+- lib/evilution/parallel/work_queue/worker_registry.rb
 - lib/evilution/parallel/work_queue/worker_stat.rb
 - lib/evilution/parallel_db_warning.rb
 - lib/evilution/process_cleanup.rb
@@ -394,6 +398,7 @@ files:
 - lib/evilution/reporter/cli/line_formatters/result_line.rb
 - lib/evilution/reporter/cli/line_formatters/score.rb
 - lib/evilution/reporter/cli/line_formatters/truncation_notice.rb
+- lib/evilution/reporter/cli/line_formatters/unresolved_rate_warning.rb
 - lib/evilution/reporter/cli/metrics_block.rb
 - lib/evilution/reporter/cli/pct.rb
 - lib/evilution/reporter/cli/section.rb
@@ -484,6 +489,7 @@ files:
 - lib/evilution/temp_dir_tracker.rb
 - lib/evilution/version.rb
 - lib/tasks/memory_check.rake
+- lib/tasks/stress.rake
 - schema/evilution.config.schema.json
 - script/build_runtime_snapshot
 - script/memory_check