saboteur 0.11.0 → 0.11.2

data/lib/saboteur/preview.rb

@@ -59,8 +59,13 @@ module Saboteur
       @diagnostics.warnings.each { |warning| @out.puts("warning: #{warning}") }
     end
 
+    # The default set is what --list-operators prints, so a preview leads
+    # with it only when the selection was changed or --verbose asks (#1178).
     def announce_operators
-      @out.puts("Operators: #{@config.operator_policy['effective'].join(', ')}") unless @json
+      return if @json
+      return unless @config["verbose"] || @config["operators"].any? || @config["exclude_operators"].any?
+
+      @out.puts("Operators: #{@config.operator_policy['effective'].join(', ')}")
     end
 
     # Candidate filtering precedes diff restriction and the per-method cap.

data/lib/saboteur/reporter/agent_commands.rb

@@ -22,6 +22,11 @@ module Saboteur
                           baseline_passes: "--baseline-passes", max_duration: "--max-duration",
                           shard: "--shard" }.freeze
 
+        # Not part of the selection a replay reproduces: a shard is a slice of
+        # it, and a report path would overwrite the report the replay came
+        # from (the audit preset names whole-project reports, #1185).
+        REPLAY_SKIPPED = %i[shard json_report html_report].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.
@@ -40,14 +45,30 @@ module Saboteur
 
           # 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]
+          # report: narrows the replay to the mutant's covering spec files
+          # instead of the run's full inferred list (#1148).
+          def replay(provenance, digest, capped: true, report: nil)
+            words = ["saboteur", "run", "--id", digest,
+                     *selection(provenance, replay: true, tests: report && covering_files(report, digest)),
+                     "--seed", provenance.seed.to_s]
             finish(words, provenance, capped: capped)
           end
 
           private
 
+          # A replay needs only the specs that cover the mutant, not every
+          # inferred file (#1148): covered_by holds RSpec ids like
+          # "./spec/fee_spec.rb[1:2]", so strip the example suffix. nil when
+          # the survivor has no covering ids - then the whole selection
+          # stays, since dropping it would widen the replay to inference.
+          def covering_files(report, digest)
+            result = report.results.find { |entry| entry.digest == digest }
+            return unless result
+
+            files = result.covered_by.filter_map { |id| id[%r{\A\.?/?(.+?\.rb)\[}, 1] }.uniq
+            files unless files.empty?
+          end
+
           def finish(words, provenance, capped: true)
             words += ["--", *provenance.sources] unless provenance.sources.empty?
             command = Shellwords.join(words)
@@ -76,7 +97,7 @@ module Saboteur
           # (#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 [] if replay && REPLAY_SKIPPED.include?(key)
               next [] unless provenance.settings.key?(key)
 
               value = provenance.settings[key]
@@ -88,13 +109,14 @@ module Saboteur
 
           # Whole-suite scope is a bare --all, only when no tests resolved;
           # --all never combines with --test.
-          def selection(provenance, replay: false)
+          def selection(provenance, replay: false, tests: nil)
+            tests ||= provenance.tests
             words = []
             words.push("--config", provenance.config_path) if provenance.config_path
             words.push("--since", provenance.ref) if provenance.ref
             provenance.subjects.each { |subject| words.push("--subject", subject) }
-            words << "--all" if provenance.settings[:all] && provenance.tests.empty?
-            words.push(*test_words(provenance.tests))
+            words << "--all" if provenance.settings[:all] && tests.empty?
+            words.push(*test_words(tests))
             words.concat(setting_words(provenance, replay: replay))
             words.concat(mode_words(provenance))
             words.push("--id", provenance.digest) if provenance.digest && !replay

data/lib/saboteur/reporter/agent_incomplete.rb

@@ -40,8 +40,7 @@ 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, "unverified", report.counts[:unverified],
-                "mutants the --max-duration budget left unverified; their kills are not confirmed")
+            unverified_reasons(reasons, report)
             discovery_failures(reasons, report)
             early_stop_reason(reasons, report)
             inline_scope(reasons, report)
