saboteur 0.6.0 → 0.7.0

data/lib/saboteur/install.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "text"
 
 module Saboteur
   # Writes the Rails starter files: config/saboteur.rb, bin/saboteur and a
@@ -64,7 +65,7 @@ module Saboteur
     # Printed after install; the Gemfile is never edited.
     def gemfile_hint
       gemfile = File.join(@root, "Gemfile")
-      return nil if File.file?(gemfile) && File.read(gemfile).match?(/^\s*gem\s+["']saboteur["']/)
+      return nil if File.file?(gemfile) && Text.utf8(File.read(gemfile)).match?(/^\s*gem\s+["']saboteur["']/)
 
       GEMFILE_HINT
     end
@@ -108,8 +109,8 @@ module Saboteur
       link = symlink_component(".gitignore")
       return Result.new(:skipped, ".gitignore") if link && !@force
 
-      current = File.file?(path) ? File.read(path) : ""
-      listed = listed?(current)
+      current = File.file?(path) ? Text.utf8_identity(File.read(path)) : ""
+      listed = listed?(Text.utf8(current))
       return Result.new(:unchanged, ".gitignore") if listed && !link
 
       File.delete(link) if link

data/lib/saboteur/integration/base.rb

@@ -10,8 +10,13 @@ module Saboteur
     # so a kill by a failed assertion can be told from a kill by a crash.
     # failure_messages: the first line of each failure, so a verdict that
     # does not hold up can say why the test failed.
-    RunResult = Data.define(:passed, :failed_ids, :executed_ids, :runtime, :failure_classes, :failure_messages) do
-      def initialize(passed:, failed_ids:, executed_ids:, runtime:, failure_classes: {}, failure_messages: {})
+    # failure_details: the full message and first backtrace frames of each
+    # failure, so a neutral re-run (the verdict check) can say exactly why
+    # the killer failed with the method unchanged (#296).
+    RunResult = Data.define(:passed, :failed_ids, :executed_ids, :runtime, :failure_classes, :failure_messages,
+                            :failure_details) do
+      def initialize(passed:, failed_ids:, executed_ids:, runtime:, failure_classes: {}, failure_messages: {},
+                     failure_details: {})
         super
       end
     end

data/lib/saboteur/integration/rspec.rb

@@ -55,7 +55,8 @@ module Saboteur
         passed = execute(listener)
         RunResult.new(passed: passed && listener.failed.empty?, failed_ids: listener.failed,
                       executed_ids: listener.executed, runtime: listener.runtime,
-                      failure_classes: listener.failure_classes, failure_messages: listener.failure_messages)
+                      failure_classes: listener.failure_classes, failure_messages: listener.failure_messages,
+                      failure_details: listener.failure_details)
       end
 
       def run_all(recorder)
@@ -71,7 +72,8 @@ module Saboteur
         passed = execute(listener, log_phase: true)
         RunResult.new(passed: passed && listener.failed.empty?, failed_ids: listener.failed,
                       executed_ids: listener.executed, runtime: listener.runtime,
-                      failure_classes: listener.failure_classes, failure_messages: listener.failure_messages)
+                      failure_classes: listener.failure_classes, failure_messages: listener.failure_messages,
+                      failure_details: listener.failure_details)
       end
 
       private
@@ -185,8 +187,10 @@ module Saboteur
         EVENTS = %i[example_started example_finished example_failed].freeze
 
         MESSAGE_LIMIT = 200
+        DETAIL_LIMIT = 2_000
+        BACKTRACE_LIMIT = 5
 
-        attr_reader :executed, :failed, :failure_classes, :failure_messages
+        attr_reader :executed, :failed, :failure_classes, :failure_messages, :failure_details
         attr_accessor :runtime
 
         def initialize(recorder = nil)
@@ -195,6 +199,7 @@ module Saboteur
           @failed = []
           @failure_classes = {}
           @failure_messages = {}
+          @failure_details = {}
           @runtime = 0.0
         end
 
@@ -213,12 +218,43 @@ module Saboteur
           exception = notification.example.execution_result.exception
           @failure_classes[notification.example.id] = exception&.class&.name
           @failure_messages[notification.example.id] = first_line(exception&.message)
+          @failure_details[notification.example.id] = detail_for(exception)
         end
 
         private
 
+        # The full failure, class and first frames: a neutral re-run that
+        # fails needs enough context to explain why (the compact first line
+        # alone reads as just "expected: 0").
+        def detail_for(exception)
+          return nil unless exception
+
+          message = Text.utf8("#{exception.class.name}: #{exception.message}")
+          ([message] + relevant_frames(exception)).join("\n")[0, DETAIL_LIMIT]
+        rescue StandardError
+          exception.message.to_s.dump[0, DETAIL_LIMIT]
+        end
+
+        # An expectation failure leads with rspec's own frames (notify_failure,
+        # handle_failure); under the cap they would crowd out the spec line.
+        # Keep the project frames; fall back to the raw ones when rspec itself
+        # raised, so the detail never comes back empty.
+        def relevant_frames(exception)
+          frames = Array(exception.backtrace).map { |frame| Text.utf8(frame.to_s) }
+          project = frames.reject { |frame| frame.include?("/gems/rspec") }
+          (project.empty? ? frames : project).first(BACKTRACE_LIMIT)
+        end
+
         def first_line(message)
-          message.to_s.lines.map(&:strip).find { |line| !line.empty? }.to_s[0, MESSAGE_LIMIT]
+          # Exception messages can carry bytes invalid under the locale encoding
+          # (e.g. a path with raw bytes); scrub before splitting, or .lines/.strip
+          # raises Encoding::CompatibilityError and the run reports error (CI #272).
+          Text.utf8(message.to_s).lines.map(&:strip).find { |line| !line.empty? }.to_s[0, MESSAGE_LIMIT]
+        rescue StandardError
+          # Text.utf8 is mutable code: when the mutant under test breaks it,
+          # the raise must not flip the run to error - the recorded failure
+          # is what classifies the kill. dump is ASCII-safe for any bytes.
+          message.to_s.dump[0, MESSAGE_LIMIT]
         end
       end
     end

data/lib/saboteur/mutation_source/builtin.rb

@@ -13,6 +13,9 @@ require_relative "operator_registry"
 require_relative "range_replacement"
 require_relative "operator_assignment"
 require_relative "condition_negation"
+require_relative "method_swap"
+require_relative "operand_replacement"
+require_relative "interpolation_removal"
 
 module Saboteur
   module MutationSource
@@ -66,6 +69,9 @@ module Saboteur
         @range_replacement = RangeReplacement.new(arid: arid)
         @operator_assignment = OperatorAssignment.new(arid: arid)
         @condition_negation = ConditionNegation.new(arid: arid)
+        @method_swap = MethodSwap.new(arid: arid)
+        @operand_replacement = OperandReplacement.new(arid: arid)
+        @interpolation_removal = InterpolationRemoval.new(arid: arid)
       end
 
       def name
@@ -78,20 +84,20 @@ module Saboteur
         @found = []
         coarse(body)
         visit(body)
-        @found.concat(@filter_replacement.mutations_for(subject))
-        @found.concat(@literal_replacement.mutations_for(subject))
-        @found.concat(@argument_removal.mutations_for(subject))
-        @found.concat(@pair_removal.mutations_for(subject))
-        @found.concat(@chain_removal.mutations_for(subject))
-        @found.concat(@endpoint_replacement.mutations_for(subject))
-        @found.concat(@range_replacement.mutations_for(subject))
-        @found.concat(@operator_assignment.mutations_for(subject))
-        @found.concat(@condition_negation.mutations_for(subject))
+        @found.concat(delegated.flat_map { |source| source.mutations_for(subject) })
         @found.select { |mutation| @operators.include?(mutation.operator) }
       ensure
         @subject = nil
       end
 
+      # The single-purpose sources run after the shared walk, in registration
+      # order; each filters its own operator through the same policy below.
+      def delegated
+        [@filter_replacement, @literal_replacement, @argument_removal, @pair_removal, @chain_removal,
+         @endpoint_replacement, @range_replacement, @operator_assignment, @condition_negation,
+         @method_swap, @operand_replacement, @interpolation_removal]
+      end
+
       private
 
       # --- coarse ---------------------------------------------------------
@@ -185,9 +191,12 @@ module Saboteur
         add("safe_navigation", node.call_operator_loc, ".") if node.safe_navigation?
       end
 
+      # Only the infix spelling is binary: an operator call has no call
+      # operator, and its receiver, message, single argument and lack of a
+      # block all follow from that (a block binds to the last operand's own
+      # call, never to the operator).
       def binary?(node)
-        node.receiver && node.message_loc && node.call_operator_loc.nil? &&
-          node.arguments&.arguments&.size == 1 && node.block.nil?
+        node.call_operator_loc.nil?
       end
 
       def numeric_operands?(node)

data/lib/saboteur/mutation_source/hazard_guard.rb

@@ -31,6 +31,7 @@ module Saboteur
       ].freeze
 
       OPEN3 = /\A(::)?Open3\z/
+      SEND_NAMES = %w[send public_send __send__].freeze
       ALWAYS_NAMES = %w[rmtree].freeze
       KERNEL_RECEIVERS = %w[Kernel Process].freeze
 
@@ -81,6 +82,19 @@ module Saboteur
         name = node.name.to_s
         receiver = node.receiver&.slice&.sub(/\A::/, "")
         return true if OPEN3.match?(receiver.to_s)
+
+        args = node.arguments&.arguments || []
+        # obj.send(:rmtree, x) is obj.rmtree(x) with indirection (#240): the
+        # resolved selector faces the same direct-call semantics, with the
+        # arguments shifted past it (#294 review). A dynamic selector stays
+        # out of scope, as documented.
+        return true if SEND_NAMES.include?(name) && (selector = literal_selector(args.first)) &&
+                       direct_hazard?(selector, receiver, args[1])
+
+        direct_hazard?(name, receiver, args.first)
+      end
+
+      def direct_hazard?(name, receiver, first_arg)
         return true if ALWAYS_NAMES.include?(name)
 
         tag = receiver ? "#{receiver}.#{name}" : name
@@ -89,14 +103,18 @@ module Saboteur
         # spelling of a bare process spawn is the same hazard.
         return true if KERNEL_RECEIVERS.include?(receiver) && @tags.include?(name)
 
-        piped_open?(node, name, receiver)
+        piped_open?(first_arg, name, receiver)
+      end
+
+      # A literal symbol or string selector names the real call.
+      def literal_selector(first)
+        first.unescaped if first.is_a?(Prism::SymbolNode) || first.is_a?(Prism::StringNode)
       end
 
       # Kernel#open with a "| command" argument spawns a process.
-      def piped_open?(node, name, receiver)
+      def piped_open?(first, name, receiver)
         return false unless name == "open" && (receiver.nil? || receiver == "Kernel")
 
-        first = node.arguments&.arguments&.first
         case first
         when Prism::StringNode then first.unescaped.start_with?("|")
         when Prism::InterpolatedStringNode

data/lib/saboteur/mutation_source/interpolation_removal.rb

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+require_relative "operator_visit"
+
+module Saboteur
+  module MutationSource
+    # Removes one piece of an interpolated string at a time: each #{expr}
+    # and each literal segment. Plain strings stay with literal_replacement
+    # and backticks stay untouched (the hazard guard owns those).
+    class InterpolationRemoval < Base
+      include OperatorVisit
+
+      # Base inherits Object's empty initializer; there is no parent state to set.
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "interpolation_removal"
+      end
+
+      private
+
+      def mutate_node(node, subject, found)
+        remove_parts(node, subject, found) if node.is_a?(Prism::InterpolatedStringNode)
+      end
+
+      def remove_parts(node, subject, found)
+        node.parts.each do |part|
+          location = part.location
+          edit = Edit.new(file: subject.file, start_byte: location.start_offset,
+                          end_byte: location.end_offset, replacement: "")
+          found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+        end
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/method_swap.rb

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+require_relative "operator_visit"
+
+module Saboteur
+  module MutationSource
+    # Swaps a method whose name has a semantic opposite: min with max,
+    # any? with all?, map with each. Only message bytes change; receiver,
+    # arguments and block stay intact. A receiver is required, so a bare
+    # max(a, b) Kernel call is left alone.
+    class MethodSwap < Base
+      include OperatorVisit
+
+      SWAPS = { min: "max", max: "min", any?: "all?", all?: "any?", map: "each", each: "map" }.freeze
+
+      # Base inherits Object's empty initializer; there is no parent state to set.
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "method_swap"
+      end
+
+      private
+
+      def mutate_node(node, subject, found)
+        swap(node, subject, found) if node.is_a?(Prism::CallNode)
+      end
+
+      def swap(node, subject, found)
+        replacement = SWAPS[node.name]
+        return unless replacement && node.receiver
+
+        location = node.message_loc
+        edit = Edit.new(file: subject.file, start_byte: location.start_offset,
+                        end_byte: location.end_offset, replacement: replacement)
+        found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/mutation.rb

@@ -15,13 +15,15 @@ module Saboteur
       end
 
       # Stable id for the ignore list. Offsets are made relative to subject_start
-      # so edits elsewhere in the file do not change the id.
+      # so edits elsewhere in the file do not change the id. The digest hashes
+      # bytes, not encodings: a binary-read source and a UTF-8 replacement hold
+      # the same identity, and joining them without .b raises under LANG=C.
       def digest(subject_start:, original_source:)
         parts = edits.map do |edit|
           original = original_source.byteslice(edit.start_byte, edit.end_byte - edit.start_byte)
-          [edit.start_byte - subject_start, original, edit.replacement].join("\0")
+          [edit.start_byte - subject_start, original.to_s.b, edit.replacement.b].join("\0".b)
         end
-        Digest::SHA256.hexdigest([subject_id, operator, *parts].join("\x1F"))[0, 16]
+        Digest::SHA256.hexdigest([subject_id.to_s.b, operator.to_s.b, *parts].join("\x1F".b))[0, 16]
       end
     end
   end

data/lib/saboteur/mutation_source/operand_replacement.rb

@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+require_relative "operator_visit"
+
+module Saboteur
+  module MutationSource
+    # Replaces a binary operation with each of its operands: a + b yields a
+    # and b. Arithmetic and comparison calls only; boolean connectors stay
+    # with boolean_logic, which already replaces a connector with each side.
+    # An operand binds at least as tightly as the operation it replaces, so
+    # it needs no parentheses (the re-parse check backs this).
+    class OperandReplacement < Base
+      include OperatorVisit
+
+      FAMILIES = %i[+ - * / % ** < <= > >= == !=].freeze
+
+      # Base inherits Object's empty initializer; there is no parent state to set.
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "operand_replacement"
+      end
+
+      private
+
+      def mutate_node(node, subject, found)
+        replace_operands(node, subject, found) if node.is_a?(Prism::CallNode)
+      end
+
+      def replace_operands(node, subject, found)
+        return unless FAMILIES.include?(node.name) && binary?(node)
+
+        [node.receiver, *node.arguments.arguments].each do |operand|
+          edit = Edit.new(file: subject.file, start_byte: node.start_offset,
+                          end_byte: node.end_offset, replacement: operand.slice)
+          found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+        end
+      end
+
+      # Only the infix spelling is binary: an operator call has no call
+      # operator, and its receiver, message, single argument and lack of a
+      # block all follow from that (a block binds to the last operand's own
+      # call, never to the operator).
+      def binary?(node)
+        node.call_operator_loc.nil?
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/operator_examples.rb

@@ -28,7 +28,10 @@ module Saboteur
         "chain_removal" => "x.first.to_s -> x.to_s",
         "range" => "1..3 -> 1...3",
         "operator_assignment" => "x += 1 -> x -= 1",
-        "condition_negation" => "x ? a : b -> !(x) ? a : b"
+        "condition_negation" => "x ? a : b -> !(x) ? a : b",
+        "method_swap" => "xs.min -> xs.max",
+        "operand_replacement" => "a + b -> a",
+        "interpolation_removal" => "\"hi \#{name}\" -> \"hi \""
       }.freeze
     end
   end

