saboteur 0.5.0 → 0.7.0

data/lib/saboteur/mutation_source/operator_registry.rb

@@ -1,6 +1,9 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require "did_you_mean"
+require_relative "operator_examples"
+
 module Saboteur
   module MutationSource
     # Public names used by selection, help and inline suppression validation.
@@ -29,26 +32,51 @@ 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
-      EXTENDED = %w[range operator_assignment condition_negation].freeze
-      TIERS = { "core" => (DESCRIPTIONS.keys - EXTENDED).freeze, "extended" => EXTENDED,
-                "all" => DESCRIPTIONS.keys.freeze }.freeze
+      POLICY_VERSION = 2
+      TIERS = { "all" => DESCRIPTIONS.keys.freeze }.freeze
 
-      def self.list(out)
+      def self.list(out, names: [], excluded: [])
+        active = select(names, excluded)
         DESCRIPTIONS.each do |name, description|
-          out.puts("#{name}  #{EXTENDED.include?(name) ? 'extended' : 'core'}  #{description}")
+          out.puts("#{name}  #{active.include?(name) ? 'on' : 'off'}  #{description}  #{OperatorExamples::EXAMPLES.fetch(name)}")
         end
         nil
       end
 
+      def self.policy(names, excluded)
+        { "version" => POLICY_VERSION, "selected" => names, "excluded" => excluded,
+          "effective" => select(names, excluded) }
+      end
+
+      # Exclusion wins over explicit selection; empty exclusions remove nothing.
+      def self.select(names, excluded)
+        selected = resolve(names)
+        excluded.empty? ? selected : selected - resolve(excluded)
+      end
+
+      def self.suggestion(name)
+        matches = DidYouMean::SpellChecker.new(dictionary: DESCRIPTIONS.keys).correct(name)
+        matches.empty? ? "" : "Did you mean #{matches.first}?"
+      end
+
       def self.resolve(names)
-        return TIERS.fetch("core") if names.empty?
+        return TIERS.fetch("all") if names.empty?
 
+        legacy = names & %w[core extended]
+        unless legacy.empty?
+          raise ConfigError, "operator tiers #{legacy.join(', ')} were removed: use concrete names or all; " \
+                             "for the old core set exclude range,operator_assignment,condition_negation"
+        end
         unknown = names - DESCRIPTIONS.keys - TIERS.keys
         unless unknown.empty?
           raise ConfigError, "unknown operators: #{unknown.join(', ')}. Valid names: " \
-                             "#{(DESCRIPTIONS.keys + TIERS.keys).join(', ')}"
+                             "#{(DESCRIPTIONS.keys + TIERS.keys).join(', ')}. " \
+                             "#{suggestion(unknown.first)} See --list-operators."
         end
         names.flat_map { |name| TIERS.fetch(name) { [name] } }.uniq
       end

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.
@@ -13,6 +14,7 @@ module Saboteur
     end
 
     def call
+      announce_operators
       selection = Engine::SubjectSelection.new(@config, @diagnostics)
       subjects = selection.select(@config.included_files)
       scope = selection.changed_lines && Engine::DiffScope.new(selection.changed_lines)
@@ -24,12 +26,20 @@ module Saboteur
       @out.puts("Total: #{lists.sum(&:size)} mutants; #{@diagnostics.omissions.sum(&:count)} " \
                 "dropped by max_mutants_per_method#{incomplete_note(incomplete)}")
       incomplete.zero? ? estimate(subjects, lists) : @out.puts("no estimate: source discovery was incomplete")
-      @diagnostics.warnings.each { |warning| @out.puts("warning: #{warning}") }
+      print_warnings
       nil
     end
 
     private
 
+    def print_warnings
+      @diagnostics.warnings.each { |warning| @out.puts("warning: #{warning}") }
+    end
+
+    def announce_operators
+      @out.puts("Operators: #{@config.operator_policy['effective'].join(', ')}")
+    end
+
     # Candidate filtering precedes diff restriction and the per-method cap.
     # Name that scope rather than implying these rows were executed or scored.
     def inline_suppressions