@@ -70,6 +69,14 @@ module Saboteur
                 "included untracked files could not be read; their subjects were not covered")
           end
 
+          def unverified_reasons(reasons, report)
+            flaky = report.results.count(&:flaky?)
+            add(reasons, "unverified", report.counts[:unverified] - flaky,
+                "mutants the --max-duration budget left unverified; their kills are not confirmed")
+            add(reasons, "flaky", flaky,
+                "mutants gave a different verdict on the --flaky-check reordered rerun; they are unverified")
+          end
+
           def early_stop_reason(reasons, report)
             stop = report.early_stop
             return unless stop

data/lib/saboteur/reporter/agent_summary.rb

@@ -123,7 +123,8 @@ module Saboteur
             steps = {}
             add_command(steps, :rerun, Commands.rerun(provenance))
             first = Findings.build(report)[:survivors].first
-            add_command(steps, :replay, Commands.replay(provenance, first[:digest])) if first
+            # report: narrows the replay to covering specs, as on the run screen (#1148).
+            add_command(steps, :replay, Commands.replay(provenance, first[:digest], report: report)) if first
             steps[:fullReport] = provenance.json_report if short_path?(provenance.json_report)
             steps
           end

data/lib/saboteur/reporter/baseline_tail.rb

@@ -24,12 +24,14 @@ module Saboteur
         new_count = gate.new_survivor_ids.size
         return pass_line(gate) if new_count.zero?
 
-        "saboteur: #{matched_count(gate)} matched the baseline#{breakdown(gate)} " \
-          "#{@palette.glyph(:middot)} #{@palette.paint(:fail, counted(new_count, 'new survivor'))}"
+        matched = @palette.paint(:dim, "#{matched_count(gate)} matched the baseline#{breakdown(gate)}")
+        "saboteur: #{matched} #{@palette.glyph(:middot)} " \
+          "#{@palette.paint(:fail, counted(new_count, 'new survivor'))}"
       end
 
       def pass_line(gate)
-        line = "saboteur: #{matched_count(gate)} matched the baseline, no new survivors"
+        matched = @palette.paint(:dim, "#{matched_count(gate)} matched the baseline")
+        line = "saboteur: #{matched}, #{@palette.paint(:pass, 'no new survivors')}"
         current, baseline = score_pair(gate)
         line << " - score #{current} (baseline #{baseline})" if current
         line
@@ -80,13 +82,13 @@ module Saboteur
       end
 
       def pass_hint
-        @palette.paint(:dim, "re-baseline deliberately #{@palette.glyph(:middot)} " \
-                             "run without --baseline weekly to catch drift")
+        hint = "re-baseline deliberately #{@palette.glyph(:middot)} run without --baseline weekly to catch drift"
+        @palette.paint(:info, hint)
       end
 
       def fail_hint
-        "  #{@palette.paint(:dim, 're-baseline deliberately: saboteur baseline accept ' \
-                                  "#{@palette.glyph(:middot)} run full weekly")}"
+        hint = "re-baseline deliberately: saboteur baseline accept #{@palette.glyph(:middot)} run full weekly"
+        "  #{@palette.paint(:info, hint)}"
       end
     end
   end

data/lib/saboteur/reporter/gap_kinds.rb