data/lib/saboteur/mutation_source/operator_registry.rb

@@ -32,7 +32,10 @@ module Saboteur
         "argument_removal" => "Remove a call argument",
         "pair_removal" => "Remove a hash pair",
         "endpoint_replacement" => "Swap explicit no-argument first and last",
-        "chain_removal" => "Remove one call from a method chain"
+        "chain_removal" => "Remove one call from a method chain",
+        "method_swap" => "Swap a method with its semantic opposite",
+        "operand_replacement" => "Replace a binary operation with one operand",
+        "interpolation_removal" => "Remove part of an interpolated string"
       }.freeze
       POLICY_VERSION = 2
       TIERS = { "all" => DESCRIPTIONS.keys.freeze }.freeze

data/lib/saboteur/mutation_source/operator_visit.rb

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+
+module Saboteur
+  module MutationSource
+    # The tree walk shared by the statement-driven operators: visit every
+    # node except nested definitions, skip arid statements, and hand each
+    # remaining node to the operator's mutate_node hook.
+    module OperatorVisit
+      SCOPE_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+
+      def mutations_for(subject)
+        found = []
+        visit(subject.node.body, subject, found)
+        found
+      end
+
+      private
+
+      def visit(node, subject, found)
+        return if node.nil? || SCOPE_NODES.any? { |scope| node.is_a?(scope) }
+
+        if node.is_a?(Prism::StatementsNode)
+          node.body.each { |statement| visit(statement, subject, found) unless arid?(statement) }
+          return
+        end
+
+        mutate_node(node, subject, found)
+        node.compact_child_nodes.each { |child| visit(child, subject, found) }
+      end
+
+      def arid?(node)
+        @arid.any? { |pattern| pattern.match?(node.slice) }
+      end
+    end
+  end
+end