@@ -83,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,14 +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" }.freeze
+                          timeout_factor: "--timeout-factor", json_report: "--json", html_report: "--html",
+                          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,
@@ -25,38 +37,59 @@ 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
+
+          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: --no-guess-tests keeps a config-file
-          # guess_tests from conflicting with the --test list.
+          # 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)
+            SETTING_FLAGS.flat_map do |key, flag|
+              next [] unless provenance.settings.key?(key)
+
+              value = provenance.settings[key]
+              [flag, value.is_a?(Array) ? value.join(",") : value.to_s]
+            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))
-            SETTING_FLAGS.each do |key, flag|
-              words.push(flag, provenance.settings[key].to_s) if provenance.settings.key?(key)
-            end
-            words << "--no-cache" if provenance.cache == false
-            words << "--incremental" if provenance.incremental
+            words.concat(setting_words(provenance))
+            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")

data/lib/saboteur/reporter/agent_summary.rb

@@ -22,7 +22,7 @@ module Saboteur
             verdict = verdict_of(report, status)
             {
               version: VERSION, status: status, verdict: verdict, exitCode: exit_code_for(verdict),
-              provenance: provenance_hash(provenance),
+              provenance: provenance_hash(provenance).merge(operatorPolicy: report.operator_policy),
               counts: counts(report), score: score(report),
               scoreDefinition: "(killed + timeout) / (killed + survived + timeout); null when nothing was tested",
               incomplete: incomplete, timeoutCountedAsDetected: report.counts[:timeout],

data/lib/saboteur/reporter/history_policy.rb

@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # v1 stays readable, but v2 records require versioned operator evidence.
+    module HistoryPolicy
+      def validate_header(record, fields)
+        version = record.is_a?(Hash) && record["version"]
+        raise Error, "score history contains an invalid version" unless version.is_a?(Integer) && [1,
+                                                                                                   2].include?(version)
+
+        fields(record, version == 2 ? fields + ["operatorPolicy"] : fields)
+        validate_policy(record["operatorPolicy"]) if version == 2
+      end
+
+      def validate_policy(value)
+        raise Error, "score history contains invalid operator policy" unless value.is_a?(Hash)
+
+        fields(value, %w[version selected excluded effective])
+        raise Error, "score history contains invalid operator policy" if value["effective"].empty?
+
+        lists = value.values_at("selected", "excluded", "effective")
+        unless lists.all? { |list| list.is_a?(Array) && list.all?(String) }
+          raise Error, "score history contains invalid operator policy"
+        end
+
+        expected = MutationSource::OperatorRegistry.policy(value["selected"], value["excluded"])
+        raise Error, "score history contains invalid operator policy" unless value == expected
+      rescue ConfigError, NoMethodError, TypeError
+        raise Error, "score history contains invalid operator policy"
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/history_record.rb

@@ -3,6 +3,7 @@
 
 require "json"
 require "time"
+require_relative "history_policy"
 
 module Saboteur
   module Reporter
@@ -21,6 +22,8 @@ module Saboteur
         end
       end
 
+      extend HistoryPolicy
+
       module_function
 
       def parse(line)
@@ -32,11 +35,7 @@ module Saboteur
       end
 
       def validate(record)
-        fields(record, FIELDS)
-        unless record.fetch("version").is_a?(Integer) && record.fetch("version") == 1
-          raise Error,
-                "score history contains an invalid version"
-        end
+        validate_header(record, FIELDS)
 
         date(record.fetch("date"))
         commit = record.fetch("commit")

data/lib/saboteur/reporter/next_steps.rb

@@ -7,9 +7,14 @@ module Saboteur
     # accept one, and how to hand the run to an agent. Silent when nothing
     # survived, so a clean run stays short.
     class NextSteps
-      def initialize(out, palette)
+      # replay_command: digest -> the full, copy-pasteable replay command
+      # carrying the run's own selection options, however long it gets
+      # (#261). When no builder is wired the digest-only hint (with its
+      # reassembly note) is the fallback.
+      def initialize(out, palette, replay_command: nil)
         @out = out
         @palette = palette
+        @replay_command = replay_command
       end
 
       def call(report)
@@ -17,9 +22,14 @@ module Saboteur
         return unless survivor
 
         @out.puts "\n#{@palette.paint(:bold, 'Next steps:')}"
-        seed = " --seed #{report.seed}" if report.seed
-        @out.puts "  replay one survivor: saboteur run --id #{survivor.digest}#{seed}"
-        @out.puts "    (add this run's own --config, --since, --subject, --test and source options)"
+        command = @replay_command&.call(survivor.digest)
+        if command
+          @out.puts "  replay one survivor: #{command}"
+        else
+          seed = " --seed #{report.seed}" if report.seed
+          @out.puts "  replay one survivor: saboteur run --id #{survivor.digest}#{seed}"
+          @out.puts "    (add this run's own --config, --since, --subject, --test and source options)"
+        end
         @out.puts "  accept an equivalent one: add to your ignore file (c.ignore_file, default #{Config::IGNORE_FILE}):"
         entry = %(i.mutation "#{survivor.digest}", subject: "#{survivor.subject.id}", reason: "why it is equivalent")
         @out.puts "    #{entry}"

data/lib/saboteur/reporter/score_history.rb

@@ -13,6 +13,7 @@ module Saboteur
     # Opt-in append-only score observations, not a baseline or a CI gate.
     class ScoreHistory
       DIFFERENT_RUN = "score history: change unavailable (different selection/inventory or incomplete run)"
+      DIFFERENT_POLICY = "score history: change unavailable (different record version or operator policy)"
       MISSING_SCORE = "score history: change unavailable (no tested mutants)"
       MAX_RECORD_BYTES = 64 * 1024
       OPEN_FLAGS = File::RDWR | File::CREAT | File::NONBLOCK | File::NOFOLLOW
@@ -38,7 +39,11 @@ module Saboteur
           file.flush
           change(previous, record)
         end
-      rescue SystemCallError, IOError, JSON::ParserError, KeyError, TypeError => e
+      # SystemCallError/IOError from the write itself propagate unwrapped on
+      # purpose: the CLI treats those as a soft artifact failure (warn and
+      # exit by the results), while validation, integrity, record-size and
+      # lock failures stay hard errors (#296).
+      rescue JSON::ParserError, KeyError, TypeError => e
         raise Error, "score history was not recorded: #{e.message}"
       end
 
@@ -58,13 +63,13 @@ module Saboteur
       private
 
       def build(report, head, scope)
-        { "version" => 1, "date" => Time.now.utc.iso8601, "commit" => head,
+        { "version" => 2, "date" => Time.now.utc.iso8601, "commit" => head,
           "selection" => Digest::SHA256.hexdigest(JSON.generate(scope.sort_by { |key, _| key.to_s }.to_h)),
           "inventory" => Digest::SHA256.hexdigest(JSON.generate(report.results.map(&:digest).sort)),
           "score" => overall_score(report), "coveredScore" => report.score,
           "counts" => report.counts.transform_keys(&:to_s),
           "breakdown" => report.score_breakdown.to_h.transform_keys(&:to_s),
-          "incomplete" => incompleteness(report) }
+          "incomplete" => incompleteness(report), "operatorPolicy" => report.operator_policy }
       end
 
       def overall_score(report)
@@ -107,11 +112,22 @@ module Saboteur
         previous
       end
 
+      # Only one record version and one non-null operator policy compare:
+      # scores never mix across v1/v2 or across policy configurations.
+      # A non-null previous policy forces a non-null equal current one, so
+      # only the previous record needs the null guard.
+      def comparable_policy?(previous, current)
+        previous["version"] == current["version"] &&
+          !previous["operatorPolicy"].nil? &&
+          previous["operatorPolicy"] == current["operatorPolicy"]
+      end
+
       def change(previous, current)
         return "score history: first record" unless previous
         return DIFFERENT_RUN unless
           previous["selection"] == current["selection"] && previous["inventory"] == current["inventory"] &&
           previous["incomplete"].empty? && current["incomplete"].empty?
+        return DIFFERENT_POLICY unless comparable_policy?(previous, current)
         return MISSING_SCORE if
           previous["coveredScore"].nil? || current["coveredScore"].nil?
 

data/lib/saboteur/reporter/stryker.rb

@@ -40,13 +40,15 @@ module Saboteur
           warnings: report.warnings,
           framework: { name: "saboteur", version: VERSION },
           saboteur: { findings: Findings.build(report), scores: scores(report),
-                      inlineSuppressions: report.inline_suppressions.map do |entry|
-                        entry.merge(file: relative(entry[:file], report.root))
-                      end }
-                     .merge(exit_cause ? { exitCause: exit_cause } : {})
+                      inlineSuppressions: inline_audit(report) }
+                     .merge(operatorPolicy: report.operator_policy).merge(exit_cause ? { exitCause: exit_cause } : {})
         }.merge(report.seed ? { config: { seed: report.seed } } : {})
       end
 