@@ -0,0 +1,80 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # The gap-kind vocabulary (D2): which sort of check a survivor suggests
+    # is missing, as a LABEL ONLY (#192) - a heuristic from the operator and
+    # the edit shape, never a diagnosis, and never a score input.
+    module GapKinds
+      KINDS = %w[boundary branch effect number] + ["error path", "result unchecked"].freeze
+
+      # Operator -> gap kind, every built-in operator exactly once except
+      # operand_replacement, whose kind depends on the replaced expression
+      # (a comparison loses its boundary; anything else is a plain result).
+      # Anything missing here - a new operator before its row lands - is
+      # the honest fallback: result unchecked.
+      BY_OPERATOR = {
+        "comparison" => "boundary",
+        "range" => "boundary",
+        "endpoint_replacement" => "boundary",
+        "condition_negation" => "branch",
+        "condition_true" => "branch",
+        "condition_false" => "branch",
+        "boolean_logic" => "branch",
+        "negation_removal" => "branch",
+        "when_removal" => "branch",
+        "safe_navigation" => "branch",
+        "filter_replacement" => "branch",
+        "statement_removal" => "effect",
+        "element_removal" => "effect",
+        "argument_removal" => "effect",
+        "pair_removal" => "effect",
+        "chain_removal" => "effect",
+        "copy_replacement" => "effect",
+        "literal_number" => "number",
+        "arithmetic" => "number",
+        "unary_removal" => "number",
+        "operator_assignment" => "number",
+        "rescue_removal" => "error path",
+        "ensure_removal" => "error path",
+        "body_raise" => "error path",
+        "body_nil" => "result unchecked",
+        "body_true" => "result unchecked",
+        "body_false" => "result unchecked",
+        "literal_string" => "result unchecked",
+        "literal_boolean" => "result unchecked",
+        "or_assign" => "result unchecked",
+        "and_assign" => "result unchecked",
+        "argument_swap" => "result unchecked",
+        "method_swap" => "result unchecked",
+        "interpolation_removal" => "result unchecked",
+        "jump_value" => "result unchecked",
+        "regex_replacement" => "result unchecked"
+      }.freeze
+
+      # The one operator whose kind comes from the edit shape, not the name.
+      SHAPE_DECIDED = %w[operand_replacement].freeze
+
+      FALLBACK = "result unchecked"
+
+      # The deterministic per-kind reason printed next to a survivor's rank.
+      REASONS = {
+        "boundary" => "the covering specs pass without pinning this boundary",
+        "branch" => "the covering specs pass without pinning this branch",
+        "effect" => "the covering specs pass without pinning this effect",
+        "number" => "the covering specs pass without pinning this number",
+        "error path" => "the covering specs pass without pinning this error path",
+        "result unchecked" => "the covering specs pass without pinning this result"
+      }.freeze
+
+      module_function
+
+      def kind(operator, comparison_edit: false)
+        return comparison_edit ? "boundary" : FALLBACK if SHAPE_DECIDED.include?(operator)
+
+        BY_OPERATOR.fetch(operator, FALLBACK)
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/html.rb

@@ -4,7 +4,9 @@
 require "cgi"
 require "fileutils"
 
+require_relative "../survivor_guidance"
 require_relative "survivor_classification"
+require_relative "wording"
 
 module Saboteur
   module Reporter
@@ -31,13 +33,61 @@ module Saboteur
         .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}
+        .copy{font-size:11px;padding:0 .3rem;margin-left:.3rem;cursor:pointer}
         .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}
+        /* Paper cannot scroll sideways, and the dark viewer is screen-only
+           ink: print the table, not the widget, and let wide tables wrap. */
+        @media print{
+          mutation-test-report-app{display:none}
+          .copy,.print-hide{display:none}
+          details::details-content{content-visibility:visible}
+          body{max-width:none}
+          table{min-width:0}
+          .scroll{overflow-x:visible}
+        }
       CSS
 
       SCORE_FORMULA = "(killed + timeout) / (killed + survived + timeout)"
 
