saboteur 0.7.0 → 0.8.0

data/lib/saboteur/reporter/agent.rb

@@ -32,8 +32,16 @@ module Saboteur
 
       # Where a verdict comes from: the exact selection and the state of the working
       # source before the run started. subjects, tests and sources are arrays.
+      # typed_settings: the settings keys typed on the command line, so the
+      # generated commands can tell a typed empty list (which may clear a
+      # config-file value) from one the config itself supplies.
       Provenance = Data.define(:ref, :seed, :head, :working_tree, :changed_files, :mode, :json_report, :subjects,
-                               :tests, :sources, :config_path, :digest, :cache, :incremental, :settings)
+                               :tests, :sources, :config_path, :digest, :cache, :incremental, :settings,
+                               :typed_settings) do
+        def initialize(typed_settings: [], **fields)
+          super
+        end
+      end
 
       class << self
         def call(report, provenance)

data/lib/saboteur/reporter/agent_commands.rb

@@ -19,7 +19,8 @@ module Saboteur
         SETTING_FLAGS = { reeval: "--reeval", integration: "--integration", jobs: "--jobs",
                           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
+                          baseline_passes: "--baseline-passes", max_duration: "--max-duration",
+                          shard: "--shard" }.freeze
 
         # CLI-only boolean switches recorded in settings, mapped by value, so
         # an explicit false (--no-max-duration-ok over a config true) survives
@@ -70,11 +71,17 @@ module Saboteur
             tests.flat_map { |test| ["--test", test] }
           end
 
-          def setting_words(provenance)
+          # An empty list nobody typed came from the config file or its
+          # default, which the command reads again, so its flag is left out
+          # (#317). A typed empty list stays: it may clear a config value.
+          def setting_words(provenance, replay: false)
             SETTING_FLAGS.flat_map do |key, flag|
+              next [] if replay && key == :shard
               next [] unless provenance.settings.key?(key)
 
               value = provenance.settings[key]
+              next [] if value == [] && !provenance.typed_settings.include?(key)
+
               [flag, value.is_a?(Array) ? value.join(",") : value.to_s]
             end
           end
@@ -88,7 +95,7 @@ module Saboteur
             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.concat(setting_words(provenance, replay: replay))
             words.concat(mode_words(provenance))
             words.push("--id", provenance.digest) if provenance.digest && !replay
             words

data/lib/saboteur/reporter/agent_incomplete.rb

@@ -14,6 +14,7 @@ module Saboteur
         class << self
           def reasons(report)
             reasons = []
+            shard_reason(reasons, report)
             add(reasons, "no_coverage", skipped_for_coverage(report), "subjects or mutants had no covering test")
             load_only = report.counts[:ran_at_load] + report.skipped_subjects.values.count do |reason|
               reason == Selection::CoverageMap::RAN_AT_LOAD
@@ -35,6 +36,16 @@ module Saboteur
 
           private
 
+          # A shard always runs a subset of the planned inventory by contract, even
+          # when this shard happened to select every planned mutant (count 0).
+          def shard_reason(reasons, report)
+            shard = report.shard
+            return unless shard
+
+            reasons << { reason: "shard", count: shard.planned_count - shard.selected_count,
+                         meaning: "planned mutants assigned to other shards" }
+          end
+
           # 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)

data/lib/saboteur/reporter/agent_summary.rb

@@ -26,10 +26,11 @@ module Saboteur
               counts: counts(report), score: score(report),
               scoreDefinition: "(killed + timeout) / (killed + survived + timeout); null when nothing was tested",
               incomplete: incomplete, timeoutCountedAsDetected: report.counts[:timeout],
-              findings: findings(report, shown, snippet_limit),
+              findings: findings(report, shown, snippet_limit)
+            }.merge(report.shard ? { shard: report.shard.to_h } : {}).merge(
               warnings: report.warnings.first(WARNING_LIMIT).map { |warning| warning.to_s[0, WARNING_LENGTH] },
               next: next_steps(report, provenance)
-            }
+            )
           end
 
           private
@@ -95,7 +96,7 @@ module Saboteur
 
           def shown_findings(listed, shown, snippet_limit)
             listed.first(shown).map do |finding|