+      def self.inline_audit(report)
+        report.inline_suppressions.map { |entry| entry.merge(file: relative(entry[:file], report.root)) }
+      end
+
       # Score with its assertion and crash shares, for all mutants and without
       # the whole-body ones (body_nil, body_true, body_false, body_raise).
       def self.scores(report)
@@ -56,7 +58,14 @@ module Saboteur
       # nil for a run that covered its whole selection.
       def self.early_stop(report)
         stop = report.early_stop
-        stop && { reason: stop.reason, unreachedSubjects: stop.unreached }
+        return unless stop
+
+        { reason: stop.reason, unreachedSubjects: stop.unreached, truncatedSubjects: truncated_subjects(stop),
+          unverifiedSubjects: stop.unverified }
+      end
+
+      def self.truncated_subjects(stop)
+        stop.truncated.map { |entry| { subject: entry[:subject], omittedMutants: entry[:omitted] } }
       end
 
       def self.skipped_subjects(report)
@@ -113,8 +122,9 @@ module Saboteur
         when :error, :resource_limit then "RuntimeError"
         when :skipped then result.reason&.start_with?("no coverage") ? "NoCoverage" : "Ignored"
         # The schema has no status for "ran, but no test can observe a
-        # change here". Ignored with the reason is the honest mapping.
-        when :ran_at_load, :unreachable then "Ignored"
+        # change here", nor for a verdict the budget left unchecked.
+        # Ignored with the reason is the honest mapping.
+        when :ran_at_load, :unreachable, :unverified then "Ignored"
         end
       end
 
