mutineer 1.7.0 → 1.8.0

data/lib/mutineer/minitest_integration/kill_recorder.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "outer_reporter"
+require_relative "in_test_database_error"
 require_relative "../kill_channel"
 
 module Mutineer
@@ -22,7 +23,7 @@ module Mutineer
       # Prepended on each loaded test class: one test's run. Serial and parallel
       # runs both call it, in Minitest 5 and 6.
       module MarkSkippedTest
-        # Runs the test inside a `skip` region once a serial test has killed.
+        # Runs the test inside a `skip` region once a serial test has failed.
         #
         # @return [Minitest::Result]
         def run
@@ -35,7 +36,7 @@ module Mutineer
       # A run without `--matrix` skips both after a stop (see
       # StopAtFirstFailure::SkipAfterStop6).
       module MarkSkippedClass6
-        # Runs the class inside a `skip` region once a serial test has killed.
+        # Runs the class inside a `skip` region once a serial test has failed.
         #
         # @param reporter [Minitest::CompositeReporter]
         # @param options [Hash]
@@ -46,7 +47,7 @@ module Mutineer
         end
 
         # Runs one test's class-level step inside a `skip` region once a
-        # serial test has killed.
+        # serial test has failed.
         #
         # @param klass [Class]
         # @param method_name [String]
@@ -59,7 +60,7 @@ module Mutineer
 
       # The Minitest 5 form of {MarkSkippedClass6}.
       module MarkSkippedClass5
-        # Runs the class inside a `skip` region once a serial test has killed.
+        # Runs the class inside a `skip` region once a serial test has failed.
         #
         # @param reporter [Minitest::CompositeReporter]
         # @param options [Hash]
@@ -70,7 +71,7 @@ module Mutineer
         end
 
         # Runs one test's class-level step inside a `skip` region once a
-        # serial test has killed.
+        # serial test has failed.
         #
         # @param klass [Class]
         # @param method_name [String]
@@ -114,11 +115,11 @@ module Mutineer
         # @return [Integer, nil]
         attr_accessor :seen
 
-        # True once a serial test killed: from then on, a run without `--matrix`
-        # skips each later test and class.
+        # True once a serial test failed, including a database failure: from
+        # then on, a run without `--matrix` skips each later test and class.
         #
         # @return [Boolean, nil]
-        attr_accessor :serial_killed
+        attr_accessor :serial_failed
 
         # Installs the hooks, arms the recorder for this process, and writes the
         # channel's `start` line. Call it after the test files load, so the
@@ -149,7 +150,7 @@ module Mutineer
           # the run joins it without running, which would break the count.
           self.runnables = runnables.dup
           self.seen = 0
-          self.serial_killed = false
+          self.serial_failed = false
           KillChannel.write_start(channel)
           true
         end
@@ -186,7 +187,7 @@ module Mutineer
           self.armed_reporter = nil
           self.channel = nil
           self.runnables = nil
-          self.serial_killed = false
+          self.serial_failed = false
         end
 
         # Writes the `parallel` line when the first parallel class starts on the
@@ -206,7 +207,7 @@ module Mutineer
         end
 
         # Runs the block between `skip` and `unskip` when a serial test has
-        # killed in this armed process, else just runs it. No `ensure`: a block
+        # failed in this armed process, else just runs it. No `ensure`: a block
         # that never returns (an exit, a crash) must leave its region open, so
         # the parent knows the child ended where a run without `--matrix`
         # would not have been.
@@ -214,7 +215,7 @@ module Mutineer
         # @yieldreturn [Object]
         # @return [Object] the block's value.
         def skipping
-          open = channel && serial_killed && armed_here?
+          open = channel && serial_failed && armed_here?
           KillChannel.write_skip(channel) if open
           value = yield
           KillChannel.write_unskip(channel) if open
@@ -222,9 +223,10 @@ module Mutineer
         end
 
         # Sends one result recorded on `reporter`: a pass, or a kill for a