-              finding.slice(:digest, :line, :endLine, :operator, :coarse)
+              finding.slice(:digest, :line, :endLine, :operator, :coarse, :classification)
                      .merge(path: clip_value(finding[:path], 200), subject: clip_value(finding[:subject], 200),
                             original: clip(finding[:original], snippet_limit),
                             replacement: clip(finding[:replacement], snippet_limit))

data/lib/saboteur/reporter/findings.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "survivor_ranking"
+require_relative "survivor_classification"
 
 module Saboteur
   module Reporter
@@ -59,8 +60,10 @@ module Saboteur
             original: joined_texts(result) { |edit| original_text(result, edit) },
             replacement: joined_texts(result, &:replacement),
             edits: entries,
-            coarse: result.mutation.coarse
-          }
+            coarse: result.mutation.coarse,
+            # Why the survivor is worth a look, as a label only (#192).
+            classification: SurvivorClassification.label(result)
+          }.compact
           entry = with_changed_lines(report, result, entry)
           result.ignored ? entry.merge(reason: result.ignored) : entry
         end

data/lib/saboteur/reporter/history_policy.rb

@@ -4,6 +4,10 @@
 module Saboteur
   module Reporter
     # v1 stays readable, but v2 records require versioned operator evidence.
+    # A policy stamped with an older POLICY_VERSION is shape-checked only:
+    # the operator set has moved on, so it never recomputes equal - and it
+    # never compares equal to a current run's policy either, which is what
+    # keeps trend from mixing operator sets (#135).
     module HistoryPolicy
       def validate_header(record, fields)
         version = record.is_a?(Hash) && record["version"]
@@ -18,6 +22,11 @@ module Saboteur
         raise Error, "score history contains invalid operator policy" unless value.is_a?(Hash)
 
         fields(value, %w[version selected excluded effective])
+        policy_version = value["version"]
+        unless policy_version.is_a?(Integer) &&
+               policy_version.between?(1, MutationSource::OperatorRegistry::POLICY_VERSION)
+          raise Error, "score history contains invalid operator policy"
+        end
         raise Error, "score history contains invalid operator policy" if value["effective"].empty?
 
         lists = value.values_at("selected", "excluded", "effective")
@@ -25,6 +34,8 @@ module Saboteur
           raise Error, "score history contains invalid operator policy"
         end
 
+        return if policy_version != MutationSource::OperatorRegistry::POLICY_VERSION
+
         expected = MutationSource::OperatorRegistry.policy(value["selected"], value["excluded"])
         raise Error, "score history contains invalid operator policy" unless value == expected
       rescue ConfigError, NoMethodError, TypeError

data/lib/saboteur/reporter/history_reader.rb

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "score_history"
+require_relative "history_record"
+
+module Saboteur
+  module Reporter
+    # Read side of the append-only score history for `saboteur badge` and
+    # `saboteur trend` (#474). Every record is re-validated on read and the
+    # file discipline mirrors ScoreHistory: regular file, no symlink,
+    # byte-capped lines, no repair of imported evidence.
+    module HistoryReader
+      module_function
+
+      def read(path)
+        records = []
+        File.open(path, File::RDONLY | File::NONBLOCK | File::NOFOLLOW) do |file|
+          raise Error, "score history must be a regular file" unless file.stat.file?
+
+          file.flock(File::LOCK_SH)
+          limit = ScoreHistory::MAX_RECORD_BYTES
+          while (line = file.gets(limit + 1))
+            raise Error, "score history record exceeds byte limit" if line.bytesize > limit
+            raise Error, "score history contains a truncated record" unless line.end_with?("\n")
+
+            records << HistoryRecord.parse(line)
+          end
+        end
+        records
+      rescue SystemCallError, IOError => e
+        raise Error, "score history cannot be read: #{e.message}"
+      end
+
+      # The ScoreHistory change rules: same record version, selection,
+      # inventory and operator policy (a null policy never compares), both
+      # runs complete.
+      def comparable?(previous, current)
+        previous["version"] == current["version"] &&
+          previous["selection"] == current["selection"] &&
+          previous["inventory"] == current["inventory"] &&
+          previous["incomplete"].empty? && current["incomplete"].empty? &&
+          !previous["operatorPolicy"].nil? && previous["operatorPolicy"] == current["operatorPolicy"]
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/html.rb