data/lib/saboteur/preview.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "engine"
+require_relative "text"
 
 module Saboteur
   # Source-only planning. Never boots the host or executes its test suite.
@@ -92,7 +93,7 @@ module Saboteur
     # coverage map means "no estimate", never an exception.
     def cached_map
       path = File.join(@config.path("cache_dir"), "preview.json")
-      receipt = JSON.parse(File.read(path))
+      receipt = JSON.parse(Text.utf8_strict(File.read(path)))
       return unless receipt["fingerprint"] == Engine::RunFingerprint.new(config: @config).snapshot.digest
 
       Selection::CoverageMap.load(receipt["path"])

data/lib/saboteur/reporter/agent_commands.rb

@@ -8,15 +8,26 @@ module Saboteur
     module Agent
       # The shell commands an agent is told to run next. Every word is escaped with
       # Shellwords, so a ref, path or subject holding shell syntax stays one literal
-      # argument. A command is never cut short: when it is longer than MAX_BYTES it
-      # is left out, because half a command could run something else.
+      # argument. A command for the agent protocol is never cut short: when it is
+      # longer than MAX_BYTES it is left out, because half a command could run
+      # something else. The text footer passes capped: false instead - there the
+      # promise is the complete command, however long (#261).
       module Commands
         MAX_BYTES = 1024
 
         # Options typed on the command line that change how a run behaves.
         SETTING_FLAGS = { reeval: "--reeval", integration: "--integration", jobs: "--jobs",
                           timeout_factor: "--timeout-factor", json_report: "--json", html_report: "--html",
-                          operators: "--operators", exclude_operators: "--exclude-operators" }.freeze
+                          operators: "--operators", exclude_operators: "--exclude-operators",
+                          baseline_passes: "--baseline-passes", max_duration: "--max-duration" }.freeze
+
+        # CLI-only boolean switches recorded in settings, mapped by value, so
+        # an explicit false (--no-max-duration-ok over a config true) survives
+        # into the generated commands instead of reverting to the config.
+        BOOLEAN_SETTING_FLAGS = { allow_hazardous: { true => "--allow-hazardous" },
+                                  allow_focus: { true => "--allow-focus" },
+                                  max_duration_ok: { true => "--max-duration-ok",
+                                                     false => "--no-max-duration-ok" } }.freeze
 
         class << self
           # Run the same selection again: ref, subjects, sources, tests, config,