@@ -123,7 +133,8 @@ module Saboteur
         return "resource limit: #{result.reason}" if result.status == :resource_limit
         return result.crash_kill? ? "crash: #{result.kill_cause}" : result.kill_cause if result.kill_cause
 
-        result.reason.to_s.lines.first&.strip
+        reason = result.reason.to_s.strip
+        reason.empty? ? nil : reason
       end
 
       def self.location(edit, source)

data/lib/saboteur/reporter/survivor_hints.rb

@@ -19,6 +19,9 @@ module Saboteur
         "safe_navigation" => "try an example where the receiver is nil",
         "argument_removal" => "try have_received(...).with(...), or assert a result that depends on this argument",
         "pair_removal" => "try have_received(...).with(...), or assert the hash content under this key",
+        "chain_removal" => "try the shorter chain's value against the longer one; if you confirm the " \
+                           "shorter chain is equivalent across the intended inputs (for example a duplicated " \
+                           "column), simplify the code or ignore the mutant",
         "endpoint_replacement" => "try a collection with 2 or more elements, to tell first from last",
         "filter_replacement" => "try items that match and items that do not, to tell select from reject"
       }.freeze

data/lib/saboteur/reporter/terminal.rb

@@ -17,12 +17,12 @@ module Saboteur
       MAX_ERRORS = 10
       MAX_PASSING_TESTS = SurvivorList::MAX_PASSING_TESTS
 
-      def initialize(out, verbose: false, color: :auto)
+      def initialize(out, verbose: false, color: :auto, replay_command: nil)
         @out = out
         @verbose = verbose
         @palette = Palette.for(out, mode: color)
         @score_table = ScoreTable.new(out, @palette)