-        # failure or an error. Skips send no test line, though they count as
-        # seen, and results on other reporters count for nothing. The
-        # `parallel` line goes out when the first parallel class starts (see
+        # failure or an error, or an unavailable database outcome. Skips send
+        # no test line, though they count as seen, and results on other
+        # reporters count for nothing. The `parallel` line goes out when the
+        # first parallel class starts (see
         # {.class_starting}), so a kill that precedes it came from a serial test.
         #
         # @param reporter [Minitest::CompositeReporter] the recording reporter.
@@ -251,8 +253,14 @@ module Mutineer
         def send_result(result)
           return if result.skipped?
 
-          event = result.passed? ? KillChannel::PASS : KillChannel::KILL
-          self.serial_killed = true if event == KillChannel::KILL && !parallel_marked
+          event = if result.passed?
+                    KillChannel::PASS
+                  elsif InTestDatabaseError.database_error(result.failures.first)
+                    KillChannel::UNAVAILABLE
+                  else
+                    KillChannel::KILL
+                  end
+          self.serial_failed = true if event != KillChannel::PASS && !parallel_marked
           file, line = Array(result.source_location)
           KillChannel.write(channel, event, file, *name_and_id(result, line))
         rescue StandardError

data/lib/mutineer/minitest_integration.rb

@@ -2,11 +2,13 @@
 
 require_relative "minitest_integration/stop_at_first_failure"
 require_relative "minitest_integration/kill_recorder"
+require_relative "minitest_integration/in_test_database_error"
 
 module Mutineer
   # Child-process-only: loads a test file in the current process and runs it
   # programmatically, returning an exit status integer (0 = all passed,
-  # 1 = any failure/error).
+  # 1 = any failure/error, 2 = the first failure was an Active Record
+  # connection or lock error).
   #
   # Never call this in the parent — it manipulates global Minitest state
   # (autorun, runnables) that only makes sense in a throwaway forked child.
@@ -14,15 +16,39 @@ module Mutineer
   # A missing minitest is rescued as FrameworkUnavailable (Isolation.run
   # still turns that raise into exit 2). There is no rescue around the
   # suite run itself: Isolation.run's fork block is the single exception
-  # boundary for unexpected errors. Swallowing those here would create a
-  # second exit-2 path and break this method's 0/1 return contract.
+  # boundary for unexpected errors. Swallowing those here would hide a
+  # crash as a verdict. The one 2 this method returns on purpose comes from
+  # Minitest's own results: the run's first failing test failed with an
+  # Active Record connection or lock error (#296, {InTestDatabaseError}).
   class MinitestIntegration
-    # The seed of a mutant run (one that stops at the first failure, or a
-    # `--matrix` run that records every test), unless `SEED` is set. With the
-    # stop, the test order can decide `killed` vs `timeout`; a fixed order keeps
-    # the verdict stable for a `--baseline` gate. A matrix run uses the same
+    # The seed of every Minitest run Mutineer starts, unless `SEED` is set:
+    # coverage capture, the clean checks and the mutant runs (#282). A file's
+    # clean check then runs its tests in the order a mutant run of that file
+    # uses. Several covering files can still differ from the combined clean
+    # check: a smaller class list shuffles differently. With the stop,
+    # the test order can decide `killed` vs `timeout`; a fixed order keeps the
+    # verdict stable for a `--baseline` gate. A `--matrix` run uses the same
     # order, so its first failure comes at the same point as the stop's.
-    STOP_AT_FIRST_FAILURE_SEED = 1
+    #
+    # @api private
+    PINNED_SEED = 1
+
+    # The arguments that give `Minitest.run` the shared seed. With `SEED` set,
+    # none: Minitest reads `SEED` itself.
+    #
+    # @api private
+    # @return [Array<String>] `["--seed", "1"]`, or `[]` when `SEED` is set.
+    def self.seed_args
+      ENV["SEED"] ? [] : ["--seed", seed]
+    end
+
+    # The seed the Minitest runs use: `SEED` when set, else {PINNED_SEED}.
+    #
+    # @api private
+    # @return [String]
+    def self.seed
+      ENV.fetch("SEED", PINNED_SEED.to_s)
+    end
 
     # Tested via runner_test.rb, not in isolation — a direct unit test
     # would require forking and duplicate isolation_test's coverage.