@@ -26,25 +37,37 @@ module Saboteur
             finish(words, provenance)
           end
 
-          # Replay one survivor by digest in the same selection.
-          def replay(provenance, digest)
+          # Replay one survivor by digest in the same selection. capped: false
+          # skips the protocol byte cap, for callers that print to a terminal.
+          def replay(provenance, digest, capped: true)
             words = ["saboteur", "run", "--id", digest, *selection(provenance, replay: true), "--seed",
                      provenance.seed.to_s]
-            finish(words, provenance)
+            finish(words, provenance, capped: capped)
           end
 
           private
 
-          def finish(words, provenance)
+          def finish(words, provenance, capped: true)
             words += ["--", *provenance.sources] unless provenance.sources.empty?
             command = Shellwords.join(words)
-            command.bytesize <= MAX_BYTES ? command : nil
+            command if !capped || command.bytesize <= MAX_BYTES
           end
 
-          # An explicit scope is frozen: --no-guess-tests keeps a config-file
-          # guess_tests from conflicting with the --test list.
+          def mode_words(provenance)
+            words = []
+            words << "--no-cache" if provenance.cache == false
+            words << "--incremental" if provenance.incremental
+            words.concat(boolean_words(provenance))
+          end
+
+          def boolean_words(provenance)
+            BOOLEAN_SETTING_FLAGS.filter_map { |key, words| words[provenance.settings[key]] }
+          end
+
+          # An explicit scope is frozen as --test, which wins over inferred
+          # selection by precedence, whatever the config file sets.
           def test_words(tests)
