evilution 0.31.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 923190b1b1b35a2e5bad46d1866a0a001bcd6afa48d208f962e73d73af6e7577
-  data.tar.gz: 76edef4423129342ce415bead32545894927070d042f615294d5b04df2c6b5ec
+  metadata.gz: dc948250a218198fef7420e04ab49e5a2f8e01ff50ae279f5299bb85db07ab77
+  data.tar.gz: df6e3a2ea4ee5512f9c946f4df514f8a1a2df8308ac77236ceafa3de81b435d8
 SHA512:
-  metadata.gz: ff3ec8345986e7ad9b51e7a7ec75ed3b2acbb95eb00c11d1edd3ca0c41163b7a24fa8ba68e82e941608644c4075f50a2734c1c1ee6787ac48f794ae47bfda8ae
-  data.tar.gz: 826763c5a82048db39a81a9343f586aac488ecf1910d56bc086456cb5dbe7ee975a6c4de9651ee87f7210a9f26635599db347ee02c6d6ec43623caa151cd5e14
+  metadata.gz: 43c08e6baa4904c1122d639c957cc1139c9e4760e3e38aed8664a70ff46388aab91b64924816739d4c7a9f00abb049f2da579c50f3b5a585c49b2175f3461dff
+  data.tar.gz: e30f5845c332781de9431c9a4238df1ac9048960d3ef36323dac0a8beaf2f5c5d56eb1d3132d618a7e076bb7547520286fc127347499b0b95640331e16912fb8

data/.beads/interactions.jsonl

@@ -393,3 +393,19 @@
 {"id":"int-4ea24fb5","kind":"field_change","created_at":"2026-05-16T16:04:54.395246914Z","actor":"Denis Kiselev","issue_id":"EV-s24s","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Already fixed — both named specs (unparseable_short_circuit_spec.rb, neutralization_integration_spec.rb) pass and destructure via execution.results. Stale in_progress; syncing."}}
 {"id":"int-8b699158","kind":"field_change","created_at":"2026-05-16T17:22:07.345408768Z","actor":"Denis Kiselev","issue_id":"EV-kcuf","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Proof-of-life canary implemented + merged. Runner::Canary runs a synthetic unobservable mutation at session start; aborts if not scored :survived. --[no-]canary flag, config.canary default true."}}
 {"id":"int-e4dcc2b3","kind":"field_change","created_at":"2026-05-27T04:19:00.738936734Z","actor":"Denis Kiselev","issue_id":"EV-qbd6","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Fix landed on master in commit 0f1781f (require 'bundler/setup' at bin/evilution-self:16). Verified 2026-05-27: crash dir lib/evilution/result/*.rb scores 91.11% (744 muts, 656 killed, 64 survived, 24 equivalent, 0 errors); canary passes; dual-runtime harness measures crash dirs again."}}