-        @next_steps = NextSteps.new(out, @palette)
+        @next_steps = NextSteps.new(out, @palette, replay_command: replay_command)
       end
 
       def call(report)
@@ -34,11 +34,20 @@ module Saboteur
         warnings(report)
         early_stop(report)
         test_matrix(report)
+        operator_policy(report)
         summary(report)
       end
 
       private
 
+      def operator_policy(report)
+        policy = report.operator_policy
+        return unless policy && policy["excluded"].any?
+
+        @out.puts("Excluded operators: #{policy['excluded'].join(', ')} " \
+                  "(policy #{policy['version']}; #{policy['effective'].size} enabled)")
+      end
+
       def test_matrix(report)
         return unless report.matrix?
 
@@ -100,6 +109,7 @@ module Saboteur
                "resource limit #{c[:resource_limit]}  error #{c[:error]}  skipped #{c[:skipped]}"
         line += "  ran at load #{c[:ran_at_load]}" if c[:ran_at_load].positive?
         line += "  unreachable #{c[:unreachable]}" if c[:unreachable].positive?
+        line += "  unverified #{c[:unverified]}" if c[:unverified].positive?
         line
       end
 
@@ -214,17 +224,39 @@ module Saboteur
         end
       end
 
-      # The verdict covers only the subjects that ran, so say it where the
+      # The verdict covers only the completed work, so say it where the
       # score is read.
       def early_stop(report)
         stop = report.early_stop
         return unless stop
 
-        @out.puts @palette.paint(:yellow, "stopped early (--fail-fast): #{stop.unreached.size} selected " \
-                                          "subject#{'s' unless stop.unreached.one?} did not run; the score below " \
-                                          "covers only the subjects that ran")
-        stop.unreached.first(MAX_ERRORS).each { |id| @out.puts "  not run: #{id}" }
-        @out.puts "  ... #{stop.unreached.size - MAX_ERRORS} more" if stop.unreached.size > MAX_ERRORS
+        label = stop.reason == "fail_fast" ? "--fail-fast" : "--max-duration spent"
+        @out.puts @palette.paint(:yellow, "stopped early (#{label}): #{early_stop_summary(stop)}; the score below " \
+                                          "covers only completed work")
+        list(stop.unreached) { |id| "  not run: #{id}" }
+        list(stop.truncated) { |entry| "  stopped mid-way: #{entry[:subject]} (#{entry[:omitted]} mutants omitted)" }
+        list(stop.unverified) { |id| "  unverified: #{id}" }
+      end
+
+      def list(entries)
+        entries.first(MAX_ERRORS).each { |entry| @out.puts yield(entry) }
+        @out.puts "  ... #{entries.size - MAX_ERRORS} more" if entries.size > MAX_ERRORS
+      end
+
+      def early_stop_summary(stop)
+        parts = []
+        if stop.unreached.any?
+          parts << "#{stop.unreached.size} selected subject#{'s' unless stop.unreached.one?} did not run"
+        end
+        if stop.truncated.any?
+          omitted = stop.truncated.sum { |entry| entry[:omitted] }
+          parts << "#{stop.truncated.size} subject#{'s' unless stop.truncated.one?} stopped mid-way " \
+                   "(#{omitted} mutants omitted)"
+        end
+        if stop.unverified.any?
+          parts << "#{stop.unverified.size} subject#{'s' unless stop.unverified.one?} left with unverified results"
+        end
+        parts.join("; ")
       end
 
       def warnings(report)
@@ -237,8 +269,9 @@ module Saboteur
 
         @out.puts "\nErrors (not counted as killed):"
         errored.first(MAX_ERRORS).each do |result|
-          @out.puts "  #{result.subject.id} #{result.mutation.operator} #{result.digest}: " \
-                    "#{result.reason.to_s.lines.first&.strip}"
+          lines = result.reason.to_s.lines.map(&:strip)
+          @out.puts "  #{result.subject.id} #{result.mutation.operator} #{result.digest}: #{lines.first}"
+          lines.drop(1).each { |line| @out.puts "    #{line}" }
         end
         @out.puts "  ... #{errored.size - MAX_ERRORS} more" if errored.size > MAX_ERRORS
       end