@@ -4,6 +4,8 @@
 require "cgi"
 require "fileutils"
 
+require_relative "survivor_classification"
+
 module Saboteur
   module Reporter
     # One self-contained HTML page: inline style, no script, no network. It is
@@ -23,7 +25,9 @@ module Saboteur
         .status{border-radius:3px;padding:0 .4rem;color:#fff;white-space:nowrap}
         .Killed{background:#2e7d32}.Survived{background:#c62828}.Timeout{background:#b45309}
         .RuntimeError{background:#6a1b9a}.NoCoverage{background:#455a64}.Ignored{background:#616161}
-        .Accepted{background:#8d6e63}
+        .Accepted,.Triage_accepted_equivalent{background:#8d6e63}
+        .Triage_wont_fix{background:#616161}.Triage_todo{background:#b45309}
+        .classification{border-radius:3px;padding:0 .4rem;background:#eceff1;color:#37474f;white-space:nowrap}
         .warning{background:#fff8e1;border-left:4px solid #f9a825;margin:.3rem 0;padding:.3rem .6rem;overflow-wrap:anywhere}
         code,pre{font-family:ui-monospace,monospace;font-size:13px}
         pre{display:inline-block;vertical-align:top;margin:0;white-space:pre-wrap;overflow-wrap:anywhere}summary{cursor:pointer;font-weight:600;overflow-wrap:anywhere}
@@ -195,12 +199,30 @@ module Saboteur
       def row_status(mutant, result)
         badge = status_label(mutant[:status])
         # Only survivors are ever put on the ignore list.
-        result.ignored ? "#{badge} #{status_label('Accepted')}" : badge
+        if result.ignored || result.triage_state
+          # An entry without a state predates triage states: render Accepted.
+          badge = if result.triage_state.nil?
+                    "#{badge} #{status_label('Accepted')}"
+                  else
+                    "#{badge} #{status_label(triage_badge(result), css_class: "Triage_#{result.triage_state}")}"
+                  end
+        end
+        # The survivor's classification, as a label only (#192).
+        label = SurvivorClassification.label(result)
+        label ? "#{badge} <span class=\"classification\">#{escape(label)}</span>" : badge
       end
 
       # One edit shows the original text and its replacement. A mutant with
       # several edits shows only the replacements, because one location cannot
       # stand for all of them.
+      def triage_badge(result)
+        case result.triage_state
+        when "wont_fix" then "Won\u2019t fix"
+        when "todo" then "Todo"
+        else "Accepted"
+        end
+      end
+
       def change(mutant, result)
         edits = result.mutation.edits
         return "<pre>#{escape(mutant[:replacement])}</pre>" unless edits.size == 1
@@ -212,8 +234,8 @@ module Saboteur
           "<pre>#{escape(edit.replacement)}</pre>"
       end
 
-      def status_label(status)
-        %(<span class="status #{status}">#{status}</span>)
+      def status_label(status, css_class: status)
+        %(<span class="status #{css_class}">#{status}</span>)
       end
 
       def escape(text)

data/lib/saboteur/reporter/mutation_text.rb

@@ -20,6 +20,12 @@ module Saboteur
         join(result, &:replacement)
       end
 
+      # A mutant that only deletes: every edit's replacement is empty.
+      # Rendered as "removes X" rather than "X -> " with a blank side.
+      def removal?(result)
+        sorted_edits(result).all? { |edit| edit.replacement.empty? }
+      end
+
       def sorted_edits(result)
         result.mutation.edits.sort_by(&:start_byte)
       end

data/lib/saboteur/reporter/stryker.rb

@@ -39,12 +39,24 @@ module Saboteur
           rejectedKills: report.rejected_kills,
           warnings: report.warnings,
           framework: { name: "saboteur", version: VERSION },
-          saboteur: { findings: Findings.build(report), scores: scores(report),
-                      inlineSuppressions: inline_audit(report) }
-                     .merge(operatorPolicy: report.operator_policy).merge(exit_cause ? { exitCause: exit_cause } : {})
+          saboteur: saboteur_enrichment(report, exit_cause)
         }.merge(report.seed ? { config: { seed: report.seed } } : {})
       end
 
+      # saboteur-namespaced keys beyond Stryker's schema: findings and
+      # scores, then the optional policy, shard, exit-cause and memory keys.
+      def self.saboteur_enrichment(report, exit_cause)
+        { findings: Findings.build(report), scores: scores(report),
+          inlineSuppressions: inline_audit(report) }
+          .merge(operatorPolicy: report.operator_policy).merge(shard(report))
+          .merge(exit_cause ? { exitCause: exit_cause } : {})
+          .merge(report.memory ? { memory: report.memory } : {})
+      end
+
+      def self.shard(report)
+        report.shard ? { shard: report.shard.to_h } : {}
+      end
+
       def self.inline_audit(report)
         report.inline_suppressions.map { |entry| entry.merge(file: relative(entry[:file], report.root)) }
       end
@@ -107,7 +119,14 @@ module Saboteur
 
       def self.optional_fields(result, test_ids)
         {
+          # A rejected kill is a verdict, not a tool error: the tests failed
+          # but also fail with the method unchanged. Flag it per mutant;
+          # the top-level rejectedKills stays a bare count (#375).
+          rejectedKill: (true if result.rejected_kill?),
           statusReason: status_reason(result),
+          # Why the survivor is worth a look, as a label only: scores and
+          # the exit code never change (#192).
+          classification: SurvivorClassification.label(result),
           killedBy: result.killed_by.map { |name| test_ids.fetch(name) }.then { |ids| ids.empty? ? nil : ids },
           coveredBy: result.covered_by.map { |name| test_ids.fetch(name) }.then { |ids| ids.empty? ? nil : ids },
           duration: result.runtime && (result.runtime * 1000).round
@@ -129,6 +148,11 @@ module Saboteur
       end
 
       def self.status_reason(result)
+        return "todo: #{result.triage_reason}" if result.triage_state == "todo"
+        # The "ignored: " prefix is a public contract consumers classify by
+        # (#304 CI): accepted_equivalent stays byte-identical to a plain
+        # ignore, and only wont_fix adds a suffix after the reason.
+        return "ignored: #{result.ignored} (wont_fix)" if result.triage_state == "wont_fix"
         return "ignored: #{result.ignored}" if result.ignored
         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

data/lib/saboteur/reporter/survivor_classification.rb

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "../engine/bytecode_equivalence"
+require_relative "../execution/external_runner"
+require_relative "../mutation_source/builtin"
+
+module Saboteur
+  module Reporter
+    # Why a survivor is worth a look, as a LABEL ONLY (#192): the label
+    # lands in reports so a reader can sort real gaps from noise. Every
+    # label is a HEURISTIC, not a diagnosis - inspect the survivor before
+    # acting on it, and never add a test or ignore a mutant from the label
+    # alone. Labels never change scores or the exit code.
+    #
+    # One label per survivor, first match wins:
+    #   likely_equivalent - the mutant compiles to the same instructions as
+    #     the original (the #151/#169 bytecode filter): strong evidence of
+    #     a no-op mutant, worth checking against the source. First: a
+    #     no-op mutant's survival says nothing about the suite.
+    #   arid         - every line an edit touches matches an arid pattern
+    #     (logging and friends, #111/#187). The builtin hint list decides;
+    #     a configured arid policy does not change the label.
+    #   missing_test - a test covered the line and passed, which MAY mean
+    #     the suite reaches the code without pinning this behaviour. The
+    #     covering list is only the PLANNED coverage: whole-body (coarse)
+    #     mutants carry method-level guesses, so they never get this
+    #     label, and neither does anything without real coverage.
+    #   tool_limit   - reserved for survivors saboteur could not observe
+    #     faithfully (re-eval refusal, external runner without coverage). No
+    #     result records that signal yet, so the label is never emitted.
+    #
+    # A survivor with no matching signal stays unlabeled.
+    module SurvivorClassification
+      LABELS = %w[likely_equivalent arid missing_test tool_limit].freeze
+
+      class << self
+        def label(result, arid: MutationSource::Builtin::DEFAULT_ARID)
+          return nil unless result.status == :survived
+          return "likely_equivalent" if equivalent?(result)
+          return "arid" if arid?(result, arid)
+          return "missing_test" if possible_test_gap?(result)
+
+          nil
+        end
+
+        private
+
+        # The mutant's own def text, compiled side by side with the
+        # original: equal instruction sequences mean behaviour cannot
+        # change. Edits index the whole file, so they shift by the def's
+        # start byte before splicing into the def text.
+        def equivalent?(result)
+          subject = result.subject
+          original = subject.source
+          mutated = result.mutation.edits.sort_by(&:start_byte).reverse.inject(original) do |text, edit|
+            from = edit.start_byte - subject.start_byte
+            to = edit.end_byte - subject.start_byte
+            text.byteslice(0, from) + edit.replacement + text.byteslice(to..)
+          end
+          Engine::BytecodeEquivalence.new.equivalent?(original, mutated,
+                                                      frozen_string_literal: subject.frozen_literals)
+        end
+
+        # covered_by is a PLANNED covering list, not a verdict about what
+        # the suite asserts: coarse (whole-body) mutants carry method-level
+        # guesses, and a --test-command run records only the pseudo-test id
+        # for every mutant, so neither reads as real coverage (#305 QA).
+        def possible_test_gap?(result)
+          real_coverage = result.covered_by - [Execution::ExternalRunner::PSEUDO_TEST]
+          !result.mutation.coarse && real_coverage.any?
+        end
+
+        # Arid only when EVERY line an edit touches reads as arid: an edit
+        # that starts on a logging line but removes a composite body is not
+        # arid. The operator never decides: removing a logging statement is
+        # arid whatever removed it.
+        def arid?(result, patterns)
+          result.mutation.edits.all? do |edit|
+            lines = edited_lines(result.subject, edit)
+            lines.any? && lines.all? do |line|
+              patterns.any? { |pattern| line.strip.match?(Regexp.new(pattern)) }
+            end
+          end
+        end
+
+        # Edit offsets are BYTES, so the line lookup runs on the binary
+        # view (index/rindex are byte-exact there) and only the extracted
+        # lines are decoded, scrubbed so a partial multibyte sequence at an
+        # edit boundary cannot raise on the pattern match.
+        def edited_lines(subject, edit)
+          bytes = subject.file_source.b
+          last = [edit.end_byte - 1, edit.start_byte].max
+          line_start = (bytes.byteslice(0, edit.start_byte).rindex("\n") || -1) + 1
+          line_end = bytes.index("\n", last) || bytes.bytesize
+          bytes.byteslice(line_start, line_end - line_start).force_encoding(Encoding::UTF_8).scrub.lines
+        end
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/survivor_list.rb

@@ -47,14 +47,16 @@ module Saboteur
         end
       end
 
-      # Mutants on one line share the printed evidence only when it is the
-      # same for all of them: covering tests (in order), reuse and changed
-      # lines can each differ per mutant, so each run of neighbours with the
-      # same tuple is one group and shares evidence above its own mutations.
-      # Evidence that repeats after another group is printed again, which
-      # keeps the ranked order.
+      # Mutants on one line share the printed evidence when it names the
+      # same tests: the covering-test list is compared as a set (#502), so
+      # one line's mutants no longer reprint an identical block only because
+      # the run measured the killer order per mutant. Reuse and changed
+      # lines still group exactly. Each run of neighbours with the same key
+      # is one group and shares evidence above its own mutations; evidence
+      # that repeats after another group is printed again, which keeps the
+      # ranked order. The block prints in the first mutant's run order.
       def evidence_groups(report, on_line)
-        on_line.chunk { |result| [result.covered_by, result.reused?, report.changed_lines_for(result)] }
+        on_line.chunk { |result| [result.covered_by.uniq.sort, result.reused?, report.changed_lines_for(result)] }
                .map(&:last)
       end
 
@@ -70,9 +72,13 @@ module Saboteur
       end
 
       def mutation(result)
+        change = if MutationText.removal?(result)
+                   "removes #{MutationText.original(result)}"
+                 else
+                   "#{MutationText.original(result)} -> #{@palette.paint(:green, MutationText.replacement(result))}"
+                 end
         text = "      #{@palette.paint(:red, '-')} #{result.mutation.operator} " \
-               "#{MutationText.original(result)} -> #{@palette.paint(:green, MutationText.replacement(result))} " \
-               "#{result.digest}"
+               "#{change} #{result.digest}"
         text += " (ignored: #{result.ignored})" if result.ignored
         @out.puts text
         hint(result)

data/lib/saboteur/reporter/terminal.rb

@@ -91,6 +91,7 @@ module Saboteur
         seed = report.seed && ", seed #{report.seed} (repeat with --seed #{report.seed})"
         @out.puts "saboteur #{VERSION}: #{report.subjects.size} subjects, #{report.results.size} mutants, " \
                   "wall #{format('%.2f', report.wall_time)} s#{seed}"
+        @out.puts report.shard.line if report.shard
         @out.puts status_line(report)
         details(report)
         @score_table.call(report)
@@ -103,10 +104,12 @@ module Saboteur
         survived = "survived #{c[:survived]}"
         ignored = report.survivors.size - report.unignored_survivors.size
         survived += " (#{ignored} ignored)" if ignored.positive?
+        rejected = report.rejected_kills
+        rejected_note = " (#{rejected} rejected kill#{'s' if rejected > 1})" if rejected.positive?
         line = "#{@palette.paint(:green,
                                  "killed #{c[:killed]}")}  #{@palette.paint(:red,
                                                                             survived)}  timeout #{c[:timeout]}  " \
-               "resource limit #{c[:resource_limit]}  error #{c[:error]}  skipped #{c[:skipped]}"
+               "resource limit #{c[:resource_limit]}  error #{c[:error]}#{rejected_note}  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?
@@ -122,11 +125,19 @@ module Saboteur
 
       def details(report)
         breakdown = report.score_breakdown
-        @out.puts "score #{percent(breakdown.value)}" \
-                  "#{if @verbose
-                       "#{score_split(breakdown)} (killed+timeout)/(killed+survived+timeout); " \
-                         'errors, resource limits and skips excluded'
-                     end}"
+        # The share covers scored mutants only, so an error-dominated run
+        # must not print it as a bare score: "score 100.0 %" above "the run
+        # tested almost nothing" reads as a contradiction (#557).
+        if report.majority_errored?
+          @out.puts "score n/a (#{breakdown.tested} of #{report.executed.size} mutants scored, " \
+                    "#{percent(breakdown.value)} of scored)"
+        else
+          @out.puts "score #{percent(breakdown.value)}" \
+                    "#{if @verbose
+                         "#{score_split(breakdown)} (killed+timeout)/(killed+survived+timeout); " \
+                           'errors, resource limits and skips excluded'
+                       end}"
+        end
         report.skip_reasons.each { |reason, count| @out.puts "skipped: #{reason}: #{count}" }
         reused = report.results.count(&:reused?)
         @out.puts "reused #{reused} of #{report.results.size} verdicts from earlier runs (--incremental)" if
@@ -233,6 +244,7 @@ module Saboteur
         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")
+        budget_shortfall(stop, report.results.size)
         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}" }
@@ -243,6 +255,17 @@ module Saboteur
         @out.puts "  ... #{entries.size - MAX_ERRORS} more" if entries.size > MAX_ERRORS
       end
 
+      def budget_shortfall(stop, completed)
+        return unless stop.reason == "max_duration"
+
+        line = if stop.planned_mutants
+                 "partial: #{stop.planned_mutants - completed} of #{stop.planned_mutants} mutants not run"
+               else
+                 "partial: mutant count unknown; the budget was spent before planning finished"
+               end
+        @out.puts @palette.paint(:yellow, line)
+      end
+
       def early_stop_summary(stop)
         parts = []
         if stop.unreached.any?
@@ -264,10 +287,20 @@ module Saboteur
       end
 
       def errors(report)
-        errored = report.results.select { |result| result.status == :error }
+        # Rejected kills are verdicts, not tool errors: the tests failed,
+        # but they also fail with the method unchanged (#375).
+        rejected, errored = report.results.select { |result| result.status == :error }.partition(&:rejected_kill?)
+        unless rejected.empty?
+          @out.puts "\nRejected kills (tests also fail with the method unchanged; not counted as killed):"
+          print_error_lines(rejected)
+        end
         return if errored.empty?
 
         @out.puts "\nErrors (not counted as killed):"
+        print_error_lines(errored)
+      end
+
+      def print_error_lines(errored)
         errored.first(MAX_ERRORS).each do |result|
           lines = result.reason.to_s.lines.map(&:strip)
           @out.puts "  #{result.subject.id} #{result.mutation.operator} #{result.digest}: #{lines.first}"

data/lib/saboteur/result.rb

@@ -23,6 +23,11 @@ module Saboteur
     attr_reader :subject, :mutation, :status, :reason, :runtime, :killed_by, :covered_by, :mutated_source,
                 :kill_cause, :executed
     attr_accessor :ignored
+    # The ignore list's triage for this survivor (#155): a state from
+    # IgnoreList::STATES and its reason. accepted_equivalent and wont_fix
+    # suppress the exit failure (the survivor still counts in the score); a
+    # todo survivor keeps counting as an unignored survivor.
+    attr_accessor :triage_state, :triage_reason
 
     def initialize(subject:, mutation:, status:, mutated_source:, reason: nil, runtime: nil, killed_by: [],
                    covered_by: [], kill_cause: nil, reused: false, rejected_kill: false, executed: nil)
@@ -41,6 +46,9 @@ module Saboteur
       @rejected_kill = rejected_kill
       @reused = reused
       @ignored = nil
+      # triage_state/triage_reason stay unset until the ignore list writes
+      # them: the accessors read as nil before that, and there is no
+      # statement for a mutation to remove (#304 dogfood).
     end
 
     # The same mutant, marked unverified: the budget ran out before its
@@ -117,7 +125,11 @@ module Saboteur
   # subjects that started but stopped mid-way as {subject:, omitted:}
   # entries; unverified lists the subjects whose kills the budget left
   # unchecked. The verdict covers only completed, verified work.
-  EarlyStop = Data.define(:reason, :unreached, :truncated, :unverified)
+  EarlyStop = Data.define(:reason, :unreached, :truncated, :unverified, :planned_mutants) do
+    def initialize(reason:, unreached:, truncated:, unverified:, planned_mutants: nil)
+      super
+    end
+  end
 
   # Everything one run produced.
   class Report
@@ -127,14 +139,14 @@ module Saboteur
 
     attr_reader :results, :subjects, :wall_time, :invalid_mutations, :warnings, :root, :seed, :skipped_subjects,
                 :generation_events, :omissions, :run_evidence, :hazard_suppressions, :early_stop, :inline_suppressions,
-                :operator_policy, :discovery_failures
+                :operator_policy, :discovery_failures, :memory, :shard
 
     # REVIEW: diff mode; the terminal then shows one survivor per line.
     # seed: the random seed every test run started from (nil when unknown).
     def initialize(results:, subjects:, wall_time:, root:, invalid_mutations: 0, warnings: [], review: false,
                    seed: nil, skipped_subjects: {}, diff_scope: nil, generation_events: [], omissions: [],
                    run_evidence: nil, hazard_suppressions: 0, early_stop: nil, matrix: false, inline_suppressions: [],
-                   operator_policy: nil, discovery_failures: [])
+                   operator_policy: nil, discovery_failures: [], memory: nil, shard: nil)
       @results = results
       @subjects = subjects
       @wall_time = wall_time
@@ -154,6 +166,10 @@ module Saboteur
       @inline_suppressions = inline_suppressions.dup.freeze
       @operator_policy = operator_policy
       @discovery_failures = discovery_failures.dup.freeze
+      # Per-worker and supervisor peak RSS in MB, when the platform measured
+      # it (#202); nil elsewhere, so JSON reports omit the section.
+      @memory = memory.dup.freeze
+      @shard = shard
     end
 
     # A --matrix run: every covering test ran per mutant.