mutineer 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a96e7bad1e1cf8d106957e770418e6a1854c677943114b9bc45421c4e06da7f2
-  data.tar.gz: c404d87071f3d270566e368ac70153f1e87c940eb170b220b972fb1b28b29889
+  metadata.gz: 1ca70f2affdf60ddda53d3d38e23ddff4ba6cae27cd789501c7fe3060975f146
+  data.tar.gz: 94a9968fe182655e6d566e9edfc43f1f2e15b050c7690f8905e7be9f7d710b61
 SHA512:
-  metadata.gz: 15417ab5322c43c537953eaa438c18a9a89794f199a9c4666f031daf60f55f6c3ffabcb2e69e15b7ffd030e48b6f2d5d3ab41ee01ccfe9d52dd6c9ee22b4971c
-  data.tar.gz: 1e68e920b3aa610ea1715c16e48e89060e8eba2b2511aafb3c7db0c44e21f8fac077529173befd9acf3afbe2962829cf4534dce371a2f6262628dd507f37469b
+  metadata.gz: 8da96d70db7af241cda4ca44ecbe84522b0c0b68427a46c05e3178723c2eada7d957677c8b2cc7d2853d9593cba546c194f342862058dffdba55d03e8ef27021
+  data.tar.gz: 50481e9ca34d07530878f6ff0f25f192ab63c3200376a1a1ea5665341955a00c6bf2f9e7a4429d6cd8fd8d2119c4316c4c993741f219897f57ab493ca6c428b1

data/CHANGELOG.md

@@ -6,6 +6,97 @@ All notable changes to this project are documented here. The format is based on
 
 ## [Unreleased]
 