-            tests.empty? ? [] : ["--no-guess-tests", *tests.flat_map { |test| ["--test", test] }]
+            tests.flat_map { |test| ["--test", test] }
           end
 
           def setting_words(provenance)
@@ -56,15 +79,17 @@ module Saboteur
             end
           end
 
+          # Whole-suite scope is a bare --all, only when no tests resolved;
+          # --all never combines with --test.
           def selection(provenance, replay: false)
             words = []
             words.push("--config", provenance.config_path) if provenance.config_path
             words.push("--since", provenance.ref) if provenance.ref
             provenance.subjects.each { |subject| words.push("--subject", subject) }
+            words << "--all" if provenance.settings[:all] && provenance.tests.empty?
             words.push(*test_words(provenance.tests))
             words.concat(setting_words(provenance))
-            words << "--no-cache" if provenance.cache == false
-            words << "--incremental" if provenance.incremental
+            words.concat(mode_words(provenance))
             words.push("--id", provenance.digest) if provenance.digest && !replay
             words
           end

data/lib/saboteur/reporter/agent_incomplete.rb

@@ -8,6 +8,8 @@ module Saboteur
       # stable code, a count and a plain meaning.
       module Incomplete
         NO_COVERAGE = "no coverage"
+        SYNTAX_FAILURE = "invalid_file_syntax"
+        UNREADABLE_FAILURE = "unreadable"
 
         class << self
           def reasons(report)
