mutation_tester 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e32ba3afbad23fb7f2d04c12f197c8e7d7af50d0eb537266f76e3bd957165110
-  data.tar.gz: b27a1b44965b42cb4498daaba8d221dcf820b71fd3e61f3b94c47a71c7cad41d
+  metadata.gz: b33e53b5e67f12380151690883608e8bc76ab3915d4771baa6d5293e5cedd94c
+  data.tar.gz: 24fda20aa66c67f0a828c44fd3cd064a586c8ea40f6c9fe2f8263518ef6318be
 SHA512:
-  metadata.gz: 4a05a309477ff66005be2371bedd4b5ce4b3622a064f2013b3b62336dbe5d43af7c0e27526eee2ab186c07d9faef5fc8e3a568fe1bdda5e428c3142af19b0165
-  data.tar.gz: 3fd04d05930cf47e0a4fb15680531586dfd9183ecd77ec3040aae3e5397ca1cd0cef2ac68ea087acf87c0acdd43dd8f3a18a40a46f05d8c5fac9a545511988f0
+  metadata.gz: 76f242526719139f3e78ba2a32e145671db00486f7a017d75011330c6c390c8b12e91ff142e779270d2f05711da36970747831cf1af9aadd06735f604010cfa8
+  data.tar.gz: 58d9d64c6344dfcee881455109b9638e9e380233a7e3a4be826879e14f8b4ca21de201f79978b9eb07fbcd0376a30b9e9b71cc440bb1c033fc92804062c6770a

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.6.0] - 2026-09-19
+
+- Added an opt-in kill matrix (`--kill-matrix`, `config.kill_matrix = true`) that records which tests kill each mutant, so the JSON report can be used to find redundant tests and not only missing ones. In this mode every mutant runs the full test file (no stop at the first failing test and no RSpec test selection), for RSpec and Minitest on all three runners, serial and parallel. The JSON report gains three additive fields, so `schema_version` stays at 1: `kill_matrix: true`, `tests[]` (every test of the baseline run with `id`, `name`, `line` and `status`) and `mutations[].killed_by` (the sorted ids of every test that failed under the mutant). An empty `killed_by` on a `killed` or `timeout` mutant means the killers are unknown (every timeout, and a mutated file that no longer loads), so a test must never be called redundant because of such a mutant. `--kill-matrix` together with `--fail-fast` is a usage error (exit code `2`), and a baseline that records no test aborts the run instead of reporting an empty matrix. The README has a new "Finding redundant tests" section with `jq` recipes, and `examples/github_actions/redundant_tests.yml` ships a scheduled audit workflow.
+- The live progress line now shows the elapsed time, an estimate of the remaining time and running tallies of survived and timed out mutants (plus errored ones once any occur): `69.2% | 848/1226 processed | elapsed 37m 2s, remaining ~16m 32s | 170 survived, 0 timed out`. The estimate is extrapolated from real throughput measured from the first completed mutant, so worker boot and the shadow copy do not distort it and it holds for parallel runs; it is withheld until the sample is stable. On a terminal the line is fitted to the terminal width so it never wraps. The `| type | line N` suffix is gone (it was always empty in parallel runs) and the counter label is shortened to `processed`.
+- Behavior change for Ruby API users: the progress callback of `MutationRunner#run` now fires for every completed mutant in parallel mode (it used to fire for every second one) and receives the result hash as a third argument. A plain two-argument block keeps working; a two-argument lambda or `method(:name)` passed with `&` now raises `ArgumentError` and needs a third parameter. `ProgressDisplay#update` now takes `(index, result = nil)` and `ProgressDisplay#current_mutation` is removed.
+- Fixed a false 100% score on Minitest projects without a Gemfile whose test file pins `gem 'minitest', '~> 5.0'` while a newer Minitest is installed. The Minitest preloads and the fork worker loaded Minitest before the test file ran, which activated the newer version and made the pin raise `Gem::LoadError`: the baseline failed on the default runner, and under `--runner spawn` every mutant ended in that load error and counted as killed, so a test that asserts nothing scored 100%. Nothing loads Minitest before the test file does anymore.
+- Fixed `format_duration` returning `1m 60s` for 119.6 seconds (it now rounds before splitting into units), and fixed the spinner thread staying alive after Ctrl-C, which printed the interruption message onto a half-drawn progress line.
+
 ## [1.5.1] - 2026-08-13
 
 - Fixed load-time mutants losing per-worker database isolation in a parallel in-memory run with `--worker-env` and `--after-fork`. Mutants on load-time code (constants, class macros, `included do`) are decided file-based on purpose, but that file-based run acquires a fork-runner worker, and a worker booted inside a `Parallel` worker process inherited the parent process's value of the worker-env variable instead of the per-worker assignment: with 8 workers, every load-time mutant's test run hit the parent's database concurrently, races on shared rows failed tests unrelated to the mutant, and those failures were scored as kills. The same file could report 75% and 100% on consecutive runs with no error and no timeout in the output, while the spawn path and the pooled fork runner (which already carried the per-worker value) stayed stable. The fork execution path now passes the same per-worker env override the spawn path always used, and the worker applies it inside the forked test child before the spec loads, so every execution path resolves the same per-worker database. Reported in the field with exactly this signature: only class-macro mutants unstable, serial and fork-runner scores identical and stable.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mutation_tester (1.5.1)