@@ -36,7 +62,8 @@ module Mutineer
     #   test. Only the mutant path passes true.
     # @param record_to [IO, nil] a `--matrix` run: send each test's outcome to
     #   this channel (see {KillRecorder}) and run every test.
-    # @return [Integer] 0 on success, 1 on failure.
+    # @return [Integer] 0 on success, 1 on failure, 2 when the first failure
+    #   was an Active Record connection or lock error (see {InTestDatabaseError}).
     # @raise [ArgumentError] when both options are given: a matrix run never stops.
     def self.run(test_files, stop_at_first_failure: false, record_to: nil)
       if stop_at_first_failure && record_to
@@ -75,22 +102,25 @@ module Mutineer
         elsif stop_at_first_failure
           StopAtFirstFailure.arm!(Minitest::Runnable.runnables)
         end
-      # Pin the seed only when a hook is armed; an unknown Minitest shape gets
-      # the normal full, randomly ordered run.
-      args = armed && !ENV["SEED"] ? ["--seed", STOP_AT_FIRST_FAILURE_SEED.to_s] : []
+      # An unknown Minitest shape arms no hook and gets a full run, in the
+      # same seeded order.
       keep_file_order(rank) if armed
+      # Every run, on its own line: `armed` decides the file order (#296).
+      InTestDatabaseError.arm!
       # No silencing here: the fork boundary that calls this method has already
       # pointed stdout at File::NULL (see ChildStdout).
-      passed = Minitest.run(args)
+      passed = Minitest.run(seed_args)
       # Reached only when the suite returned: a test that exits the process
       # skips it, and the parent then keeps the row incomplete.
       KillRecorder.finish! if record_to
 
       # A plugin can replace the summary reporter, so a stop decides by itself.
-      passed && !StopAtFirstFailure.stopped_here? ? 0 : 1
+      code = passed && !StopAtFirstFailure.stopped_here? ? 0 : 1
+      InTestDatabaseError.exit_code(code)
     ensure
       StopAtFirstFailure.disarm!
       KillRecorder.disarm!
+      InTestDatabaseError.disarm!
     end
 
     # Runs the test classes in the order of their files (#203). Minitest

data/lib/mutineer/mutators/array_literal.rb

@@ -25,12 +25,14 @@ module Mutineer
       #
       # The operator skips an implicit array (`x = 1, 2`), because it has no
       # brackets. It also skips an array that holds a heredoc, because the
-      # heredoc body stays behind as code.
+      # heredoc body stays behind as code. Only the heredoc skip counts as
+      # declined.
       #
       # @param node [Prism::ArrayNode] array node to inspect.
       # @return [void]
       def emit(node)