+      # A file section holding a survivor, timeout or error opens on load -
+      # but only the first OPEN_FILE_LIMIT of them, and only while the open
+      # rows stay under OPEN_ROW_BUDGET, so a big run does not land as a wall
+      # of expanded rows. The rest stay collapsed, survivor count in the header.
+      OPEN_FILE_LIMIT = 10
+      OPEN_ROW_BUDGET = 30
+
+      # Statuses worth opening a file for on load: a survivor, a timeout or an
+      # error is exactly what a reader needs to inspect.
+      ATTENTION_STATUSES = %w[Survived Timeout RuntimeError].freeze
+
+      # Survivor rows get a copy button for the replay command. file:// is a
+      # secure context, so navigator.clipboard works; the textarea fallback
+      # covers browsers where it rejects without a gesture. One delegated
+      # listener keeps the page free of per-row scripts.
+      COPY_SCRIPT = <<~JS
+        document.addEventListener("click",function(event){
+        var button=event.target.closest("button.copy");if(!button)return;
+        var text=button.getAttribute("data-copy");
+        function done(){button.textContent="copied";setTimeout(function(){button.textContent="copy"},1200)}
+        function fallback(){var area=document.createElement("textarea");area.value=text;
+        document.body.appendChild(area);area.select();try{document.execCommand("copy")}catch(e){}
+        document.body.removeChild(area);done()}
+        if(navigator.clipboard&&navigator.clipboard.writeText){navigator.clipboard.writeText(text).then(done,fallback)}
+        else{fallback()}})
+      JS
+
+      # Fallback for engines without details::details-content (the print CSS
+      # does this JS-free where supported): open every details for the
+      # printout, then restore the reader's open/closed state afterwards.
+      PRINT_SCRIPT = <<~JS
+        (function(){var wasClosed=[];
+        window.addEventListener("beforeprint",function(){wasClosed=[];
+        document.querySelectorAll("details:not([open])").forEach(function(d){wasClosed.push(d);d.open=true})});
+        window.addEventListener("afterprint",function(){wasClosed.forEach(function(d){d.open=false});wasClosed=[]})})();
+      JS
+
       # The vendored viewer bundle, embedded verbatim into every report.
       BUNDLE_PATH = File.expand_path("assets/mutation_report.js", __dir__)
 
@@ -66,6 +116,7 @@ module Saboteur
         results = report.results.to_h do |result|
           [[Stryker.relative(result.subject.file, report.root), result.digest], result]
         end
+        sections, collapsed = file_sections(data, names, results, report)
         <<~HTML
           <!DOCTYPE html>
           <html lang="en"><head><meta charset="utf-8">
@@ -75,10 +126,12 @@ module Saboteur
           <script>#{bundle}</script></head><body>
           <h1>saboteur report</h1>
           #{headline(report)}
+          #{scope_note(report)}
           <mutation-test-report-app theme="dark" title-postfix="saboteur"></mutation-test-report-app>
           <script type="application/json" id="saboteur-report-json">#{embed_json(data)}</script>
           <script>document.querySelector("mutation-test-report-app").report =
-          JSON.parse(document.getElementById("saboteur-report-json").textContent);</script>
+          JSON.parse(document.getElementById("saboteur-report-json").textContent);
+          #{COPY_SCRIPT}#{PRINT_SCRIPT}</script>
           <details><summary>How the score is computed</summary>
           #{summary(report, data)}
           </details>
@@ -86,7 +139,7 @@ module Saboteur
           <h2>Files</h2>
           <p class="note">The viewer above and this table list the same mutants; the table adds notes,
           covering tests and triage reasons.</p>
-          #{data[:files].map { |file, entry| file_section(file, entry, names, results, report) }.join("\n")}
+          #{collapse_note(collapsed)}#{file_listing(sections)}
           </body></html>
         HTML
       end
@@ -99,11 +152,13 @@ module Saboteur
       def headline(report)
         breakdown = report.score_breakdown
         text = "<p><strong>Covered mutation score: #{score_text(report.score)}</strong>"