+    mutation_tester (1.6.0)
       parallel (~> 1.20)
       parser (~> 3.3)
       rainbow (~> 3.0)

data/docs/ci.md

@@ -23,6 +23,9 @@ It also carries commented variants for parallel execution
 (`MUTATION_TESTER_PARALLEL_PROCESSES`), for testing several file pairs, and for
 an incremental pull-request gate (`--since`/`--fail-fast`).
 
+Two more templates sit next to it: the [AI mutation gate](#ai-workflow-mutation-gate)
+and the scheduled [redundant test audit](#redundant-test-audit-scheduled-job).
+
 ## GitHub Actions (minimal inline workflow)
 
 The same thing, condensed to a copy-pasteable minimal workflow. It matches the
@@ -179,3 +182,31 @@ the template carries a commented step showing where to wire your agent CLI. Use
 it alongside the plain [5-minute CI template](#mutation-testing-in-ci-in-5-minutes):
 the AI gate adds the surviving-mutant worklist, the plain template is just the
 pass/fail gate.
+
+## Redundant test audit (scheduled job)
+
+The opt-in kill matrix (`--kill-matrix`) records, for every mutant, the tests
+that kill it, which makes it possible to list tests that add no protection. The
+method, the `jq` recipes and their limits are described under
+[Finding redundant tests](../readme.md#finding-redundant-tests) in the README.
+
+The gem ships a ready-to-copy workflow at
+[`examples/github_actions/redundant_tests.yml`](../examples/github_actions/redundant_tests.yml)
+(installed with the gem, so you have it offline). Copy it to
+`.github/workflows/redundant_tests.yml`, add the gem to your bundle, and edit the
+`EDIT:` lines. It:
+
+1. runs on a weekly schedule and on demand (`workflow_dispatch`), not on every
+   push: without the stop at the first failing test the run is slower than the
+   normal gate,
+2. runs `mutation_test --kill-matrix --json --glob ...` with `--minimum-score 0`,
+   so the mutation score never fails the audit while a broken run (failing
+   baseline, no file measured) still does,
+3. writes two lists to the GitHub job summary (`$GITHUB_STEP_SUMMARY`): tests
+   that kill no mutant, and tests whose every kill is shared with another test,
+   plus the number of mutants whose killers are unknown,
+4. uploads `kill_matrix.json` as an artifact.
+
+It is an audit, not a gate: the findings never fail the job. Treat the lists as
+candidates to review and remove one test at a time, because two listed tests can
+cover for each other.

data/docs/execution-runners.md

@@ -92,12 +92,32 @@ Every mutant run stops as soon as one test fails, on all three runners:
   non-passing result. On `spawn` the file is preloaded with `ruby -r`, on the
   preloaded runners the worker enables the same reporter per job.
 
+Neither preload loads Minitest itself. Each one waits until the test file has
+loaded Minitest and only then registers its plugin, and the fork worker sets its
+autorun guard the same way. The test file therefore still chooses the Minitest
+version: a project without a Gemfile that pins `gem 'minitest', '~> 5.0'` at the
+top of its test file keeps working when a newer Minitest is installed. Loading
+Minitest first would activate the newest installed version, the pin would then
+raise `Gem::LoadError`, and every mutant run would end in that load error and be
+counted as killed.
+
 This cannot change a verdict. A run that stops early has already recorded a
 failure, which is exactly what makes a mutant killed, and a run without a failure
 is untouched and executes every test. Only the mutant runs opt in: the baseline
 run and the shadow-workspace sanity check are expected to pass and always run the
 whole file, so a failing baseline still reports every failure it finds.
 
+The opt-in kill matrix (`--kill-matrix`, `config.kill_matrix = true`) turns the
+early stop off for mutant runs too, on all three runners, because it has to
+record every failing test of every mutant. A small recorder is loaded next to the
+test file (`--require` for RSpec and `ruby -r` for Minitest on `spawn`, at worker
+boot on the preloaded runners) and appends the failing test ids to a per-run
+temporary file named through the environment. The ids deliberately do not travel
+through the fork worker's result pipe: the parent reads that pipe only after the
+child has finished, so a list larger than the pipe buffer would block the child
+until the deadline and turn a kill into a timeout. See
+[Finding redundant tests](../readme.md#finding-redundant-tests).
+
 The pathological case it removes is a mutant that breaks something every test
 touches (a class body that no longer loads, a constant every test reads). Such a
 mutant used to re-raise the same error once per test, which on a large test file
@@ -200,6 +220,9 @@ runner (the default path) performs no selection at all: every mutant runs the
 full preloaded example set, which is why its report omits the `Selection:`
 summary line (see the in-memory limitations above).
 
+The kill matrix mode (`--kill-matrix`) turns selection off for the run, because a
+subset run would under-report the tests that kill a mutant.
+
 Disable it with the `--no-test-selection` CLI flag or in Ruby:
 
 ```ruby

data/docs/json-schema.md

@@ -73,6 +73,9 @@ history of changes.
 | `mutations[].timeout`          | boolean | Legacy passthrough flag from the runner (`true` only when the mutant timed out). Kept for backward compatibility; prefer `status`.                                                                                                                                                                                                              |
 | `mutations[].status`           | string  | One of the taxonomy statuses below. This is the authoritative per-mutant result.                                                                                                                                                                                                                                                                |
 | `mutations[].description`      | string  | Human-readable description of the mutation (for `error`, the failure message).                                                                                                                                                                                                                                                                  |
+| `kill_matrix`                  | boolean | Optional, additive (does not bump `schema_version`). Present and `true` only for a run with the opt-in `--kill-matrix` mode, which guarantees that every `mutations[].killed_by` list is complete. Absent otherwise. See [Kill matrix fields](#kill-matrix-fields-opt-in).                                                                       |
+| `tests[]`                      | array   | Optional, additive. Present only with `--kill-matrix`: every test of the unmutated baseline run, ordered by line. See [Kill matrix fields](#kill-matrix-fields-opt-in).                                                                                                                                                                       |
+| `mutations[].killed_by`        | array   | Optional, additive. Present only with `--kill-matrix`, on every mutant: the sorted `tests[].id` values of every test that failed under this mutant. See [Kill matrix fields](#kill-matrix-fields-opt-in).                                                                                                                                       |
 | `mutations[].diff`             | string  | Optional, additive (does not bump `schema_version`). Present only for `survived` and `timeout` mutants: a unified diff of the change with a few lines of surrounding context (`@@` hunk header, lines prefixed with `- `, `+ ` or two spaces). Falls back to a context-free `- `/`+ ` pair when the source file is not readable at report time. |
 
 **Status taxonomy** (`mutations[].status`): `killed` (tests caught it), `survived`
@@ -80,6 +83,47 @@ history of changes.
 (unparseable, excluded from the score), `error` (runner failure, excluded from
 the score).
 
+## Kill matrix fields (opt-in)
+
+A normal run stops every mutant at its first failing test, so it cannot say which
+tests kill a mutant and emits none of the fields below. With `--kill-matrix`
+(`config.kill_matrix = true`) every mutant runs the full test file, on every
+runner and for both RSpec and Minitest, and the report gains:
+
+```json
+{
+  "schema_version": 1,
+  "interrupted": false,
+  "kill_matrix": true,
+  "tests": [
+    { "id": "InvoiceTest#test_rejects_negative_total", "name": "test_rejects_negative_total", "line": 12, "status": "passed" },
+    { "id": "InvoiceTest#test_total_sums_lines", "name": "test_total_sums_lines", "line": 20, "status": "passed" }
+  ],
+  "mutations": [
+    {
+      "id": 12,
+      "status": "killed",
+      "line": 41,
+      "killed_by": ["InvoiceTest#test_rejects_negative_total", "InvoiceTest#test_total_sums_lines"]
+    }
+  ]
+}
+```
+
+| Field                   | Type            | Description                                                                                                                                                                                                                                                              |
+|-------------------------|-----------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `tests[].id`            | string          | Stable id of the test within the run. Minitest: `TestClass#test_name`. RSpec: the spec path relative to the project root plus the scoped example id, e.g. `spec/invoice_spec.rb[1:2:1]`, which `rspec` accepts as an argument from the project root. RSpec older than 3.3 has no scoped ids, so there the id is the file and line, e.g. `spec/invoice_spec.rb:12`. |
+| `tests[].name`          | string          | Human-readable name: the full example description for RSpec, the test method name for Minitest.                                                                                                                                                                          |
+| `tests[].line`          | integer or null | 1-based line where the test is defined in the test file. `null` when the framework does not report it or the example is defined in another file (RSpec shared examples).                                                                                                 |
+| `tests[].status`        | string          | `passed` or `skipped` (RSpec `pending`/`skip`/`xit`, Minitest `skip`) in the baseline run. The baseline must pass, so there is no `failed`.                                                                                                                              |
+| `mutations[].killed_by` | array of string | Sorted ids of every test that failed under the mutant. Always `[]` for `survived`, `stillborn`, `error` and `timeout`. Also `[]` for a `killed` mutant whose run failed without any test failing (typically the mutated file no longer loads, or an error outside a test). |
+
+An empty `killed_by` on a `killed` or `timeout` mutant means the killers are
+**unknown**, not that there are none: a consumer must never call a test redundant
+because of such a mutant. In the multi-file envelope the fields appear inside each
+`files[]` report. The redundancy recipes live under
+[Finding redundant tests](../readme.md#finding-redundant-tests) in the README.
+
 ## Extracting the score and the survived mutants
 
 A ready-to-use snippet for an agent or script: read the score and list every

data/examples/github_actions/redundant_tests.yml

@@ -0,0 +1,77 @@
+# Redundant-test audit for GitHub Actions (mutation_tester gem). Runs
+# mutation_test --kill-matrix, which records for every mutant the tests that
+# kill it, and publishes two lists of candidates to the job summary: tests that
+# kill no mutant, and tests whose every kill is shared with another test. This
+# is an AUDIT, not a gate: it runs on a schedule and never fails the job because
+# of what it finds. Copy to .github/workflows/, edit the "EDIT:" lines. Needs jq
+# (preinstalled on ubuntu runners); see mutation_test.yml for the quality gate.
+#
+# Read the lists as candidates to review. Remove one test at a time and re-run:
+# two tests can cover for each other, so deleting both may let mutants survive.
+
+name: Redundant Test Audit
+
+on:
+  schedule:
+    - cron: '0 4 * * 1'   # EDIT: weekly, Monday 04:00 UTC
+  workflow_dispatch:
+
+jobs:
+  redundant_tests:
+    name: Redundant test audit
+    runs-on: ubuntu-latest
+    # The kill matrix runs every mutant against the full test file without
+    # stopping at the first failure, so it is slower than the normal gate.
+    timeout-minutes: 60
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'   # EDIT: match your project's Ruby (floor is 3.0)
+          bundler-cache: true
+
+      - name: Run mutation tests with the kill matrix (JSON report on stdout)
+        run: |
+          # EDIT: select YOUR sources; add --spec-glob 'test/{name}_test.rb' for Minitest.
+          # --minimum-score 0 keeps the score from failing this audit; a broken run
+          # (failing baseline, no file measured) still fails the step.
+          bundle exec mutation_test --kill-matrix --json --minimum-score 0 \
+            --timeout-factor 10 --glob 'lib/**/*.rb' > kill_matrix.json
+
+      - name: List redundancy candidates in the job summary
+        run: |
+          kill_nothing=$(jq -r '(.files // [.])[]
+            | (.metadata.spec_file | ltrimstr("\($ENV.PWD)/")) as $spec
+            | [.mutations[].killed_by[]] as $killers
+            | .tests[] | select(.status == "passed" and (.id | IN($killers[]) | not))
+            | "- `\(.id)` \(.name) (\($spec))"' kill_matrix.json)
+          shared_only=$(jq -r '(.files // [.])[]
+            | (.metadata.spec_file | ltrimstr("\($ENV.PWD)/")) as $spec
+            | [.mutations[] | select(.status == "killed") | .killed_by] as $kills
+            | .tests[] | .id as $id
+            | [$kills[] | select(index($id))] as $mine
+            | select(($mine | length) > 0 and all($mine[]; length > 1))
+            | "- `\(.id)` \(.name) (\($spec))"' kill_matrix.json)
+          unknown=$(jq '[(.files // [.])[] | .mutations[]
+            | select((.status == "killed" or .status == "timeout") and (.killed_by | length) == 0)]
+            | length' kill_matrix.json)
+          {
+            echo "## Redundant test audit"
+            echo "### Tests that kill no mutant"
+            echo "${kill_nothing:-None.}"
+            echo "### Tests whose every kill is shared with another test"
+            echo "${shared_only:-None.}"
+            echo
+            echo "Mutants with unknown killers (timeouts, load failures): **${unknown}**."
+            echo "Remove one test at a time and re-run: two listed tests can cover for each other."
+          } >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Upload the kill matrix report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: kill-matrix
+          path: kill_matrix.json

data/exe/mutation_test

@@ -76,6 +76,10 @@ OptionParser.new do |opts|
     options[:fail_fast] = true
   end
 
+  opts.on('--kill-matrix', 'Audit mode: run every mutant against the full test file without stopping at its first failing test and without test selection, and record in the JSON report which tests kill each mutant (mutations[].killed_by) plus the list of tests that ran (tests[]). Slower than a normal run; cannot be combined with --fail-fast') do
+    options[:kill_matrix] = true
+  end
+
   opts.on('--timeout-factor N', Float, "Per-mutant timeout budget as N times the measured baseline test run, never below #{MutationTester::Configuration::CALIBRATED_TIMEOUT_FLOOR}s (default: #{MutationTester::Configuration::DEFAULT_TIMEOUT_FACTOR}; ignored when config.timeout is set explicitly, which keeps a fixed budget)") do |n|
     options[:timeout_factor] = n
   end
@@ -184,6 +188,7 @@ apply_configuration = lambda do
     config.worker_env_var = options[:worker_env] if options.key?(:worker_env)
     config.after_fork_file = options[:after_fork] if options.key?(:after_fork)
     config.fail_fast = options.fetch(:fail_fast, false)
+    config.kill_matrix = true if options[:kill_matrix]
     config.mutation_types[:strict_equality] = true if options[:strict_equality]
 
     if json_mode
@@ -208,6 +213,11 @@ run_batch_machine = lambda do |batch, passed_for|
   exit(passed ? 0 : 1)
 end
 
+if options[:kill_matrix] && options[:fail_fast]
+  usage_error.call('--kill-matrix cannot be combined with --fail-fast.',
+                   '--fail-fast stops the run at the first surviving mutant, which would leave the kill matrix incomplete; drop one of the two flags.')
+end
+
 if options[:since] && !glob_mode
   usage_error.call('--since requires --glob (batch mode).',
                    'Usage: mutation_test --glob "lib/**/*.rb" --since origin/main')
@@ -360,7 +370,7 @@ if json_mode
   end
 
   reporter = MutationTester::Reporters::JsonReporter.new(
-    core.results, core.source_file, core.spec_file, core.config, interrupted: core.interrupted?
+    core.results, core.source_file, core.spec_file, core.config, interrupted: core.interrupted?, tests: core.tests
   )
 
   unless core.results.empty?

data/lib/mutation_tester/batch_runner.rb

@@ -22,7 +22,7 @@ module MutationTester
 
     SKIP_ORDER = %i[missing not_ruby test_file no_spec].freeze
 
-    ProcessedEntry = Struct.new(:source_file, :spec_file, :score, :passed, :output_dir, :results, :interrupted, :degraded, keyword_init: true) do
+    ProcessedEntry = Struct.new(:source_file, :spec_file, :score, :passed, :output_dir, :results, :interrupted, :degraded, :tests, keyword_init: true) do
       def passed?
         passed
       end
@@ -230,7 +230,8 @@ module MutationTester
         output_dir: file_config.output_dir,
         results: core.results,
         interrupted: core.interrupted?,
-        degraded: core.infrastructure_failure?
+        degraded: core.infrastructure_failure?,
+        tests: core.tests
       )
       [entry, core.stopped_on_survivor?]
     end

data/lib/mutation_tester/configuration.rb

@@ -33,7 +33,8 @@ module MutationTester
       :show_file_path,
       :show_progress,
       :test_selection,
-      :fail_fast
+      :fail_fast,
+      :kill_matrix
 
     def initialize
       self.parallel_processes = ENV['MUTATION_TESTER_PARALLEL_PROCESSES'] || self.class.auto_parallel_processes
@@ -66,6 +67,7 @@ module MutationTester
       @show_progress = true
       @test_selection = true
       @fail_fast = false
+      @kill_matrix = false
     end
 
     def merge(options)

data/lib/mutation_tester/core.rb

@@ -2,7 +2,7 @@ require_relative 'progress_display'
 
 module MutationTester
   class Core
-    attr_reader :source_file, :spec_file, :mutations, :results, :config
+    attr_reader :source_file, :spec_file, :mutations, :results, :config, :tests
 
     def initialize(source_file, spec_file, config = MutationTester.configuration)
       @source_file = File.expand_path(source_file)
@@ -10,6 +10,7 @@ module MutationTester
       @config = config
       @mutations = []
       @results = []
+      @tests = []
       @parse_failed = false
       @shadow_aborted = false
       MutationRunner.recover_in_place_backup(@source_file)
@@ -18,6 +19,7 @@ module MutationTester
 
     def run
       print_header
+      return report_conflicting_modes if @config.kill_matrix && @config.fail_fast
       return false unless run_original_tests
 
       generate_mutations
@@ -98,14 +100,35 @@ module MutationTester
         return false
       end
       puts Rainbow('✓ Original tests passed').green
+      @tests = recorded_tests(result.tests)
+      return report_unrecorded_baseline if @config.kill_matrix && @tests.empty?
+
       @config.baseline_duration = baseline_elapsed
       true
     end
 
+    def report_conflicting_modes
+      puts Rainbow('❌ kill_matrix cannot be combined with fail_fast.').red
+      puts Rainbow('   fail_fast stops the run at the first surviving mutant, which would leave the kill matrix incomplete.').red
+      false
+    end
+
+    def report_unrecorded_baseline
+      puts Rainbow('❌ The kill matrix could not record a single test of the passing baseline run.').red
+      puts Rainbow('   Without the list of tests it cannot tell which tests kill a mutant, so the run is aborted instead of').red
+      puts Rainbow('   reporting an empty matrix. Usual causes: the test file defines no tests, or a plugin or hook replaces').red
+      puts Rainbow('   the test framework reporters or ends the process before the results are written.').red
+      false
+    end
+
     def monotonic_time
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
+    def recorded_tests(entries)
+      Array(entries).uniq { |entry| entry[:id] }.sort_by { |entry| [entry[:line].to_i, entry[:id]] }
+    end
+
     def replay_baseline_output(output)
       return if output.nil? || output.strip.empty?
 
@@ -161,11 +184,14 @@ module MutationTester
 
       progress_display = ProgressDisplay.new(@mutations.size, @config)
 
-      @results = mutation_runner.run(@mutations) do |mutation, index|
-        progress_display.update(mutation, index)
+      begin
+        @results = mutation_runner.run(@mutations) do |_mutation, index, result|
+          progress_display.update(index, result)
+        end
+        progress_display.finish
+      ensure
+        progress_display.stop
       end
-
-      progress_display.finish
       puts Rainbow("✓ Completed #{@results.size} mutations").green
     end
 
@@ -186,11 +212,11 @@ module MutationTester
     def create_reporter(type)
       case type
       when :console
-        Reporters::ConsoleReporter.new(@results, @source_file, @spec_file, @config, interrupted: interrupted?)
+        Reporters::ConsoleReporter.new(@results, @source_file, @spec_file, @config, interrupted: interrupted?, tests: @tests)
       when :html
-        Reporters::HtmlReporter.new(@results, @source_file, @spec_file, @config, interrupted: interrupted?)
+        Reporters::HtmlReporter.new(@results, @source_file, @spec_file, @config, interrupted: interrupted?, tests: @tests)
       when :json
-        Reporters::JsonReporter.new(@results, @source_file, @spec_file, @config, interrupted: interrupted?)
+        Reporters::JsonReporter.new(@results, @source_file, @spec_file, @config, interrupted: interrupted?, tests: @tests)
       end
     end
 
@@ -198,7 +224,9 @@ module MutationTester
       TestCommand.new(
         @spec_file,
         use_bundle_exec: TestCommand.use_bundle_exec?(@source_file),
-        runner: @config.runner
+        runner: @config.runner,
+        record: @config.kill_matrix ? :all : nil,
+        record_root: @config.kill_matrix ? mutation_runner.recording_root : nil
       )
     end
 

data/lib/mutation_tester/fork_runner/worker.rb

@@ -10,11 +10,12 @@ STDOUT.reopen(File::NULL)
 framework = ARGV.shift == 'minitest' ? :minitest : :rspec
 
 if framework == :minitest
-  require 'minitest'
   require_relative '../minitest_fail_fast'
-  Minitest.class_variable_set(:@@installed_at_exit, true)
+  require_relative '../test_recorder/minitest_hook'
+  MutationTester::MinitestLoadHook.on_load { Minitest.class_variable_set(:@@installed_at_exit, true) }
 else
   require 'rspec/core'
+  require_relative '../test_recorder/rspec_hook'
 end
 
 kill_group = lambda do |pid|

data/lib/mutation_tester/fork_runner.rb

@@ -190,8 +190,8 @@ module MutationTester
       [false, 'the fork runner worker terminated unexpectedly']
     end
 
-    def execute_in_memory(source:, path:, timeout: nil, chdir: nil)
-      job = { in_memory: { source: source, path: path }, timeout: timeout, chdir: chdir }
+    def execute_in_memory(source:, path:, timeout: nil, chdir: nil, env: nil)
+      job = { in_memory: { source: source, path: path }, timeout: timeout, chdir: chdir, env: env }
       @job_writer.puts(JSON.generate(job))
       event = await_result(timeout)
       InMemoryOutcome.new(event['status'], event['message'])

data/lib/mutation_tester/minitest_fail_fast.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'minitest_load_hook'
+
 module MutationTester
   module MinitestFailFast
     PLUGIN_NAME = :mutation_tester_fail_fast
@@ -12,11 +14,7 @@ module MutationTester
   end
 end
 
-begin
-  require 'minitest'
-rescue LoadError
-  Kernel.warn '[MutationTester] minitest is not loadable here; mutant runs will execute every test instead of stopping at the first failure.'
-else
+MutationTester::MinitestLoadHook.on_load do
   module MutationTester
     module MinitestFailFast
       class Reporter < Minitest::AbstractReporter

data/lib/mutation_tester/minitest_load_hook.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module MutationTester
+  module MinitestLoadHook
+    class << self
+      def on_load(&block)
+        return block.call if loaded?
+
+        callbacks << block
+        trace.enable unless trace.enabled?
+      end
+
+      private
+
+      def loaded?
+        return false unless defined?(::Minitest::AbstractReporter)
+
+        ::Minitest.respond_to?(:register_plugin) && ::Minitest.respond_to?(:extensions) && !::Minitest.extensions.nil?
+      end
+
+      def callbacks
+        @callbacks ||= []
+      end
+
+      def trace
+        @trace ||= TracePoint.new(:end) do |point|
+          next unless defined?(::Minitest) && point.self.equal?(::Minitest) && loaded?
+
+          @trace.disable
+          callbacks.shift.call until callbacks.empty?
+        end
+      end
+    end
+  end
+end