@@ -23,14 +25,37 @@ module Saboteur
             add(reasons, "mutant_cap", omitted_by_cap(report), "mutants omitted by max_mutants_per_method")
             add(reasons, "errors", report.counts[:error], "mutants errored; their verdict did not hold up")
             add(reasons, "resource_limit", report.counts[:resource_limit], "mutants hit the memory or process cap")
-            add(reasons, "fail_fast", report.early_stop&.unreached&.size.to_i,
-                "selected subjects did not run because --fail-fast stopped the run")
+            add(reasons, "unverified", report.counts[:unverified],
+                "mutants the --max-duration budget left unverified; their kills are not confirmed")
+            discovery_failures(reasons, report)
+            early_stop_reason(reasons, report)
             inline_scope(reasons, report)
             reasons
           end
 
           private
 
+          # Source the selection could not read at all: its subjects never
+          # entered the run, so a clean or complete verdict would be wrong.
+          def discovery_failures(reasons, report)
+            failures = report.discovery_failures
+            add(reasons, SYNTAX_FAILURE, failures.count { |f| f.reason == SYNTAX_FAILURE },
+                "included files did not parse; their subjects were not discovered")
+            add(reasons, UNREADABLE_FAILURE, failures.count { |f| f.reason == UNREADABLE_FAILURE },
+                "included untracked files could not be read; their subjects were not covered")
+          end
+
+          def early_stop_reason(reasons, report)
+            stop = report.early_stop
+            return unless stop
+
+            label = stop.reason == "fail_fast" ? "--fail-fast stopped" : "the --max-duration budget stopped"
+            add(reasons, stop.reason, stop.unreached.size, "selected subjects did not run because #{label} the run")
+            omitted = stop.truncated.sum { |entry| entry[:omitted] }
+            add(reasons, "#{stop.reason}_truncated", omitted,
+                "mutants omitted inside subjects that stopped mid-way because #{label} the run")
+          end
+
           def inline_scope(reasons, report)
             add(reasons, "inline_suppressed", report.inline_suppressions.size,
                 "candidates were suppressed by inline directives; see the full report audit")