-        text << " (#{breakdown.detected}/#{breakdown.tested} killed, tested subjects)" if breakdown.tested.positive?
+        if breakdown.tested.positive?
+          text << " (#{breakdown.detected}/#{breakdown.tested} #{Wording.detected_word(breakdown)}, tested subjects)"
+        end
         untested = report.skipped_subjects.count { |_, reason| reason == ScoreTable::NO_COVERAGE }
         if untested.positive?
           noun = untested == 1 ? "subject" : "subjects"
-          text << " - #{untested} #{noun} not scored - no tests exist"
+          text << " - #{untested} #{noun} not scored - #{Wording.no_execution(untested)}"
         end
         "#{text}</p>"
       end
@@ -126,13 +181,27 @@ module Saboteur
         "<h2>Inline suppressions (#{items.size}, outside the score)</h2><ul>#{items.join}</ul>"
       end
 
+      # A diff run's score covers only the changed lines; the shareable
+      # page says so, or a reader takes it for the whole project.
+      def scope_note(report)
+        return "" unless report.diff? && report.since
+
+        "<p class=\"note\">Diff run: only lines changed since #{escape(report.since)} are mutated - " \
+          "the score covers those changes, not the whole project.</p>"
+      end
+
+      # "1 subject, 2 mutants": each count pluralizes on its own (C9).
+      def counts_note(report)
+        "#{Text.counted(report.subjects.size, 'subject')}, #{Text.counted(report.results.size, 'mutant')}"
+      end
+
       def summary(report, data)
         seed = data.dig(:config, :seed)
         seed_note = seed ? ", seed #{seed}" : ""
         counts = data[:files].values.flat_map { |entry| entry[:mutants] }.map { |mutant| mutant[:status] }.tally
         <<~HTML
           <p><strong>Covered mutation score: #{score_text(report.score)}</strong>