+{"id":"int-4cb27d5a","kind":"field_change","created_at":"2026-05-28T06:42:48.564599548Z","actor":"Denis Kiselev","issue_id":"EV-pyx6","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Fix merged on master in commit 72b43a3 (PR #1292). Added Evilution.project_base_dir helper + anchored spec/ via Evilution.project_base_dir in framework_loader.rb and baseline_runner.rb. Verified 2026-05-28: bin/evilution-self run lib/evilution/config/env_loader.rb scores 94.59% (was 0 before fix). 4705 examples pass, rubocop clean."}}
+{"id":"int-4cd16cba","kind":"field_change","created_at":"2026-05-29T04:54:00.815774086Z","actor":"Denis Kiselev","issue_id":"EV-8tmc","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Partial fix landed in commit 525787b: 18 of 20 lib/ subdirs now measurable (was 11/20). Two follow-up causes diagnosed and addressed: (1) auto-isolation picking in_process for non-Rails projects + RSpec swallowing Timeout::Error per-example, fixed by script using --isolation=fork explicitly; (2) ChildOutput log_dir relative-path bug under EV-wqxu sandbox CWD, fixed by absolutizing in runner.rb#configure_child_output. Remaining 2 dirs (parallel + toplevel) hang via different root cause — grandchild fork leak — tracked separately as EV-dgjv (GH #1295)."}}
+{"id":"int-991e5acf","kind":"field_change","created_at":"2026-05-30T15:56:24.341278813Z","actor":"Denis Kiselev","issue_id":"EV-auk5","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-df2bd661","kind":"field_change","created_at":"2026-05-30T15:56:24.686504141Z","actor":"Denis Kiselev","issue_id":"EV-9d62","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-6a1dc0ce","kind":"field_change","created_at":"2026-05-30T15:56:25.04815512Z","actor":"Denis Kiselev","issue_id":"EV-unar","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-defdc095","kind":"field_change","created_at":"2026-05-30T15:56:25.406639346Z","actor":"Denis Kiselev","issue_id":"EV-04sc","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-bc5a7747","kind":"field_change","created_at":"2026-05-30T17:33:33.191722982Z","actor":"Denis Kiselev","issue_id":"EV-8qiy","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-796e3efc","kind":"field_change","created_at":"2026-05-30T17:33:34.539604057Z","actor":"Denis Kiselev","issue_id":"EV-uv11","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-5fb67d2b","kind":"field_change","created_at":"2026-05-30T17:46:39.956899342Z","actor":"Denis Kiselev","issue_id":"EV-bcjp","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-6ba88696","kind":"field_change","created_at":"2026-05-30T17:59:44.432841837Z","actor":"Denis Kiselev","issue_id":"EV-aqxd","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-34eb133e","kind":"field_change","created_at":"2026-05-31T02:20:26.61836178Z","actor":"Denis Kiselev","issue_id":"EV-vumz","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-9527af14","kind":"field_change","created_at":"2026-05-31T02:47:48.910182696Z","actor":"Denis Kiselev","issue_id":"EV-zhqc","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-dfe331ef","kind":"field_change","created_at":"2026-05-31T02:59:12.044281579Z","actor":"Denis Kiselev","issue_id":"EV-akt2","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"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"}}

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 Versioning policy: see [docs/versioning.md](docs/versioning.md).
 
+## [0.32.0] - 2026-05-31
+
+### Added
+
+- **`--integration test-unit` runs mutations against projects whose suites use the `test-unit` gem** — Rails projects that `require "test/unit/rails/test_help"` make `ActiveSupport::TestCase` inherit from `Test::Unit::TestCase`, and the existing Minitest integration could not dispatch them (`Minitest::Runnable.runnables` is empty because the test classes are not Minitest runnables at all). A dedicated `Evilution::Integration::TestUnit` orchestrator now wires a framework loader (disables the `Test::Unit::AutoRunner` at_exit handler so it does not fire on evilution exit), a subject-class registry (diffs `Test::Unit::TestCase` descendants across `load` to scope each mutation to freshly-loaded suites without a public registry-clear API), a dispatcher (`Test::Unit::UI::Console::TestRunner` with output captured to a `StringIO`), a spec resolver (`test/foo_test.rb` convention, matching Minitest), and a result builder shaping the `passed`/`test_crashed`/`no_tests_ran`/`unresolved` hashes that `classify_status` consumes. `Evilution::Integration::TestUnitCrashDetector` mirrors the Minitest analogue, distinguishing `Test::Unit::Failure` (assertion) from `Test::Unit::Error` (exception/crash) via `TestResult.add_listener(FAULT, ...)`. CLI accepts both `--integration test-unit` and `--integration test_unit`; the MCP `evilution-mutate` tool advertises `test-unit` in its JSON schema enum. Kaminari canary (`kaminari-core/lib/kaminari/models/page_scope_methods.rb`) now scores 63.60% (272 mutations dispatched) where 0.30.x scored 0.00% with the Minitest integration. See [docs/integrations.md](docs/integrations.md). Suggest-tests templates for test-unit are not yet implemented; runs with `--suggest-tests --integration test-unit` fall back to the generic operator-level phrasing (EV-d7re epic + sub-beads EV-8qiy/EV-uv11/EV-bcjp/EV-aqxd/EV-vumz/EV-zhqc/EV-akt2/EV-6az9/EV-d3av, PRs #1314/#1315/#1316/#1318/#1320/#1321, GH #1267)
+
+### Fixed
+
+- **Pool workers no longer hang indefinitely in `Process.wait` when a per-mutation child writes a payload but does not exit promptly** — `Evilution::Isolation::Fork#reap_and_decode` called unbounded `Process.wait(pid)` after reading a length-prefixed payload from the marshal pipe. If the per-mutation child had written the payload but was still stuck in `execute_in_child` waiting on a subject grandchild the mutation broke (or a grandchild had written garbage bytes that looked like a valid header+body to the parent's inherited write fd), the pool worker blocked forever; the per-mutation timeout had no effect because `wait_for_result` had already returned. `Evilution::Parallel::WorkQueue::Dispatcher`'s `item_timeout` then fired `"worker timed out after 30s"` and SIGKILLed the pool worker, leaving the per-mutation child orphaned to init. `reap_and_decode` now bounds the wait by `REAP_DEADLINE = 1.0`s and falls through to the TERM → GRACE_PERIOD → KILL → safe_wait ladder when the child has not exited, so a stuck child takes ~3s worst-case instead of indefinite. Previously-unmeasurable parallel/ + toplevel/ self-baseline directories (parallel/work_queue.rb, parallel/work_queue/dispatcher.rb, parallel/work_queue/worker.rb, isolation/, toplevel) now all produce real summaries (EV-dgjv, PR #1296, GH #1295)
+- **`script/run_self_baseline` toplevel batch invocation now passes `--isolation=fork`** — every subdir invocation explicitly passed `--isolation=fork`, but the trailing toplevel batch (`lib/evilution/*.rb` files) omitted it. Default isolation auto-picked in_process for the non-Rails self-mutation, which (combined with RSpec's per-example `Timeout::Error` swallow) caused the toplevel batch to hit dispatcher item_timeout and report `NO_SUMMARY`. The toplevel cmd now matches the per-subdir cmd, so all 20 self-baseline dirs are measurable (EV-dgjv, PR #1296, GH #1295)
+
 ## [0.31.0] - 2026-05-27
 
 ### Added

data/README.md

@@ -104,10 +104,10 @@ Every command, subcommand, and flag listed in this section is part of evilution'
 | `--[no-]canary`              | Boolean | _(enabled)_  | Run a proof-of-life synthetic mutation at session start; abort the run if the pipeline misreports it. Catches misconfigured isolation, broken autoload, and reporter-plugin eviction before any real score is produced. Pass `--no-canary` to skip (e.g. CI speed, or when the canary itself is the thing under test). |
 | `--fail-fast [N]`            | Integer | _(none)_     | Stop after N surviving mutants (default 1 if no value given). |
 | `-v`, `--verbose`            | Boolean | false        | Verbose output with RSS memory and GC stats per phase and per mutation; also prints error class, message, and first 5 backtrace lines for errored mutations. |
-| `--suggest-tests`            | Boolean | false        | Generate concrete test code in suggestions (RSpec or Minitest, based on `--integration`). |
+| `--suggest-tests`            | Boolean | false        | Generate concrete test code in suggestions (RSpec or Minitest, based on `--integration`; falls back to generic phrasing for `test-unit`). |
 | `-q`, `--quiet`              | Boolean | false        | Suppress output.                                   |
 | `--stdin`                    | Boolean | false        | Read target file paths from stdin (one per line).  |
-| `--integration NAME`         | String  | `rspec`      | Test framework integration: `rspec` or `minitest`.  |
+| `--integration NAME`         | String  | `rspec`      | Test framework integration: `rspec`, `minitest`, or `test-unit`. See [docs/integrations.md](docs/integrations.md). |
 | `--[no-]incremental`         | Boolean | false        | Cache killed/timeout results; skip unchanged mutations on re-runs. Pass `--no-incremental` to override `incremental: true` from the config file for one invocation (e.g. cold-cache debugging). Last flag wins when both are given. |
 | `--save-session`             | Boolean | false        | Persist results as timestamped JSON under `.evilution/results/`. |
 | `--no-progress`              | Boolean | _(enabled)_  | Disable the TTY progress bar.                      |
@@ -169,7 +169,7 @@ schema_version: 1            # opts into strict validation (rejects unknown keys
 # timeout: 30              # seconds per mutation
 # format: text             # text | json | html
 # min_score: 0.0           # 0.0–1.0
-# integration: rspec       # test framework: rspec, minitest
+# integration: rspec       # test framework: rspec, minitest, test_unit
 # suggest_tests: false     # concrete test code in suggestions (matches integration)
 # save_session: false      # persist results under .evilution/results/
 # isolation: auto          # auto | fork | in_process (auto selects fork for Rails)
@@ -213,7 +213,7 @@ All keys recognised under `schema_version: 1`:
 | `format`                     | String                        | `text`                                 | Output format: `text`, `json`, `html`.                                                                                                   |
 | `target`                     | String / null                 | `null`                                 | Filter expression: method (`Foo#bar`), class (`Foo`), namespace (`Foo*`), descendants (`descendants:Foo`), source glob (`source:**/*.rb`). |
 | `min_score`                  | Float                         | `0.0`                                  | Minimum mutation score (0.0–1.0) for exit code 0.                                                                                        |
-| `integration`                | String                        | `rspec`                                | Test framework: `rspec` or `minitest`.                                                                                                   |
+| `integration`                | String                        | `rspec`                                | Test framework: `rspec`, `minitest`, or `test_unit`.                                                                                     |
 | `verbose`                    | Boolean                       | `false`                                | Verbose output (RSS/GC stats per phase, error details for errored mutations).                                                            |
 | `quiet`                      | Boolean                       | `false`                                | Suppress output.                                                                                                                         |
 | `jobs`                       | Integer                       | `1`                                    | Number of parallel workers.                                                                                                              |
@@ -517,7 +517,7 @@ These fields are added in addition to the existing `operator`, `file`, `line`, `
 
 The `evilution-mutate` tool accepts a `suggest_tests` boolean parameter (default: `false`). When enabled, survived mutation suggestions contain concrete test code that an agent can drop into a test file, instead of static description text. It currently generates RSpec-style suggestions (`it`/`expect` blocks).
 
-Pass `suggest_tests: true` in the `evilution-mutate` call to activate this mode. The CLI also supports `--suggest-tests`; when using the CLI, generated suggestions match the `--integration` setting (RSpec `it`/`expect` blocks or Minitest `def test_`/`assert_equal` methods).
+Pass `suggest_tests: true` in the `evilution-mutate` call to activate this mode. The CLI also supports `--suggest-tests`; when using the CLI, generated suggestions match the `--integration` setting (RSpec `it`/`expect` blocks or Minitest `def test_`/`assert_equal` methods). Concrete templates for `test-unit` are not yet implemented — `test-unit` runs fall back to generic suggestion text.
 
 ### Project Config File
 
@@ -532,7 +532,7 @@ Pass `skip_config: true` to ignore the project config file. This skips loading `
 | Parameter | Purpose |
 |---|---|
 | `incremental` | Cache killed/timeout results across runs — set `true` when iterating on the same files |
-| `integration` | `rspec` or `minitest` |
+| `integration` | `rspec`, `minitest`, or `test_unit` |
 | `isolation` | `auto`, `fork`, or `in_process` |
 | `baseline` | `false` to skip the baseline suite check when you already know it's green |
 | `save_session` | Persist results to `.evilution/results/` for inspection via `evilution-session` |
@@ -774,7 +774,7 @@ Tests 4 paths (InProcess isolation, Fork isolation, mutation generation + stripp
 3. **Filter** — Disable comments, Sorbet `sig` blocks, and AST ignore patterns exclude mutations before execution
 4. **Mutate** — 74 operators produce text replacements at precise byte offsets (source-level surgery, no AST unparsing); heredoc literal text is skipped by default. Identical byte-mutations from different operators are deduplicated by `(file_path, mutated_source)` so the count is not inflated by overlap
 5. **Isolate** — Mutations are applied to temporary file copies (never modifying originals); load-path redirection ensures `require` resolves the mutated copy. Default isolation is in-process for plain Ruby projects and fork for Rails projects (auto-detected); `--isolation fork` forces forked child processes. Both sequential and parallel (`--jobs N`) modes respect the configured isolation strategy
-6. **Test** — The configured test framework (RSpec or Minitest) executes against the mutated source
+6. **Test** — The configured test framework (RSpec, Minitest, or Test::Unit) executes against the mutated source
 7. **Collect** — Source strings and AST nodes are released after use to minimize memory retention
 8. **Report** — Results aggregated into text, JSON, or HTML, including efficiency metrics and peak memory usage
 

data/docs/integrations.md

@@ -0,0 +1,126 @@
+# Test Framework Integrations
+
+Evilution supports three test framework integrations, selected via the
+`--integration NAME` CLI flag (or the `integration:` key in `.evilution.yml`).
+Each integration owns its own framework loader, dispatcher, spec resolver,
+and result builder so they can evolve independently.
+
+| Integration   | Flag value    | Default test dir | Default test suffix | Gem dep                |
+|---------------|---------------|------------------|---------------------|------------------------|
+| RSpec         | `rspec`       | `spec/`          | `_spec.rb`          | `rspec-core`           |
+| Minitest      | `minitest`    | `test/`          | `_test.rb`          | `minitest`             |
+| Test::Unit    | `test-unit`   | `test/`          | `_test.rb`          | `test-unit`            |
+
+## When to pick which
+
+- **`rspec`** (default) — Suites built on `RSpec.describe` / `it` / `expect`.
+- **`minitest`** — Suites that subclass `Minitest::Test` or use
+  `Minitest::Spec`'s `describe` / `it`. Includes Rails apps where
+  `ActiveSupport::TestCase` inherits from `Minitest::Test`.
+- **`test-unit`** — Suites that subclass `Test::Unit::TestCase`, including
+  Rails projects that `require "test/unit/rails/test_help"` (which makes
+  `ActiveSupport::TestCase < Test::Unit::TestCase`). The `test-unit` gem's
+  `TestCase` classes are *not* `Minitest::Runnable` subclasses, so the
+  `minitest` integration cannot dispatch them — pick this integration whenever
+  your test helper pulls in `test/unit/rails/test_help`, `test-unit-activerecord`,
+  or similar test-unit-specific glue.
+
+## CLI examples
+
+```bash
+# RSpec — default; specs in spec/, named *_spec.rb
+bundle exec evilution run lib/foo.rb
+
+# Minitest
+bundle exec evilution run lib/foo.rb \
+  --integration minitest --spec test/foo_test.rb
+
+# Test::Unit (gem name uses hyphen; symbol value uses underscore)
+bundle exec evilution run lib/foo.rb \
+  --integration test-unit --spec test/foo_test.rb
+```
+
+The CLI accepts both `test-unit` and `test_unit` strings; the internal config
+symbol is always `:test_unit`.
+
+## MCP examples
+
+The `evilution-mutate` MCP tool exposes `integration` as a JSON schema enum
+of `["rspec", "minitest", "test-unit"]`:
+
+```json
+{
+  "tool": "evilution-mutate",
+  "args": {
+    "files": ["lib/foo.rb"],
+    "integration": "test-unit",
+    "spec": ["test/foo_test.rb"]
+  }
+}
+```
+
+## Spec resolution conventions
+
+When `--spec` is not supplied, evilution resolves a test file from the source
+path using the integration's spec resolver. Strips `lib/` or `app/` prefix
+and rewrites the suffix:
+
+| Source                              | rspec                               | minitest / test-unit               |
+|-------------------------------------|-------------------------------------|------------------------------------|
+| `lib/foo.rb`                        | `spec/foo_spec.rb`                  | `test/foo_test.rb`                 |
+| `lib/foo/bar.rb`                    | `spec/foo/bar_spec.rb`              | `test/foo/bar_test.rb`             |
+| `app/models/user.rb`                | `spec/models/user_spec.rb`          | `test/models/user_test.rb`         |
+| `app/controllers/users_controller.rb` | `spec/requests/users_spec.rb` *or* `spec/controllers/users_controller_spec.rb` | `test/integration/users_test.rb` *or* `test/controllers/users_controller_test.rb` |
+
+For controllers, the resolver tries the request-spec / integration-test
+location first, then falls back to the controller-spec / controller-test
+location.
+
+## Suggest-tests caveat
+
+The `--suggest-tests` mode emits ready-to-paste test snippets for survived
+mutations. Concrete templates currently exist for **rspec** and **minitest**
+only; the **test-unit** integration falls back to the generic operator-level
+suggestion text. Adding test-unit templates is a small follow-up.
+
+## Other Ruby test frameworks
+
+No additional integrations are planned at the moment. The three integrations
+above cover the overwhelming majority of Ruby projects with unit / integration
+test suites. Frameworks we considered and deferred:
+
+- **Cucumber / Spinach** — BDD scenarios over Gherkin step definitions, a
+  fundamentally coarser granularity than mutation testing rewards. Not a
+  natural fit; no plans to add.
+- **Sus** — Socketry's async-focused framework, small but actively maintained
+  user base. Could be added under the same orchestrator/collaborator pattern
+  if a real project surfaces needing it.
+- **Bacon, Test::Spec** — early RSpec-style clones, effectively dormant.
+- **Minitest::Spec** — already covered by the `minitest` integration.
+
+If you maintain a project on another framework and would benefit from
+mutation-testing it through evilution, open an issue describing the project
+and the framework's dispatch entry-point — the existing integration layout
+makes new entries cheap to add.
+
+## Behind the scenes
+
+Each integration has an orchestrator class at
+`lib/evilution/integration/<name>.rb`. RSpec and Test::Unit additionally
+decompose their collaborators into a sibling directory of the same name
+(`lib/evilution/integration/rspec/...`,
+`lib/evilution/integration/test_unit/...`); Minitest remains a single file.
+The test-unit collaborators are:
+
+- `framework_loader.rb` — `require "test-unit"` + disables the at_exit
+  auto-run handler so it doesn't fire on evilution exit.
+- `subject_class_registry.rb` — ObjectSpace tracking of newly-loaded
+  `Test::Unit::TestCase` subclasses (test-unit has no public
+  registry-clear analog to `Minitest::Runnable.runnables`).
+- `dispatcher.rb` — assembles a `Test::Unit::TestSuite` from the new
+  classes and runs it via `Test::Unit::UI::Console::TestRunner` with
+  output captured to a `StringIO`.
+- `test_file_resolver.rb` — explicit-override + spec-selector +
+  fallback glob + warn-once for unresolved sources.
+- `result_builder.rb` — shapes the `passed`/`test_crashed`/
+  `no_tests_ran`/`unresolved` Hash that flows into `classify_status`.

data/lib/evilution/cli/parser/options_builder.rb

@@ -95,7 +95,7 @@ class Evilution::CLI::Parser::OptionsBuilder
   end
 
   def add_runner_mode_options(opts)
-    opts.on("--integration NAME", "Test integration: rspec, minitest (default: rspec)") { |i| @options[:integration] = i }
+    opts.on("--integration NAME", "Test integration: rspec, minitest, test-unit (default: rspec)") { |i| @options[:integration] = i }
     opts.on("--isolation STRATEGY", "Isolation: auto, fork, in_process (default: auto)") { |s| @options[:isolation] = s }
     opts.on("--preload FILE", "Preload FILE in the parent process before forking " \
                               "(default: auto-detect spec/rails_helper.rb -> spec/spec_helper.rb -> " \

data/lib/evilution/config/validators/integration.rb

@@ -3,9 +3,13 @@
 require_relative "base"
 
 class Evilution::Config::Validators::Integration < Evilution::Config::Validators::Base
-  ALLOWED = %i[rspec minitest].freeze
+  ALLOWED = %i[rspec minitest test_unit].freeze
 
+  # CLI users naturally write the gem name `test-unit`; the internal symbol
+  # uses underscore form to match the file path and registry key. Normalize
+  # hyphenated string input before coercion.
   def self.call(value)
+    value = value.tr("-", "_") if value.is_a?(String)
     coerce_symbol!(value, allowed: ALLOWED, name: "integration")
   end
 end

data/lib/evilution/config.rb

@@ -139,7 +139,7 @@ class Evilution::Config
       # (default: true). Set false to skip (e.g. for CI speed).
       # canary: true
 
-      # Test integration: rspec, minitest (default: rspec)
+      # Test integration: rspec, minitest, test_unit (default: rspec)
       # integration: rspec
 
       # Number of parallel workers (default: 1)

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

@@ -78,8 +78,7 @@ class Evilution::Integration::Loading::MutationApplier
     # When the isolator has chdir'd into a per-mutation sandbox (EV-wqxu /
     # GH #1278), anchor against PROJECT_ROOT so File.realpath does not chase
     # file_path into a non-existent /tmp path.
-    base = Evilution.in_isolated_worker? ? Evilution::PROJECT_ROOT : Dir.pwd
-    absolute = File.realpath(File.expand_path(file_path, base))
+    absolute = File.realpath(File.expand_path(file_path, Evilution.project_base_dir))
     $LOADED_FEATURES << absolute unless $LOADED_FEATURES.include?(absolute)
   rescue Errno::ENOENT
     nil

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

@@ -16,8 +16,7 @@ class Evilution::Integration::Loading::SourceEvaluator
     # When the isolator has chdir'd into a per-mutation sandbox (EV-wqxu /
     # GH #1278), anchor the eval __FILE__ against PROJECT_ROOT so siblings
     # `require_relative` can find each other from the real source tree.
-    base = Evilution.in_isolated_worker? ? Evilution::PROJECT_ROOT : Dir.pwd
-    absolute = File.expand_path(file_path, base)
+    absolute = File.expand_path(file_path, Evilution.project_base_dir)
     eval(source, TOPLEVEL_BINDING, absolute, 1)
   end
 end

data/lib/evilution/integration/minitest.rb

@@ -128,8 +128,7 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
   end
 
   def execute_minitest(mutation, files, command)
-    base = Evilution.in_isolated_worker? ? Evilution::PROJECT_ROOT : Dir.pwd
-    files.each { |f| load(File.expand_path(f, base)) }
+    files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
 
     detector = reset_crash_detector
     run = run_minitest(build_args(mutation), detector)

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

@@ -5,7 +5,9 @@ require_relative "../rspec"
 class Evilution::Integration::RSpec::BaselineRunner
   def call(spec_file)
     require "rspec/core"
-    spec_dir = File.expand_path("spec")
+    # Anchor against PROJECT_ROOT under EV-wqxu sandbox CWD; see
+    # FrameworkLoader#add_spec_load_path for rationale.
+    spec_dir = File.expand_path("spec", Evilution.project_base_dir)
     $LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
     ::RSpec.reset
     status = ::RSpec::Core::Runner.run(

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

@@ -22,7 +22,11 @@ class Evilution::Integration::RSpec::FrameworkLoader
   private
 
   def add_spec_load_path
-    spec_dir = File.expand_path("spec")
+    # Anchor against PROJECT_ROOT inside an isolated worker (EV-wqxu /
+    # GH #1278) so the project's spec/ dir lands on $LOAD_PATH — otherwise
+    # `require "spec_helper"` resolves to a non-existent sandbox/spec and
+    # every mutation errors as "loaded 0 examples".
+    spec_dir = File.expand_path("spec", Evilution.project_base_dir)
     $LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
   end
 end

data/lib/evilution/integration/test_unit/dispatcher.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../test_unit"
+
+# Builds a Test::Unit::TestSuite from a list of TestCase subclasses and runs
+# it via the console runner with output captured to a StringIO. Owning this
+# responsibility separately keeps the runner library require + suite assembly
+# in one place — used by both the baseline path (Evilution::Integration::TestUnit
+# .run_baseline_test_file) and the per-mutation path (#run_tests).
+module Evilution::Integration::TestUnit::Dispatcher
+  module_function
+
+  def call(test_case_classes, name: "evilution")
+    require "test/unit/ui/console/testrunner"
+    suite = ::Test::Unit::TestSuite.new(name)
+    test_case_classes.each { |klass| suite << klass.suite }
+    out = StringIO.new
+    runner = ::Test::Unit::UI::Console::TestRunner.new(suite, output: out)
+    runner.start
+  end
+
+  def test_method_count(test_case_classes)
+    test_case_classes.sum { |klass| klass.suite.tests.length }
+  end
+end

data/lib/evilution/integration/test_unit/framework_loader.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Loads the test-unit gem and disables its at_exit auto-run handler.
+# Mirrors Evilution::Integration::RSpec::FrameworkLoader's role: framework
+# setup is one responsibility separated from dispatch + result building so
+# integrations can compose it independently in tests.
+class Evilution::Integration::TestUnit::FrameworkLoader
+  def loaded?
+    @loaded == true
+  end
+
+  def call
+    return if @loaded
+
+    require "test-unit"
+    self.class.stub_autorun!
+    @loaded = true
+  rescue LoadError => e
+    raise Evilution::Error, "test-unit is required but not available: #{e.message}"
+  end
+
+  # User code that `require "test-unit"` installs an at_exit hook that calls
+  # Test::Unit::AutoRunner.run when need_auto_run? is true. At evilution exit
+  # ARGV still holds evilution flags and the runner prints a misleading banner.
+  # Flipping need_auto_run = false prevents the handler from firing.
+  def self.stub_autorun!
+    return unless defined?(::Test::Unit::AutoRunner)
+
+    ::Test::Unit::AutoRunner.need_auto_run = false
+  end
+end

data/lib/evilution/integration/test_unit/result_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Shapes the result Hash that flows back to Evilution::Result::MutationResult
+# / classify_status. Three orthogonal flavours — pass/fail/crash, no tests
+# executed, and unresolved spec — each have their own change axis (e.g. the
+# no-tests-ran error string evolved separately as the test-unit framework
+# diagnostic improved). Putting them behind a single object documents the
+# contract and lets the integration class drop them.
+module Evilution::Integration::TestUnit::ResultBuilder
+  module_function
+
+  def call(passed:, command:, detector:)
+    if passed
+      { passed: true, test_command: command }
+    elsif detector.only_crashes?
+      crash(command, detector)
+    else
+      { passed: false, test_command: command }
+    end
+  end
+
+  def no_tests_ran(command)
+    {
+      passed: false,
+      error: "no Test::Unit tests executed (0 test methods ran) — the resolved " \
+             "spec registered no Test::Unit suite. Check --integration/--spec.",
+      error_class: "Evilution::Error",
+      test_command: command
+    }
+  end
+
+  def unresolved(mutation_file_path)
+    {
+      passed: false,
+      unresolved: true,
+      error: "no matching test resolved for #{mutation_file_path}",
+      test_command: "ruby -Itest (skipped: no test resolved for #{mutation_file_path})"
+    }
+  end
+
+  def crash(command, detector)
+    classes = detector.unique_crash_classes
+    {
+      passed: false,
+      test_crashed: true,
+      error: "test crashes: #{detector.crash_summary}",
+      error_class: (classes.first if classes.length == 1),
+      test_command: command
+    }
+  end
+end

data/lib/evilution/integration/test_unit/subject_class_registry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Tracks Test::Unit::TestCase descendants in the host process. Test::Unit has
+# no public registry-clear method analogous to Minitest::Runnable.runnables;
+# the integration scopes each dispatch to classes that appeared during *this*
+# round by diffing the descendant set before and after #load. Keeping that
+# responsibility in its own object makes it cheap to stub in tests and lets
+# the integration's main class read as orchestration.
+module Evilution::Integration::TestUnit::SubjectClassRegistry
+  module_function
+
+  def descendants
+    return [] unless defined?(::Test::Unit::TestCase)
+
+    ObjectSpace.each_object(Class).select { |c| c < ::Test::Unit::TestCase }
+  end
+
+  # Yields, captures the descendant set before/after, and returns the diff.
+  def newly_loaded
+    before = descendants
+    yield
+    descendants - before
+  end
+end

data/lib/evilution/integration/test_unit/test_file_resolver.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Resolves the list of test files to load for a given mutation. Encapsulates
+# the explicit-override path, spec-selector lookup, fallback glob, and the
+# warn-once behaviour for unresolved sources. The integration class would
+# otherwise carry both per-instance test resolution state (@test_files,
+# @spec_selector, @warned_files, @fallback_to_full_suite) and dispatch
+# orchestration in the same object; splitting them gives the resolver its
+# own change axis (e.g. adding new resolution heuristics) independent of
+# the runner.
+class Evilution::Integration::TestUnit::TestFileResolver
+  def initialize(test_files:, spec_selector:, fallback_to_full_suite:)
+    @test_files = test_files
+    @spec_selector = spec_selector
+    @fallback_to_full_suite = fallback_to_full_suite
+    @warned_files = Set.new
+  end
+
+  # Returns the resolved file list, or nil if the source could not be
+  # resolved and fallback is disabled.
+  def call(mutation_file_path)
+    return @test_files if @test_files
+
+    resolved = Array(@spec_selector.call(mutation_file_path))
+    return resolved unless resolved.empty?
+
+    warn_unresolved(mutation_file_path)
+    @fallback_to_full_suite ? glob_test_files : nil
+  end
+
+  private
+
+  def glob_test_files
+    files = Dir.glob("test/**/*_test.rb")
+    files.empty? ? ["test"] : files
+  end
+
+  def warn_unresolved(file_path)
+    return if @warned_files.include?(file_path)
+
+    @warned_files << file_path
+    action = @fallback_to_full_suite ? "running full suite" : "marking mutation unresolved"
+    warn "[evilution] No matching test found for #{file_path}, #{action}. " \
+         "Use --spec to specify the test file."
+  end
+end

data/lib/evilution/integration/test_unit.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "test_unit_crash_detector"
+require_relative "../spec_resolver"
+require_relative "../spec_selector"
+
+require_relative "../integration"
+
+# Test::Unit integration. Decomposed under lib/evilution/integration/test_unit/
+# mirroring the RSpec integration's layout. This class is the orchestrator:
+# it wires the framework loader, dispatcher, subject-class registry,
+# test-file resolver, and result builder. The class is registered under
+# Evilution::Runner::INTEGRATIONS[:test_unit] and reachable via the
+# `--integration test-unit` CLI flag.
+class Evilution::Integration::TestUnit < Evilution::Integration::Base
+  def self.baseline_runner
+    ->(test_file) { run_baseline_test_file(test_file) }
+  end
+
+  # SpecResolver tuned for the dominant Test::Unit layout: tests live under
+  # test/, named with the _test.rb suffix (the same convention Minitest uses).
+  # Rails plugins on the test-unit gem (e.g. kaminari-core) follow this layout.
+  # The test/test_<name>.rb prefix-style convention is rare enough in practice
+  # that we defer support to a follow-up if a project surfaces needing it.
+  def self.spec_resolver
+    Evilution::SpecResolver.new(test_dir: "test", test_suffix: "_test.rb", request_dir: "integration")
+  end
+
+  def self.baseline_options
+    {
+      runner: baseline_runner,
+      spec_resolver: spec_resolver,
+      fallback_dir: "test"
+    }
+  end
+
+  def self.run_baseline_test_file(test_file)
+    require_relative "test_unit/framework_loader"
+    require_relative "test_unit/subject_class_registry"
+    require_relative "test_unit/dispatcher"
+    FrameworkLoader.new.call
+    new_classes = SubjectClassRegistry.newly_loaded do
+      baseline_test_files(test_file).each { |f| load(File.expand_path(f)) }
+    end
+    Dispatcher.call(new_classes, name: "evilution baseline").passed?
+  end
+
+  def self.baseline_test_files(test_file)
+    File.directory?(test_file) ? Dir.glob(File.join(test_file, "**/*_test.rb")) : [test_file]
+  end
+
+  def initialize(test_files: nil, hooks: nil, fallback_to_full_suite: false, spec_selector: nil)
+    require_relative "test_unit/framework_loader"
+    require_relative "test_unit/subject_class_registry"
+    require_relative "test_unit/dispatcher"
+    require_relative "test_unit/test_file_resolver"
+    require_relative "test_unit/result_builder"
+    @framework_loader = FrameworkLoader.new
+    @file_resolver = TestFileResolver.new(
+      test_files: test_files,
+      spec_selector: spec_selector || Evilution::SpecSelector.new(spec_resolver: self.class.spec_resolver),
+      fallback_to_full_suite: fallback_to_full_suite
+    )
+    @crash_detector = nil
+    super(hooks: hooks)
+  end
+
+  private
+
+  def ensure_framework_loaded
+    return if @framework_loader.loaded?
+
+    fire_hook(:setup_integration_pre, integration: :test_unit)
+    @framework_loader.call
+    fire_hook(:setup_integration_post, integration: :test_unit)
+  end
+
+  def run_tests(mutation)
+    ensure_framework_loaded
+    reset_state
+    files = @file_resolver.call(mutation.file_path)
+    return ResultBuilder.unresolved(mutation.file_path) if files.nil?
+
+    command = "ruby -Itest #{files.join(" ")}"
+    execute_test_unit(files, command)
+  rescue StandardError => e
+    { passed: false, error: e.message, test_command: command }
+  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
+    return ResultBuilder.no_tests_ran(command) if Dispatcher.test_method_count(new_classes).zero?
+
+    detector = reset_crash_detector
+    result = Dispatcher.call(new_classes, name: "evilution-mutation")
+    result.faults.each { |fault| detector.record(fault) }
+    ResultBuilder.call(passed: result.passed?, command: command, detector: detector)
+  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
+  # classes from prior mutations sit dormant on ObjectSpace without polluting
+  # the run. #reset_state stays as a contract no-op for parity with Minitest.
+  def reset_state
+    # no-op — see comment above
+  end
+
+  def build_args(_mutation)
+    []
+  end
+
+  def reset_crash_detector
+    if @crash_detector
+      @crash_detector.reset
+    else
+      @crash_detector = Evilution::Integration::TestUnitCrashDetector.new
+    end
+    @crash_detector
+  end
+end

data/lib/evilution/integration/test_unit_crash_detector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+
+# Test::Unit analog of Evilution::Integration::MinitestCrashDetector. Tracks
+# whether a Test::Unit test run produced only crashes (exceptions captured as
+# Test::Unit::Error) vs assertion failures (Test::Unit::Failure). When only
+# crashes occur, the mutation result can carry crash details while remaining
+# classified as :killed — see classify_status / Result::MutationResult.
+#
+# Hook the detector into a Test::Unit::TestResult via .attach(result), or
+# call #record(fault) directly when iterating a finished result's #faults.
+class Evilution::Integration::TestUnitCrashDetector
+  def initialize
+    reset
+  end
+
+  def reset
+    @assertion_failures = 0
+    @crashes = []
+  end
+
+  def attach(test_result)
+    require "test/unit/testresult"
+    test_result.add_listener(Test::Unit::TestResult::FAULT) { |fault| record(fault) }
+  end
+
+  def record(fault)
+    if fault.is_a?(Test::Unit::Error)
+      @crashes << fault.exception
+    elsif fault.is_a?(Test::Unit::Failure)
+      @assertion_failures += 1
+    end
+  end
+
+  def passed?
+    @assertion_failures.zero? && @crashes.empty?
+  end
+
+  def assertion_failure?
+    @assertion_failures.positive?
+  end
+
+  def crashed?
+    @crashes.any?
+  end
+
+  def only_crashes?
+    @crashes.any? && @assertion_failures.zero?
+  end
+
+  def unique_crash_classes
+    @crashes.map { |e| e.class.name }.uniq
+  end
+
+  def crash_summary
+    return nil if @crashes.empty?
+
+    "#{unique_crash_classes.join(", ")} (#{@crashes.length} crash#{"es" unless @crashes.length == 1})"
+  end
+end

data/lib/evilution/isolation/fork.rb

@@ -11,6 +11,7 @@ require_relative "../isolation"
 
 class Evilution::Isolation::Fork
   GRACE_PERIOD = 2
+  REAP_DEADLINE = 1.0
 
   def initialize(hooks: nil)
     @hooks = hooks
@@ -130,8 +131,23 @@ class Evilution::Isolation::Fork
     end
   end
 
+  # Process.wait without a deadline can hang the parent indefinitely. The
+  # per-mutation child may already have written a payload (or a grandchild may
+  # have written garbage that looks like one) while the child itself is stuck
+  # in execute_in_child waiting on a subject grandchild the mutation broke.
+  # wait_for_result has already returned by this point, so the per-mutation
+  # timeout cannot fire. Bound the wait and fall back to the TERM/KILL ladder.
   def reap_and_decode(pid, payload)
-    ::Process.wait(pid)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + REAP_DEADLINE
+    loop do
+      break if ::Process.waitpid(pid, ::Process::WNOHANG)
+
+      if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+        terminate_child(pid)
+        break
+      end
+      sleep 0.05
+    end
     decode_payload(payload)
   end
 

data/lib/evilution/mcp/info_tool.rb

@@ -58,8 +58,8 @@ class Evilution::MCP::InfoTool < MCP::Tool
       },
       integration: {
         type: "string",
-        description: "[subjects, tests] Test integration (rspec, minitest) — 'tests' selects " \
-                     "the matching spec resolver (spec/*_spec.rb for rspec, test/*_test.rb for minitest)"
+        description: "[subjects, tests] Test integration (rspec, minitest, test-unit) — 'tests' selects " \
+                     "the matching spec resolver (spec/*_spec.rb for rspec, test/*_test.rb for minitest/test-unit)"
       },
       skip_config: {
         type: "boolean",

data/lib/evilution/mcp/mutate_tool.rb

@@ -72,8 +72,9 @@ class Evilution::MCP::MutateTool < MCP::Tool
       },
       integration: {
         type: "string",
-        enum: %w[rspec minitest],
-        description: "Test integration to use (default: rspec)"
+        enum: %w[rspec minitest test-unit],
+        description: "Test integration to use (default: rspec). " \
+                     "Use test-unit for projects whose suites run on the test-unit gem."
       },
       isolation: {
         type: "string",

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.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)

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "0.31.0"
+  VERSION = "0.32.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/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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 0.31.0
+  version: 0.32.0
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-27 00:00:00.000000000 Z
+date: 2026-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -104,6 +104,7 @@ files:
 - comparison_results/operator_classification.md
 - comparison_results/operator_prioritization.md
 - docs/ast_pattern_syntax.md
+- docs/integrations.md
 - docs/isolation.md
 - docs/mutation_density_benchmark.md
 - docs/versioning.md
@@ -240,6 +241,13 @@ files:
 - lib/evilution/integration/rspec/state_guard/world_sources_by_path.rb
 - lib/evilution/integration/rspec/test_file_resolver.rb
 - lib/evilution/integration/rspec/unresolved_spec_warner.rb
+- lib/evilution/integration/test_unit.rb
+- lib/evilution/integration/test_unit/dispatcher.rb
+- lib/evilution/integration/test_unit/framework_loader.rb
+- lib/evilution/integration/test_unit/result_builder.rb
+- lib/evilution/integration/test_unit/subject_class_registry.rb
+- lib/evilution/integration/test_unit/test_file_resolver.rb
+- lib/evilution/integration/test_unit_crash_detector.rb
 - lib/evilution/isolation.rb
 - lib/evilution/isolation/fork.rb
 - lib/evilution/isolation/in_process.rb