-        return if node.opening_loc.nil? || node.elements.empty? || heredoc?(node)
+        return if node.opening_loc.nil? || node.elements.empty?
+        return decline if heredoc?(node)
 
         @mutations << Mutation.new(
           start_offset: node.location.start_offset,

data/lib/mutineer/mutators/base.rb

@@ -20,6 +20,7 @@ module Mutineer
       def mutations_for(subject, source)
         @source = source
         @mutations = []
+        @declined = 0
         @body = subject.def_node.body
         @body&.accept(self)
         drop_dangling_heredocs
@@ -50,8 +51,26 @@ module Mutineer
         @in_undiscovered = outer
       end
 
+      # Returns how many candidates the last {#mutations_for} call declined: an
+      # edit that would split a heredoc from its body, or an equivalent skip
+      # listed in docs/equivalent-skips.md. A declined candidate is never a
+      # mutation, so it is not in the run's total.
+      #
+      # @return [Integer] declined candidates; 0 before the first call.
+      def declined
+        @declined || 0
+      end
+
       private
 
+      # Counts one declined candidate.
+      #
+      # @return [nil] so a skip line reads `return decline if ...`.
+      def decline
+        @declined += 1
+        nil
+      end
+
       # Drops a mutation that splits a heredoc opener from its body.
       #
       # The body sits past the opener's node. Replacing the opener with text
@@ -61,10 +80,13 @@ module Mutineer
       # the replaced range holds the body but the replacement keeps only the
       # opener, the opener has no body and the source does not parse. A
       # replacement that copies the opener and the body together stays.
+      # Each dropped mutation counts as declined.
       #
       # @return [void]
       def drop_dangling_heredocs
+        before = @mutations.size
         @mutations.reject! { |mutation| dangling_heredoc?(mutation) }
+        @declined += before - @mutations.size
       end
 
       # Returns whether the mutation replaces a heredoc opener and keeps the

data/lib/mutineer/mutators/call_to_receiver.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "base"
-require_relative "chain_link"
 
 module Mutineer
   module Mutators
@@ -21,11 +20,14 @@ module Mutineer
     # that is the receiver of a dotted call, or of a call write or a call
     # target, is a link, so it gets no mutant here. The two operators give the
     # same source only when the last call repeats the link before it, as in
-    # `node.name.name`.
+    # `node.name.name`. When both edits start on the same line, the job plan
+    # runs one copy, the `chain_link` one (#275).
     #
-    # Calls in {ChainLink::SKIPPED} are never replaced. On the last call,
-    # `x.to_s` is the same as `x` for the same reason as on a link. `Foo.new`
-    # becomes the class, and almost any use of the class raises.
+    # Calls in {SKIPPED} are never replaced; each one counts as declined. The
+    # list is shorter than {ChainLink::SKIPPED}: on the last call, a conversion
+    # such as `to_s` or `to_i` decides the type of the value that the
+    # expression returns, so `m[1].to_i` becomes `m[1]`. `Foo.new` becomes the
+    # class, and almost any use of the class raises.
     #
     # A call is not replaced when its name is an operator (`a.+(1)`), or a
     # setter (`a.b = 1`). A call with no dot (`a + b`, `a[0]`) is not replaced.
@@ -33,6 +35,17 @@ module Mutineer
       # Matches the name of a call written as a word, not as an operator.
       WORD_NAME = /\A[[:alpha:]_]/
 
+      # Method names whose last call is never replaced. A name is here when
+      # its mutant is most often equivalent, or when almost any test that runs
+      # the line kills it. `freeze` and `itself` return the receiver. `dup`
+      # and `clone` return a copy, so the mutant shows when code later changes
+      # the copy or the original, or compares the result with the original by
+      # identity. Dropping `to_set` most often leaves an Array, which answers
+      # `include?` and `empty?` as a Set does (it keeps duplicates, so `size`
+      # and `each` can differ). `new` leaves the class in place of an
+      # instance, which almost any test that runs the line kills.
+      SKIPPED = %i[new dup clone freeze itself to_set].freeze
+
       # Resets the per-subject record of calls that are links.
       #
       # @param subject [Mutineer::Subject] subject whose body is visited.
@@ -104,7 +117,7 @@ module Mutineer
       end
 
       # Emits the replacement of a call by its receiver, unless the name is an
-      # operator, a setter, or in {ChainLink::SKIPPED}.
+      # operator, a setter, or in {SKIPPED}.
       #
       # @param node [Prism::CallNode] the dotted call to replace.
       # @return [void]
@@ -112,7 +125,7 @@ module Mutineer
         name = node.name.to_s
         return unless name.match?(WORD_NAME)
         return if name.end_with?("=")
-        return if ChainLink::SKIPPED.include?(node.name)
+        return decline if SKIPPED.include?(node.name)
 
         receiver = node.receiver.location
         @mutations << Mutation.new(

data/lib/mutineer/mutators/chain_link.rb

@@ -16,16 +16,16 @@ module Mutineer
     # The mutant survives when no test tells the chain apart from the same chain
     # without that step: a scope, a filter or a lookup the tests never see.
     #
-    # Links in {SKIPPED} are never dropped. On a value that already has the
-    # target type or needs no copy, a conversion (`name.to_s.strip`) or a copy
-    # (`list.dup.sort`) is a no-op, so dropping it most often makes an
-    # equivalent mutant. Dropping `new` sends the next call to the class, which
+    # Links in {SKIPPED} are never dropped; each one counts as declined. On a
+    # value that already has the target type or needs no copy, a conversion
+    # (`name.to_s.strip`) or a copy (`list.dup.sort`) is a no-op, so dropping
+    # it most often makes an equivalent mutant. Dropping `new` sends the next call to the class, which
     # raises (killed by any test that runs the line) or reaches a class method
     # that builds the instance itself (equivalent); neither says anything about
     # the tests.
     class ChainLink < Base
       # Method names whose link is never dropped: core conversions and copies,
-      # plus `new`. {CallToReceiver} uses the same list for the last call.
+      # plus `new`. {CallToReceiver} has its own shorter list for the last call.
       SKIPPED = %i[
         to_s to_str to_sym to_i to_int to_f to_r to_c to_a to_ary to_h to_hash to_proc to_set
         dup clone freeze itself
@@ -100,7 +100,7 @@ module Mutineer
         link = top.receiver
         while dotted?(link)
           @links[link] = true
-          drop(link) unless SKIPPED.include?(link.name)
+          SKIPPED.include?(link.name) ? decline : drop(link)
           link = link.receiver
         end
       end

data/lib/mutineer/mutators/condition_forcing.rb

@@ -22,7 +22,8 @@ module Mutineer
     # as the `nil` that `statement_removal` or `return_nil` puts in place of the
     # whole conditional. It is still made: dropping it would make the mutants
     # of one operator depend on which other operators run, and on what the user
-    # suppressed for them. The two then get the same verdict.
+    # suppressed for them. The two then get the same verdict. Their text
+    # differs, so the job plan's drop of a repeated edit (#275) keeps both.
     #
     # `condition_negation` wraps the condition in `!( ... )`, which neither
     # forced value is.
@@ -53,13 +54,15 @@ module Mutineer
       private
 
       # Emits the forced condition unless the condition is a literal or holds a
-      # heredoc, whose body would stay behind as code.
+      # heredoc, whose body would stay behind as code. The heredoc skip counts
+      # as declined; the literal skip does not.
       #
       # @param node [Prism::IfNode, Prism::UnlessNode] the conditional.
       # @return [void]
       def force(node)
         predicate = node.predicate
-        return if LITERALS.include?(unwrap(predicate).class) || heredoc?(predicate)
+        return if LITERALS.include?(unwrap(predicate).class)
+        return decline if heredoc?(predicate)
 
         loc = predicate.location
         @mutations << Mutation.new(

data/lib/mutineer/mutators/operand_removal.rb

@@ -37,13 +37,15 @@ module Mutineer
 
       # Emits one mutation that keeps the left operand, then one that keeps
       # the right operand. The order is fixed, because the two mutants share
-      # a token and their occurrence ordinals tell them apart.
+      # a token and their occurrence ordinals tell them apart. A removed
+      # operand that holds a heredoc counts as declined; a kept jump does not.
       #
       # @param node [Prism::AndNode, Prism::OrNode] connector node.
       # @return [void]
       def emit(node)
         [[node.left, node.right], [node.right, node.left]].each do |kept, removed|
-          next if JUMPS.any? { |type| kept.is_a?(type) } || heredoc?(removed)
+          next if JUMPS.any? { |type| kept.is_a?(type) }
+          next decline if heredoc?(removed)
 
           @mutations << Mutation.new(
             start_offset: node.location.start_offset,

data/lib/mutineer/mutators/range_literal.rb

@@ -10,24 +10,125 @@ module Mutineer
     # `..` -> `...` mutant survives when no test checks the last element.
     # Flip-flops are FlipFlopNode, not RangeNode, so this mutator skips them.
     #
-    # Endless ranges (`1..`, `1..nil`) are skipped. `(1..)` and `(1...)` give
-    # the same result for slicing, `include?`, `===`, `size` and patterns, so
-    # the mutant is equivalent and no normal test can kill it.
+    # An endless range (`1..`, `1..nil`) is skipped only when it is a direct
+    # index argument of a call in {SLICE_CALLS} or of an index write
+    # (`a[1..] += x`). There `(1..)` and `(1...)` select the same elements, so
+    # the mutant is equivalent, and each skipped range counts as declined.
+    # Every other endless range is swapped, because the two ranges differ on
+    # `==`, `hash`, `exclude_end?` and `to_s`, so a test can kill it. This
+    # includes the value of `h[:k] = 1..` and a call on a class, such as
+    # `Array[1..]`, which builds a value and does not slice.
     class RangeLiteral < Base
       # Maps each range operator to its opposite.
       SWAPS = { ".." => "...", "..." => ".." }.freeze
 
+      # Calls whose direct endless-range index arguments are not mutated. They
+      # select the same elements for `(1..)` and `(1...)`. The check uses the
+      # name, and a class receiver is not skipped. The assigned value of `[]=`
+      # is not an index, so it is mutated.
+      SLICE_CALLS = %i[[] []= slice slice! byteslice bytesplice values_at].freeze
+
+      # Resets the per-subject record of endless ranges that are slice arguments.
+      #
+      # @param subject [Mutineer::Subject] subject whose body is visited.
+      # @param source [String] full source text for byte-based slicing.
+      # @return [Array<Mutineer::Mutation>] collected mutations.
+      def mutations_for(subject, source)
+        @slice_args = {}.compare_by_identity
+        super
+      end
+
+      # Visits a call. Records the range arguments of a call in {SLICE_CALLS},
+      # unless the receiver is a class.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        record_slice_args(node) if SLICE_CALLS.include?(node.name)
+        super
+      end
+
+      # Visits `a[1..] += x`. Its index arguments are slice arguments.
+      #
+      # @param node [Prism::IndexOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_index_operator_write_node(node)
+        record_slice_args(node)
+        super
+      end
+
+      # Visits `a[1..] ||= x`. Its index arguments are slice arguments.
+      #
+      # @param node [Prism::IndexOrWriteNode] node to inspect.
+      # @return [void]
+      def visit_index_or_write_node(node)
+        record_slice_args(node)
+        super
+      end
+
+      # Visits `a[1..] &&= x`. Its index arguments are slice arguments.
+      #
+      # @param node [Prism::IndexAndWriteNode] node to inspect.
+      # @return [void]
+      def visit_index_and_write_node(node)
+        record_slice_args(node)
+        super
+      end
+
+      # Visits an index used as an assignment target, as in `a[1..], b = x, y`.
+      # Its index arguments are slice arguments.
+      #
+      # @param node [Prism::IndexTargetNode] node to inspect.
+      # @return [void]
+      def visit_index_target_node(node)
+        record_slice_args(node)
+        super
+      end
+
       # Visits range nodes and emits range mutations.
       #
       # @param node [Prism::RangeNode] range node to inspect.
       # @return [void]
       def visit_range_node(node)
-        emit(node) unless endless?(node)
+        if endless?(node) && @slice_args.key?(node)
+          decline
+        else
+          emit(node)
+        end
         super # nested ranges ((1..2)...(3..4)) each get their own mutation
       end
 
       private
 
+      # Records each range that is a direct argument of the node. For a `[]=`
+      # call the last argument is the assigned value, not an index, so it is
+      # left out. Nothing is recorded when the receiver is a class, as in
+      # `Array[1..]` or `Registry[1..] ||= x`.
+      #
+      # @param node [Prism::Node] call or index node that responds to `arguments`.
+      # @return [void]
+      def record_slice_args(node)
+        return if class_receiver?(node)
+
+        args = node.arguments&.arguments || []
+        args = args[0...-1] if node.is_a?(Prism::CallNode) && node.name == :[]=
+        args.each { |arg| @slice_args[arg] = true if arg.is_a?(Prism::RangeNode) }
+      end
+
+      # Whether the receiver of a call or index write names a class or module, as in
+      # `Array[1..]` or `Foo::Bar[1..]`. Such a call builds a value, so it is not
+      # a slice. A constant in capitals only, as in `ARGV[1..]`, holds a value
+      # that is sliced, so it does not count.
+      #
+      # @param node [Prism::Node] call or index node that responds to `receiver`.
+      # @return [Boolean]
+      def class_receiver?(node)
+        receiver = node.receiver
+        return false unless receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
+
+        receiver.name.to_s.match?(/[a-z]/)
+      end
+
       # Whether the range has no end: `1..` or `1..nil`.
       #
       # @param node [Prism::RangeNode] range node to inspect.

data/lib/mutineer/mutators/return_nil.rb

@@ -16,6 +16,7 @@ module Mutineer
       def mutations_for(subject, source)
         @source = source
         @mutations = []
+        @declined = 0
         @body = subject.def_node.body
         if @body
           @body.accept(self)       # rule 1 (explicit return nodes in this body)

data/lib/mutineer/orphan_guard.rb

@@ -12,8 +12,19 @@ module Mutineer
     POLL = 0.5
     # `Tempfile.create([".mutineer_daemon", ".rb"])` names the file
     # `.mutineer_daemon<YYYYMMDD>-<pid>-<rand>.rb` (without the dot before #253).
-    # The pid is the child that is loading the mutant.
-    DAEMON_TEMP_PID = /\A\.?mutineer_daemon\d{8}-(\d+)-/
+    # An in-process `.mutineer_mutant` file has the same shape (#295). The pid
+    # is the child that is loading the mutant. An undotted name is a leftover
+    # of a version before 1.7.0, so its pid is not read: a reused pid must not
+    # keep a file that stops the next boot. A held file lock still protects it.
+    TEMP_PID = /\A\.mutineer_(?:daemon|mutant)\d{8}-(\d+)-/
+    # Basename glob for the mutant files of both modes. Tempfile puts hyphens in
+    # the name, so it is not a constant name. The leading dot hides a new file
+    # from Zeitwerk (#253); a file an older version left behind has none, so the
+    # glob matches both. Each boot sweep removes an orphan of either mode, so an
+    # old file of the other mode does not stop the boot (#287). The date and
+    # hyphen after the prefix keep a project's own file, such as
+    # `mutineer_mutant_helper.rb`, out of the sweep.
+    TEMP_BASENAME = "{.,}mutineer_{mutant,daemon}#{"[0-9]" * 8}-*.rb"
 
     # Starts the watchdog in the current (child) process.
     #
@@ -29,7 +40,7 @@ module Mutineer
       end
     end
 
-    # True when a daemon mutant file still belongs to a live process. A boot
+    # True when a mutant file still belongs to a live process. A boot
     # sweep must leave it alone. The database lock is taken later, so the
     # sweep is the step that used to delete another run's file.
     #
@@ -37,19 +48,20 @@ module Mutineer
     # file lock counts too, even when that pid is already gone. A dead pid
     # and a free lock is an orphan a killed child left behind.
     #
-    # @param path [String] absolute path of a `.mutineer_daemon*.rb` file.
+    # @param path [String] absolute path of a `.mutineer_daemon*.rb` or
+    #   `.mutineer_mutant*.rb` file.
     # @return [Boolean]
     def self.mutant_file_in_use?(path)
       creator_alive?(path) || locked_by_another?(path)
     end
 
-    # True when the pid embedded in a daemon mutant file name is still running.
+    # True when the pid embedded in a mutant file name is still running.
     # Pid 0 is this process group, so it is never treated as an owner.
     #
     # @param path [String]
     # @return [Boolean]
     def self.creator_alive?(path)
-      pid_text = File.basename(path)[DAEMON_TEMP_PID, 1]
+      pid_text = File.basename(path)[TEMP_PID, 1]
       return false unless pid_text
 
       pid = Integer(pid_text, 10)