-          (#{report.subjects.size} subjects, #{report.results.size} mutants, #{format('%.1f', report.wall_time)}s#{seed_note})</p>
+          (#{counts_note(report)}, #{format('%.1f', report.wall_time)}s#{seed_note})</p>
           <p class="note">Covered mutation score = #{SCORE_FORMULA}. NoCoverage, errors, resource limits and skipped
           mutants are not counted. Survivors accepted on the ignore list stay in the denominator. It covers only the subjects of this run, not the whole project. A tool that reads the
           Stryker JSON may show a different score, because the schema counts NoCoverage as undetected.</p>
@@ -201,15 +270,81 @@ module Saboteur
         data[:testFiles].values.flat_map { |group| group[:tests] }.to_h { |test| [test[:id], test[:name]] }
       end
 
-      def file_section(file, entry, names, results, report)
-        open = entry[:mutants].any? { |mutant| mutant[:status] == "Survived" } ? " open" : ""
-        ordered = entry[:mutants].sort_by { |mutant| position_key(mutant) }
+      # The sections in page order; the open set is the top survivor-bearing
+      # files by survivor count, within the row budget. Returns the rendered
+      # sections and the count of survivor-bearing files left collapsed.
+      def file_sections(data, names, results, report)
+        survivors = data[:files].to_h do |file, entry|
+          [file, entry[:mutants].count { |mutant| mutant[:status] == "Survived" }]
+        end
+        attention = data[:files].to_h do |file, entry|
+          [file, entry[:mutants].count { |mutant| ATTENTION_STATUSES.include?(mutant[:status]) }]
+        end
+        open_set = open_files(data, attention)
+        collapsed = data[:files].keys.count { |file| attention[file].positive? && !open_set[file] }
+        sections = data[:files].map do |file, entry|
+          file_section(file, entry, names, results, report, survivor_count: survivors[file], open_file: open_set[file])
+        end
+        [sections, collapsed]
+      end
+
+      # The open set: the top attention-bearing files by attention count,
+      # while the open rows stay under the budget.
+      def open_files(data, attention)
+        ranked = data[:files].keys.select { |file| attention[file].positive? }
+                             .sort_by { |file| [-attention[file], file] }
+        open_set = {}
+        rows = 0
+        ranked.first(OPEN_FILE_LIMIT).each do |file|
+          break if rows >= OPEN_ROW_BUDGET
+
+          open_set[file] = true
+          rows += data[:files].fetch(file)[:mutants].size
+        end
+        open_set
+      end
+
+      def collapse_note(collapsed)
+        noun = collapsed == 1 ? "file" : "files"
+        if collapsed.zero?
+          ""
+        else
+          "<p class=\"note print-hide\" id=\"files\">#{collapsed} #{noun} " \
+            "with survivors, timeouts or errors collapsed - " \
+            "<a href=\"#files\" onclick=\"document.querySelectorAll('details.file').forEach" \
+            "(function(d){d.open=true});return false\">expand all</a></p>\n"
+        end
+      end
+
+      def file_section(file, entry, names, results, report, survivor_count:, open_file:)
+        open = open_file ? " open" : ""
+        # Attention rows (survivors, timeouts, errors) come first, so a big
+        # file's survivors are not buried between killed rows; position
+        # order holds within each group (#1233).
+        ordered = entry[:mutants].sort_by { |mutant| [attention_rank(mutant), *position_key(mutant)] }
         rows = ordered.map { |mutant| mutant_row(mutant, names, results[[file, mutant[:id]]], report) }
-        "<details#{open}><summary>#{escape(file)} (#{entry[:mutants].size} mutants)</summary>\n" \
+        "<details class=\"file\"#{open}><summary>#{escape(file)} " \
+          "(#{entry[:mutants].size} mutants#{survivors_note(survivor_count, open_file)})</summary>\n" \
           "<div class=\"scroll\"><table><thead><tr><th>Location</th><th>Status</th><th>Operator</th><th>Change</th>" \
           "<th>Id</th><th>Notes</th></tr></thead>\n#{rows.join("\n")}</table></div></details>"
       end
 
+      # A collapsed survivor file names its survivors in the header, so the
+      # count is visible without expanding it.
+      def file_listing(sections)
+        return sections.join("\n") unless sections.empty?
+
+        "<p class=\"note\">No mutants - nothing to show.</p>"
+      end
+
+      def survivors_note(survivor_count, open_file)
+        open_file || survivor_count.zero? ? "" : ", #{survivor_count} survivor#{'s' unless survivor_count == 1}"
+      end
+
+      def attention_rank(mutant)
+        ATTENTION_STATUSES.include?(mutant[:status]) ? 0 : 1
+      end
+
       def position_key(mutant)
         start = mutant[:location][:start]
         [start[:line], start[:column], mutant[:id]]
@@ -222,7 +357,8 @@ module Saboteur
         "<tr><td class=\"fit\">#{location_cell(mutant[:location][:start], result, report)}</td>" \
           "<td>#{row_status(mutant, result)}</td>" \
           "<td>#{escape(mutant[:mutatorName])}</td><td class=\"wide\">#{change(mutant, result)}</td>" \
-          "<td class=\"fit\"><code>#{escape(mutant[:id])}</code></td><td class=\"wide\">#{escape(notes)}</td></tr>"
+          "<td class=\"fit\"><code>#{escape(mutant[:id])}</code>#{copy_button(mutant, seed: report.seed)}</td>" \
+          "<td class=\"wide\">#{escape(notes)}</td></tr>"
       end
 
       # In diff mode, the changed lines the mutant touches, under its own
@@ -251,6 +387,20 @@ module Saboteur
         "covered by #{passed.size} #{passed.one? ? 'test' : 'tests'} that #{when_passed}: #{shown}#{extra}"
       end
 
+      # Only survivors are worth replaying, so only they get the button.
+      # Every row's button reads "copy"; the aria-label names the mutant it
+      # belongs to, so a screen reader's button list stays navigable.
+      def copy_button(mutant, seed: nil)
+        return unless mutant[:status] == "Survived"
+
+        replay = escape(SurvivorGuidance.replay_command(mutant[:id], seed: seed))
+        start = mutant[:location][:start]
+        label = escape("Copy the replay command for #{mutant[:mutatorName]} " \
+                       "at line #{start[:line]}, column #{start[:column]}")
+        "<button type=\"button\" class=\"copy\" data-copy=\"#{replay}\" aria-label=\"#{label}\" " \
+          'title="Copy the replay command">copy</button>'
+      end
+
       def row_status(mutant, result)
         badge = status_label(mutant[:status])
         # Only survivors are ever put on the ignore list.

data/lib/saboteur/reporter/next_steps.rb

@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require_relative "../survivor_guidance"
+
 module Saboteur
   module Reporter
     # The footer under a run that left survivors: how to look at one, how to
@@ -26,14 +28,14 @@ module Saboteur
         if command
           @out.puts "  replay one survivor: #{@palette.paint(:info, command)}"
         else
-          seed = " --seed #{report.seed}" if report.seed
-          @out.puts "  replay one survivor: " \
-                    "#{@palette.paint(:info, "saboteur run --id #{survivor.digest}#{seed}")}"
-          @out.puts "    (add this run's own --config, --since, --subject, --test and source options)"
+          command = SurvivorGuidance.replay_command(survivor.digest, seed: report.seed)
+          @out.puts "  replay one survivor: #{@palette.paint(:info, command)}"
+          @out.puts "    #{SurvivorGuidance::REPLAY_CAVEAT}"
         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}"
+        @out.puts "  #{SurvivorGuidance::IGNORE_INTRO}"
+        @out.puts "    Saboteur.ignore do |i|"
+        @out.puts "      #{SurvivorGuidance.ignore_entry(survivor.digest, survivor.subject.id)}"
+        @out.puts "    end"
         @out.puts "  let an agent close the gaps: saboteur run --agent, with the same options"
       end
     end

data/lib/saboteur/reporter/notice.rb

@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # One coat of paint for every warning notice: the fact lines carry the
+    # :warn token, a "Fix:" line (the two-line shape) stays :dim. Colour
+    # only - the writers own the wording, and monochrome passes the text
+    # through byte-identical.
+    module Notice
+      module_function
+
+      # Paint line by line so a multi-line notice keeps its shape: any line
+      # starting with "Fix:" is the actionable tail and stays dim, every
+      # other line is the warning fact.
+      def paint(palette, text)
+        text.lines.map do |line|
+          line = line.chomp
+          palette.paint(line.start_with?("Fix:") ? :dim : :warn, line)
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/reuse_note.rb

@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "../engine/result_cache"
+
+module Saboteur
+  module Reporter
+    # Verdict-reuse feedback: named whenever the run opted into reuse, since a
+    # silent run leaves the flag's effect unknowable. A plain run (no reuse
+    # mechanism, nothing reused) stays silent. The label is the flag
+    # the user typed (--incremental or --resume, Engine#reuse_label). The
+    # denominator counts only storable verdicts (Engine::ResultCache::STORED);
+    # skips and errors are never cached, so naming them explains a short one.
+    class ReuseNote
+      def initialize(out)
+        @out = out
+      end
+
+      def print(report)
+        return unless report.results.any? && (report.reuse_label || report.results.any?(&:reused?))
+
+        reused = report.results.count(&:reused?)
+        label = report.reuse_label || "--incremental"
+        if reused.zero?
+          @out.puts "no verdicts reused from earlier runs (#{label}): first #{label} run, " \
+                    "or every mutant's inputs changed"
+          return
+        end
+
+        storable = report.results.count { |result| Engine::ResultCache::STORED.include?(result.status) }
+        line = "reused #{reused} of #{storable} verdicts from earlier runs (#{label})"
+        reruns = report.results.size - storable
+        @out.puts reruns.positive? ? "#{line}; #{reruns} skipped/errored mutant(s) always rerun" : line
+      end
+    end
+  end
+end