+## [1.1.0] - 2026-09-28
+
+### Added
+- **Safe-navigation operator** (Tier-2, opt-in via `--operators`):
+  `safe_navigation` replaces `&.` with `.`. The mutant survives when no test
+  passes `nil` to the call.
+- **Range operator** (Tier-2, opt-in via `--operators`): `range` replaces
+  `..` with `...` and `...` with `..`. The `..` -> `...` mutant survives when
+  no test checks the last element of the range. Endless ranges (`1..`) are
+  skipped, because `(1..)` and `(1...)` give the same result for slicing,
+  `include?`, `===` and pattern matching.
+- **Negation-removal operator** (Tier-2, opt-in via `--operators`):
+  `negation_removal` removes the `!` from `!x` and the `not` from `not x`.
+  The mutant survives when no test depends on the negated value. The
+  explicit form `x.!` is skipped, because `x.` does not parse.
+
+### Changed
+- **Stderr of tests and specs is visible** in the in-process and `--daemon`
+  runs. Mutineer silences stdout once per child process and no longer hides
+  stderr, so its own child diagnostics always reach you. `--test-command`
+  runs still capture stderr with stdout and show it under `--verbose`.
+- **A mutant's test run stops at the first failing test** — one failure
+  already kills the mutant, so the forked child does not run the tests that
+  remain. Killed mutants cost less time, and survived mutants cost the same.
+  Under Minitest, when the outer reporter of the run records a failure or an
+  error (a skip does not count), each remaining test and each remaining test
+  class returns before it starts. A skipped class does not start its
+  class-level hooks. The run does not unwind: a class that is running
+  finishes normally, so its `after_all` hooks and a class-level
+  `transaction { super; raise ActiveRecord::Rollback }` still run. RSpec runs
+  with `--fail-fast`. This applies to the in-process backend only: coverage
+  capture and the clean checks still run every test, and the `--daemon` and
+  `--test-command` backends do not change. The CLI `--fail-fast` flag keeps
+  its meaning. On rack's `lib/rack/utils.rb` (`--jobs 1`), a full run takes
+  about 35–41 s instead of about 86–89 s. With the same coverage map, the
+  verdicts are the same.
+- **The mutant run uses a fixed Minitest seed** — with the stop, the test
+  order can decide the verdict, so the child runs Minitest with seed `1`
+  unless the environment sets `SEED`. The same code then gives the same
+  verdict on each run. Coverage capture and the clean checks keep the random
+  seed, so the clean check runs the tests in a random order while each mutant
+  run uses the fixed order. RSpec keeps its configured order: a suite configured with
+  `config.order = :random` can still get a different verdict on each run for
+  the case below. In an order-dependent Minitest suite, the fixed seed makes
+  a false `killed` happen on every run or on no run, not on some runs.
+- **A mutant whose failing test runs before a hanging test is now `killed`,
+  not `timeout`** — the run stops at the failure, before the hang. The tests
+  did detect the mutation, so `killed` is the correct verdict. If the hanging
+  test runs first in the fixed order, the verdict stays `timeout`. Compared
+  with a baseline from an earlier version, the score usually goes up. In an
+  order-dependent suite it can also go down: a mutant that a random order
+  killed on some runs can survive on every run in the fixed order. A change
+  to the tests can change the fixed order, so a later run can move such a
+  mutant from `killed` to `timeout`, and a `--baseline` gate then reports a
+  score drop.
+- **Some runs still run most tests** — Minitest `parallelize_me!`, and Rails
+  `parallelize` above its threshold (by default more than 50 tests in the
+  child, or at any test count when `PARALLEL_WORKERS` is 2 or more in the
+  environment), queue their tests before the first result comes back, so the
+  queued tests still run. The verdict is the same as before. Below the
+  Rails threshold, the tests run one after the other in the child, and the
+  stop works.
+
+### Fixed
+- **Tests that reopen `$stdout`** (Minitest's `capture_subprocess_io`,
+  RSpec's `to_stdout_from_any_process`) no longer make a green suite
+  "not green" or count as false kills.
+- **Test or source files that print while they load** no longer make coverage
+  capture fail with `invalid coverage output`. The capture subprocess now
+  sends its result over a separate pipe, not over stdout.
+- **Chain-link operator** (Tier-2, opt-in via `--operators`):
+  `chain_link` drops one call from a chain, with its arguments and block
+  (`user.account.name` -> `user.name`). The mutant survives when no test tells
+  the chain apart from the same chain without that step. Conversions and copies
+  (`to_s`, `to_a`, `dup`, `freeze`, ...) and `new` are never dropped.
+
+## [1.0.2] - 2026-09-21
+
+### Added
+- **AI-readable docs wiring**: HTML pages with Markdown twins now advertise
+  `rel="alternate" type="text/markdown"`, `index.md` is the landing/CLI
+  essentials twin, `skill.md` is listed under Optional in `llms.txt`, and
+  `sitemap.xml` is generated from the same catalog as `llms.txt` (#91).
+- **Single-source CLI contract**: exit codes and `--threshold` live in
+  `docs/fragments/contract.yml`; `rake docs:generate` writes `llms-full.txt`,
+  `json-schema.html`, and the marked copies so they cannot drift (#82).
+- **YARD API on Pages**: the current gem's YARD HTML is published at
+  `/api/`, linked from the docs site, and `rake yard:pages:check` keeps it
+  from lagging the shipped sources. `documentation_uri` stays the Pages
+  root (#92).
+
 ## [1.0.1] - 2026-09-18
 
 ### Added
@@ -407,6 +498,8 @@ Rails hardening + CI batch (issues #8–#13), all verified Rails-free.
 - `.mutineer.yml` configuration (CLI > config > default precedence).
 - Byte-correct source handling for multibyte (UTF-8) sources.
 
+[1.1.0]: https://github.com/davidteren/mutineer/releases/tag/v1.1.0
+[1.0.2]: https://github.com/davidteren/mutineer/releases/tag/v1.0.2
 [1.0.1]: https://github.com/davidteren/mutineer/releases/tag/v1.0.1
 [1.0.0]: https://github.com/davidteren/mutineer/releases/tag/v1.0.0
 [0.11.4]: https://github.com/davidteren/mutineer/releases/tag/v0.11.4

data/README.md

@@ -13,6 +13,8 @@ testing anything.
 - **One mutation per mutant**, validity-checked by re-parsing.
 - **Fork-isolated**, parallel execution (Linux + macOS).
 - **Coverage-guided** — each mutant runs only the test files that cover its line.
+- **Stops at the first failing test** — in-process runs (not `--daemon` or
+  `--test-command`) stop a mutant's test run at the first failure.
 
 📖 **[mutineer.github.io →](https://davidteren.github.io/mutineer/)** — overview, operators, and usage.
 
@@ -68,11 +70,13 @@ mutineer run lib/calculator.rb --test test/calculator_test.rb --threshold 90
 
 ### Exit codes
 
+<!-- contract:exit-codes -->
 | Code | Meaning |
 |------|---------|
-| `0` | Score ≥ threshold (or no threshold set) |
-| `1` | Score below threshold, nothing could be scored and something broke, or more than one mutant produced no verdict and they exceed 10% of those attempted, a `--baseline` regression, or a runtime error |
-| `2` | Usage / invalid-flag error |
+| `0` | Score ≥ threshold (or no gate) **and** no baseline regression. |
+| `1` | Score below `--threshold`, OR nothing could be scored and something broke, or more than one mutant produced no verdict and they exceed 10% of those attempted, OR a `--baseline` regression, OR a runtime error. |
+| `2` | Usage / invalid-flag error (mistyped flag, bad path, unreadable baseline). |
+<!-- /contract:exit-codes -->
 
 ### Operators
 
@@ -80,7 +84,7 @@ Run `mutineer --list-operators` to see them. Default (Tier 1): `arithmetic`,
 `comparison`, `boolean_connector`, `boolean_literal`, `statement_removal`.
 Available but off by default (Tier 2, enable via `--operators`): `return_nil`,
 `literal_mutation`, `condition_negation`, `string_literal`, `regex`,
-`collection_method`.
+`collection_method`, `safe_navigation`, `range`, `negation_removal`, `chain_link`.
 
 ## Rails apps
 
@@ -273,6 +277,8 @@ structured exit codes, and diff-scoped runs. See:
   contract:
   [rendered](https://davidteren.github.io/mutineer/json-schema.html) ·
   [source](docs/json-schema.md)
+- **Ruby API (YARD)** — class reference for the shipped gem:
+  [https://davidteren.github.io/mutineer/api/](https://davidteren.github.io/mutineer/api/)
 
 ## Configuration
 

data/lib/mutineer/child_stdout.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mutineer
+  # Silences stdout in a forked child that runs tests. Every fork boundary
+  # calls {.silence} once, right after `fork`, so the test runners themselves
+  # do not touch stdout. The parent reads each child's result from a separate
+  # pipe or from the exit status, never from stdout.
+  #
+  # Stderr stays open: it carries mutineer's own diagnostics from the child.
+  #
+  # Stdlib-only, so the app-side daemon can load it.
+  module ChildStdout
+    # Points fd 1 at File::NULL and makes `$stdout` the real STDOUT again.
+    #
+    # The reopen goes through STDOUT, not `$stdout`: the parent may have left
+    # `$stdout` as a StringIO, which cannot reopen. A test that calls
+    # `$stdout.reopen` (Minitest's `capture_subprocess_io`, RSpec's
+    # `to_stdout_from_any_process`) then gets a real IO. Child processes of the
+    # test inherit the silenced fd 1 too.
+    #
+    # The reopen takes an open IO, not a path. A path reopen checks the access
+    # mode of STDOUT and raises ArgumentError when a parent left STDOUT on a
+    # file in another mode (for example the "w+x" Tempfile of Minitest's
+    # `capture_subprocess_io`).
+    #
+    # Call it only in a child that exits after the tests run. Nothing restores
+    # the previous stdout.
+    #
+    # @return [void]
+    def self.silence
+      File.open(File::NULL, "w") { |null| STDOUT.reopen(null) }
+      $stdout = STDOUT
+    end
+  end
+end

data/lib/mutineer/coverage_map.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
 require "json"
 require "digest"
 require "fileutils"
@@ -9,6 +8,7 @@ require "coverage"
 require "set"
 require_relative "minitest_integration"
 require_relative "test_runners"
+require_relative "child_stdout"
 
 module Mutineer
   # Maps `(source_file, line) -> [test_files]` so each mutant runs only against
@@ -22,6 +22,10 @@ module Mutineer
     # Seconds per coverage subprocess before the parent kills it.
     DEFAULT_CAPTURE_TIMEOUT = 120
 
+    # File descriptor in a capture subprocess that carries the JSON result to
+    # the parent. Stdout stays free for test output, which goes to File::NULL.
+    RESULT_FD = 3
+
     attr_reader :project_root, :failed_test_files, :failed_clean_tests, :phase_a_ran, :map
 
     # Build a QUERY-ONLY map from data captured elsewhere (the daemon builds the
@@ -232,6 +236,7 @@ module Mutineer
         rd.close
         payload =
           begin
+            ChildStdout.silence
             # Fork-safety hook: the in-process path reconnects AR; the daemon
             # routes to its worker DB. Nil (non-Rails) = no-op. Injected so this
             # file needs neither Runner (Prism) nor Rails.
@@ -293,22 +298,8 @@ module Mutineer
     # before any source is loaded. Returns the wrapped capture payload
     # (`passed` + `coverage`), or nil when the subprocess failed (logged + skipped).
     def capture(test_path)
-      out = +""
-      status = nil
-      Open3.popen2(RbConfig.ruby, "-") do |stdin, stdout, wait_thr|
-        stdin.write(subprocess_script(test_path))
-        stdin.close
-        reader = Thread.new { out << stdout.read }
-        # Bound the subprocess with a wall clock: a hanging test file must not
-        # wedge the whole run before any per-mutant timeout.
-        unless wait_thr.join(@capture_timeout)
-          Process.kill(:KILL, wait_thr.pid) rescue nil # rubocop:disable Style/RescueModifier
-          reader.kill
-          return fail_test(test_path, "timed out after #{@capture_timeout}s")
-        end
-        reader.join
-        status = wait_thr.value
-      end
+      status, out = spawn_script(subprocess_script(test_path))
+      return fail_test(test_path, "timed out after #{@capture_timeout}s") unless status
       return fail_test(test_path, "subprocess exited #{status.exitstatus}") unless status.success?
 
       parsed = JSON.parse(out)
@@ -442,20 +433,72 @@ module Mutineer
     # @param test_paths [Array<String>] test file paths.
     # @return [Boolean]
     def subprocess_clean_pass?(test_paths)
-      status = nil
-      Open3.popen2(RbConfig.ruby, "-") do |stdin, stdout, wait_thr|
-        stdin.write(clean_check_script(test_paths))
-        stdin.close
-        reader = Thread.new { stdout.read }
-        unless wait_thr.join(@capture_timeout)
-          Process.kill(:KILL, wait_thr.pid) rescue nil # rubocop:disable Style/RescueModifier
-          reader.kill
-          return false
-        end
-        reader.join
-        status = wait_thr.value
+      status, = spawn_script(clean_check_script(test_paths), result: false)
+      status&.success? || false
+    end
+
+    # Runs `script` in a fresh `ruby -` that reads the script from stdin. The
+    # child's stdout goes to File::NULL, so test output never reaches the user
+    # or the result. With `result: true`, the child writes its result as one
+    # line to fd {RESULT_FD}, a pipe that only the script uses. The child's
+    # stderr is the parent's stderr, so warnings from the script reach the
+    # user. A wall clock of `@capture_timeout` bounds the whole call, so a hung
+    # test cannot wedge the run.
+    #
+    # The parent reads one line, not until EOF: a process that a test leaves
+    # running can inherit fd {RESULT_FD} (a `fork` without `exec` keeps it
+    # despite close-on-exec) and hold the pipe open long after the child exits.
+    # A clean check reports only through its exit status, so it gets no pipe.
+    #
+    # @api private
+    # @param script [String] Ruby script text.
+    # @param result [Boolean] whether to open the result pipe on fd {RESULT_FD}.
+    # @return [Array(Process::Status, String)] the exit status and the line the
+    #   child wrote to fd {RESULT_FD} (`""` without one); `[nil, ""]` after a
+    #   timeout.
+    def spawn_script(script, result: true)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + @capture_timeout
+      script_rd, script_wr = IO.pipe
+      result_rd, result_wr = IO.pipe if result
+      options = { in: script_rd, out: File::NULL }
+      options[RESULT_FD] = result_wr if result
+      pid = Process.spawn(RbConfig.ruby, "-", **options)
+      waiter = Process.detach(pid)
+      script_rd.close
+      result_wr&.close
+      reader = Thread.new { result_rd.gets.to_s } if result
+      script_wr.write(script)
+      script_wr.close
+      unless waiter.join(remaining(deadline))
+        Process.kill(:KILL, pid) rescue nil # rubocop:disable Style/RescueModifier
+        waiter.join
+        reader&.kill
+        return [nil, ""]
       end
-      status&.success?
+      [waiter.value, reader&.join(remaining(deadline))&.value.to_s]
+    ensure
+      reader&.kill
+      [script_rd, script_wr, result_rd, result_wr].compact.each { |io| io.close unless io.closed? }
+    end
+
+    # Seconds left before `deadline`, never negative.
+    #
+    # @api private
+    # @param deadline [Float] a CLOCK_MONOTONIC time.
+    # @return [Float]
+    def remaining(deadline)
+      [deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max
+    end
+
+    # Ruby source that opens the result channel in a {#spawn_script} child. The
+    # script runs it first, so no file that a test opens can take fd
+    # {RESULT_FD}. Close-on-exec keeps the fd out of the test's own
+    # subprocesses.
+    #
+    # @api private
+    # @return [String] Ruby script text.
+    def result_channel_expression
+      "_result = IO.new(#{RESULT_FD}, \"w\"); _result.close_on_exec = true"
     end
 
     # Runs test files in a fork of the booted parent and returns whether they passed.
@@ -473,6 +516,7 @@ module Mutineer
         rd.close
         Process.setpgid(0, 0) rescue nil # rubocop:disable Style/RescueModifier
         begin
+          ChildStdout.silence
           after_fork&.call
           Coverage.result(clear: true, stop: false) if Coverage.running?
           wr.write(Marshal.dump(TestRunners.for(@framework).run(abs_tests).zero?))
@@ -533,12 +577,10 @@ module Mutineer
       loads = Array(test_paths).map { |t| "load #{absolute(t).inspect}" }.join("\n")
       <<~RUBY
         require "minitest"
-        require "stringio"
         def Minitest.autorun; end
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
         #{abs_source_paths.inspect}.each { |f| load f }
         #{loads}
-        $stdout = StringIO.new
         exit(Minitest.run([]) ? 0 : 1)
       RUBY
     end
@@ -561,7 +603,6 @@ module Mutineer
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
         #{abs_source_paths.inspect}.each { |f| load f }
         _sink = StringIO.new
-        $stdout = _sink
         status = RSpec::Core::Runner.run(["--no-color", #{specs}], _sink, _sink)
         exit(status.zero? ? 0 : 1)
       RUBY
@@ -583,31 +624,31 @@ module Mutineer
     # @return [String] Ruby script text.
     def minitest_subprocess_script(test_path)
       <<~RUBY
+        #{result_channel_expression}
         require "coverage"
         require "json"
-        require "stringio"
         require "minitest"
         def Minitest.autorun; end
         Coverage.start(lines: true)
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
         #{abs_source_paths.inspect}.each { |f| load f }
         load #{absolute(test_path).inspect}
-        _orig = $stdout
-        $stdout = StringIO.new
         _passed = Minitest.run([])
-        $stdout = _orig
-        puts JSON.generate("passed" => _passed == true, "coverage" => Coverage.result,
-                           "loaded_files" => #{loaded_files_expression})
+        _result.puts JSON.generate("passed" => _passed == true, "coverage" => Coverage.result,
+                                    "loaded_files" => #{loaded_files_expression})
+        _result.close
       RUBY
     end
 
     # Same coverage-JSON contract as the minitest path, but driven by RSpec:
     # require rspec/core lazily, load the sources under Coverage, then run the
-    # one spec via RSpec::Core::Runner with output silenced so only the JSON
-    # reaches stdout. A missing rspec makes `require` raise -> subprocess exits
-    # non-zero -> capture() records a skipped (incomplete-map) test, with a hint.
+    # one spec via RSpec::Core::Runner. The JSON goes to the result channel (see
+    # {#spawn_script}), so spec output cannot corrupt it. A missing rspec makes
+    # the script exit non-zero -> capture() records a skipped (incomplete-map)
+    # test, with a hint.
     def rspec_subprocess_script(test_path)
       <<~RUBY
+        #{result_channel_expression}
         require "coverage"
         require "json"
         require "stringio"
@@ -621,13 +662,11 @@ module Mutineer
         Coverage.start(lines: true)
         $LOAD_PATH.unshift(*#{abs_load_paths.inspect})
         #{abs_source_paths.inspect}.each { |f| load f }
-        _orig = $stdout
         _sink = StringIO.new
-        $stdout = _sink
         _status = RSpec::Core::Runner.run(["--no-color", #{absolute(test_path).inspect}], _sink, _sink)
-        $stdout = _orig
-        puts JSON.generate("passed" => _status.zero?, "coverage" => Coverage.result,
-                           "loaded_files" => #{loaded_files_expression})
+        _result.puts JSON.generate("passed" => _status.zero?, "coverage" => Coverage.result,
+                                    "loaded_files" => #{loaded_files_expression})
+        _result.close
       RUBY
     end
 

data/lib/mutineer/daemon_client.rb

@@ -56,7 +56,7 @@ module Mutineer
     # this mutant. Never a wrong verdict, never a wedged run.
     #
     # @param id [Integer] request id (echoed back for ordering safety).
-    # @param payload [Hash] {"code" => mutated ruby, "source_file" => path}.
+    # @param payload [Hash] mutated ruby under the "code" key, path under "source_file".
     # @param tests [Array<String>] covering test file paths.
     # @param timeout [Numeric] per-mutant wall-clock timeout (seconds).
     # @param worker [Integer] worker slot; the daemon routes the fork to

data/lib/mutineer/daemon_server.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "tempfile"
+require_relative "child_stdout"
 
 module Mutineer
   # App-side daemon (persistent worker).
@@ -177,9 +178,9 @@ module Mutineer
           # New process group so a per-fork timeout can SIGKILL the whole subtree,
           # and silence the child's stdout so test output never corrupts the IPC pipe.
           Process.setpgid(0, 0) rescue nil # rubocop:disable Style/RescueModifier
-          $stdout.reopen(File::NULL, "w")
           code =
             begin
+              ChildStdout.silence
               # Route THIS fork at its own worker database before any test loads.
               # A routing failure raises here and is scored `error`, never a false verdict.
               @worker_db&.after_fork(worker, schema_for_fork)

data/lib/mutineer/file_swap.rb

@@ -7,6 +7,8 @@ module Mutineer
   # Raised when another process already holds exclusive ownership of a source
   # file. Aborting beats silently restoring (or capturing) the other run's mutant.
   class ConcurrentRunError < StandardError
+    # @param path [String] the source file the other run already owns.
+    # @return [ConcurrentRunError]
     def initialize(path)
       super("another mutineer run owns #{path} — aborting to avoid corrupting the source file.")
     end

data/lib/mutineer/isolation.rb

@@ -3,6 +3,7 @@
 require "tempfile"
 require_relative "result"
 require_relative "parser"
+require_relative "child_stdout"
 
 module Mutineer
   # Fork-based isolation for running one mutant. The block runs in a child
@@ -26,6 +27,9 @@ module Mutineer
     # exit code) or any explicit `exit` is honoured; an unhandled exception
     # becomes exit 2 with the cause written to STDERR.
     #
+    # The child silences its stdout (see {ChildStdout.silence}) before the
+    # block runs, so test output never reaches the user. Stderr stays open.
+    #
     # @param timeout [Integer] timeout in seconds.
     # @yieldreturn [Integer] child exit status.
     # @return [Mutineer::Result] result from the child process.
@@ -36,15 +40,17 @@ module Mutineer
         Process.setpgid(0, 0) rescue nil # rubocop:disable Style/RescueModifier
         code = 0
         begin
+          ChildStdout.silence
           result = yield
           code = result.is_a?(Integer) ? result : 0
         rescue SystemExit => e
           code = e.status
         rescue Exception => e # rubocop:disable Lint/RescueException
-          warn "[mutineer-child] #{e.class}: #{e.message}"
+          # STDERR, not `warn`: a test may have left `$stderr` as a StringIO.
+          STDERR.puts "[mutineer-child] #{e.class}: #{e.message}"
           code = 2
         end
-        $stderr.flush
+        STDERR.flush
         # exit! skips at_exit handlers — critical, since a child forked from
         # inside our own Minitest suite would otherwise re-run the parent's
         # at_exit autorun hook on the way out.