saboteur 0.6.0 → 0.8.0

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/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

@@ -39,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
 

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
@@ -58,7 +70,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)
@@ -100,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
@@ -115,17 +141,24 @@ 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
 
       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
 
-        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_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_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/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

@@ -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)
@@ -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,12 +104,15 @@ 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?
         line
       end
 
@@ -121,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
@@ -223,17 +235,51 @@ 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")
+        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}" }
+      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 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?
+          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)
@@ -241,13 +287,24 @@ 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|
-          @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

data/lib/saboteur/result.rb

@@ -12,7 +12,10 @@ module Saboteur
   # test can observe a change there, so it is outside the score.
   # unreachable: a Method object captured before re-evaluation still calls
   # the original body, so no test can observe the mutant. Outside the score.
-  STATUSES = %i[killed survived timeout resource_limit error skipped ran_at_load unreachable].freeze
+  # unverified: the --max-duration budget ran out before the verdict check
+  # or timeout calibration could run, so the kill or timeout proves
+  # nothing. Outside the score; the run reports budget-partial.
+  STATUSES = %i[killed survived timeout resource_limit error skipped ran_at_load unreachable unverified].freeze
 
   # Outcome of one mutation. reason carries the skip reason, the error
   # message or the timeout limit. ignored is the ignore-list reason, if any.
@@ -20,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)
@@ -38,6 +46,17 @@ 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
+    # verdict could be checked, so it must not count as detected (#296).
+    def as_unverified(reason)
+      MutantResult.new(subject: subject, mutation: mutation, status: :unverified, mutated_source: mutated_source,
+                       reason: reason, runtime: runtime, killed_by: killed_by, covered_by: covered_by,
+                       kill_cause: kill_cause, executed: executed)
     end
 
     # The same mutant, marked as an error: its verdict did not hold up.
@@ -100,10 +119,17 @@ module Saboteur
     end
   end
 
-  # A run that stopped before every selected subject was mutated (--fail-fast).
-  # unreached lists the subject ids that never ran; the verdict covers only
-  # the subjects that did.
-  EarlyStop = Data.define(:reason, :unreached)
+  # A run that stopped before every selected subject was mutated (--fail-fast,
+  # --max-duration), or whose budget ran out before every verdict check.
+  # unreached lists the subject ids that never ran; truncated lists the
+  # 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, :planned_mutants) do
+    def initialize(reason:, unreached:, truncated:, unverified:, planned_mutants: nil)
+      super
+    end
+  end
 
   # Everything one run produced.
   class Report
@@ -113,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
+                :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)
+                   operator_policy: nil, discovery_failures: [], memory: nil, shard: nil)
       @results = results
       @subjects = subjects
       @wall_time = wall_time
@@ -139,6 +165,11 @@ module Saboteur
       @matrix = matrix
       @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.