saboteur 0.11.0 → 0.11.2

data/lib/saboteur/reporter/review_comments.rb

@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require_relative "gap_kinds"
+
 module Saboteur
   module Reporter
     # Pull-request review comments for surviving mutants (#246): decides what
@@ -25,11 +27,10 @@ module Saboteur
       # Labels whose survivors are probably noise: never worth a comment.
       QUIET = %w[likely_equivalent arid].freeze
 
-      HINTS = {
-        "missing_test" => "A test reaches this line and still passes with the change. " \
-                          "Add an assertion that pins this behaviour.",
-        "tool_limit" => "Saboteur could not observe this mutant faithfully. Check it by hand."
-      }.freeze
+      GAP_HINT = "A test reaches this line and still passes with the change. " \
+                 "Add an assertion that pins this behaviour."
+      TOOL_LIMIT_HINT = "Saboteur could not observe this mutant faithfully. Check it by hand."
+      HINTS = GapKinds::KINDS.to_h { |label| [label, GAP_HINT] }.merge("tool_limit" => TOOL_LIMIT_HINT).freeze
       DEFAULT_HINT = "No test fails with this change. Check whether a test should pin it."
 
       Plan = Struct.new(:post, :delete, :summary, keyword_init: true)
@@ -57,12 +58,8 @@ module Saboteur
         end
 
         def body(finding)
-          [marker(finding["digest"]),
-           "**Surviving mutant** (`#{word(finding['operator'])}`): this change did not make any test fail.",
-           "",
-           fenced(finding["original"], "Original"),
-           fenced(finding["replacement"], "Mutant"),
-           "",
+          [marker(finding["digest"]), opening(finding), "",
+           fenced(finding["original"], "Original"), fenced(finding["replacement"], "Mutant"), "",
            hint(finding["classification"])].join("\n")
         end
 
@@ -128,7 +125,8 @@ module Saboteur
           return nil if left_out.zero?
 
           text = "#{SUMMARY_MARKER}\n#{left_out} more surviving mutant#{'s' unless left_out == 1} " \
-                 "not shown as comments."
+                 "not shown as comments. Add a test that fails for each one, or accept it in " \
+                 "config/saboteur_ignore.rb with a reason."
           HTTPS_URL.match?(run_url.to_s) ? "#{text} Full report: #{run_url}" : text
         end
 
@@ -136,6 +134,13 @@ module Saboteur
           HINTS.fetch(label, DEFAULT_HINT)
         end
 
+        # The subject rides in the opening line: notification mail shows the
+        # body without its diff (#1212). Empty when there is none.
+        def opening(finding)
+          subject = finding["subject"].to_s.gsub(/[`\r\n]/, "")[0, 60].then { |n| n.empty? ? "" : " in `#{n}`" }
+          "**Surviving mutant** (`#{word(finding['operator'])}`)#{subject}: this change did not make any test fail."
+        end
+
         def word(text)
           text.to_s.gsub(/[^\w:.-]/, "")[0, 40]
         end

data/lib/saboteur/reporter/score_table.rb

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require_relative "wording"
 require_relative "../score"
 
 module Saboteur
@@ -62,7 +63,7 @@ module Saboteur
           detected: breakdown.detected, tested: breakdown.tested, untested: untested }
       end
 
-      # "cart.rb  100.0% (2/2) · n/a - 2 subjects have no tests: ...": the
+      # "cart.rb  100.0% (2/2) · n/a - 2 subjects - no test executes them: ...": the
       # tested score and the untested count stand next to each other; a
       # file with nothing tested gets no percentage at all.
       def line(row, width)
@@ -74,18 +75,18 @@ module Saboteur
         note ? "#{base} #{@palette.glyph(:middot)} #{note}" : base
       end
 
-      # "n/a - 2 subjects have no tests: Cart#total, Cart#biggest": names
-      # the subjects the score cannot speak for, capped so a long list does
-      # not swallow the row; the Not scored block lists them all.
+      # "n/a - 2 subjects - no test executes them: Cart#total, Cart#biggest":
+      # names the subjects the score cannot speak for, capped so a long
+      # list does not swallow the row; the Not scored block lists them all.
+      # Wording owns the claim (#1145): a stubbed-away subject has tests,
+      # they just never execute it.
       def untested_note(untested)
         return if untested.empty?
 
         names = untested.map(&:id)
         shown = names.first(MAX_UNTESTED_NAMES)
         shown << "+#{names.size - MAX_UNTESTED_NAMES} more" if names.size > MAX_UNTESTED_NAMES
-        count = untested.size
-        @palette.paint(:warn, "n/a - #{count} subject#{'s' unless count == 1} " \
-                              "#{count == 1 ? 'has' : 'have'} no tests: #{shown.join(', ')}")
+        @palette.paint(:warn, "n/a - #{Wording.untested_note(untested.size)}: #{shown.join(', ')}")
       end
     end
   end

data/lib/saboteur/reporter/stryker.rb

@@ -41,7 +41,16 @@ module Saboteur
           warnings: report.warnings,
           framework: { name: "saboteur", version: VERSION },
           saboteur: saboteur_enrichment(report, exit_cause, score_gates)
-        }.merge(report.seed ? { config: { seed: report.seed } } : {})
+        }.merge(report_config(report))
+      end
+
+      # The run's recorded settings: the seed, and the --since ref of a diff
+      # run, so a consumer can tell a diff-scoped score from a project one.
+      def self.report_config(report)
+        config = {}
+        config[:seed] = report.seed if report.seed
+        config[:since] = report.since if report.diff? && report.since
+        config.empty? ? {} : { config: config }
       end
 
       # saboteur-namespaced keys beyond Stryker's schema: findings and
@@ -110,6 +119,7 @@ module Saboteur
       def self.mutant(result, source, test_ids)
         entry = {
           id: result.digest,
+          subject: result.subject.id,
           mutatorName: result.mutation.operator,
           replacement: result.mutation.edits.map(&:replacement).join(" | "),
           location: location(result.mutation.edits.first, source),

data/lib/saboteur/reporter/survivor_classification.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "../engine/bytecode_equivalence"
+require_relative "gap_kinds"
 require_relative "../execution/external_runner"
 require_relative "../mutation_source/builtin"
 
@@ -21,11 +22,14 @@ module Saboteur
     #   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.
+    #   A gap kind (boundary, branch, effect, number, error path, or the
+    #     result unchecked fallback) - a test covered the line and passed,
+    #     which MAY mean the suite reaches the code without pinning this
+    #     behaviour; the kind names WHAT sort of check is missing, from the
+    #     operator and the edit shape only. The covering list is only the
+    #     PLANNED coverage: whole-body (coarse) mutants carry method-level
+    #     guesses, so they never get a gap kind, and neither does anything
+    #     without real coverage.
     #   tool_limit   - survivors saboteur could not observe faithfully: an
     #     external-runner run records only the pseudo-test id, never real
     #     coverage (#1071). A re-eval refusal records no signal on the
@@ -33,7 +37,7 @@ module Saboteur
     #
     # A survivor with no matching signal stays unlabeled.
     module SurvivorClassification
-      LABELS = %w[likely_equivalent arid missing_test tool_limit].freeze
+      LABELS = %w[likely_equivalent arid tool_limit].concat(GapKinds::KINDS).freeze
 
       class << self
         def label(result, arid: MutationSource::Builtin::DEFAULT_ARID)
@@ -41,7 +45,7 @@ module Saboteur
           return "likely_equivalent" if equivalent?(result)
           return "arid" if arid?(result, arid)
           return "tool_limit" if tool_limited?(result)
-          return "missing_test" if possible_test_gap?(result)
+          return gap_kind(result) if possible_test_gap?(result)
 
           nil
         end
@@ -66,11 +70,25 @@ module Saboteur
 
         # An external runner reports one pseudo id for every mutant and no
         # coverage map, so a survivor there was never observed against real
-        # tests. Pseudo id next to a real id keeps missing_test (#305).
+        # tests. Pseudo id next to a real id keeps the gap kind (#305).
         def tool_limited?(result)
           result.covered_by.any? && result.covered_by.all? { |id| id == Execution::ExternalRunner::PSEUDO_TEST }
         end
 
+        # The gap kind says which sort of check the survivor suggests:
+        # the operator decides for almost everything; operand_replacement
+        # looks at the replaced expression (comparison -> boundary).
+        def gap_kind(result)
+          GapKinds.kind(result.mutation.operator, comparison_edit: comparison_edit?(result))
+        end
+
+        def comparison_edit?(result)
+          result.mutation.edits.any? do |edit|
+            result.subject.file_source.byteslice(edit.start_byte...edit.end_byte)
+                  &.match?(/<=>|<=|>=|==|!=|===|<|>/)
+          end
+        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

data/lib/saboteur/reporter/survivor_hints.rb

@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require_relative "gap_kinds"
+
 module Saboteur
   module Reporter
     # Suggests a check that might kill a surviving mutant, by operator. It does
@@ -94,9 +96,8 @@ module Saboteur
       LABEL_REASONS = {
         "likely_equivalent" => "compiles to the same instructions as the original",
         "arid" => "every edited line matches an arid pattern",
-        "missing_test" => "the covering specs pass without pinning this change",
         "tool_limit" => "the tool could not observe this mutant faithfully"
-      }.freeze
+      }.merge(GapKinds::REASONS).freeze
 
       module_function
 

data/lib/saboteur/reporter/survivor_list.rb

@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require "shellwords"
+
 require_relative "diff"
 require_relative "mutation_text"
 require_relative "survivor_classification"
@@ -17,6 +19,11 @@ module Saboteur
     # --all-mutants gives every survivor its own block. Accepted
     # (ignored) survivors get one quoted dim line each, never a block.
     class SurvivorList
+      # Default when a caller never wires the whole-suite lookup (unit pins,
+      # other renderers): keep the historical bare covered-by line. Terminal
+      # always passes the kwarg - nil there means the lookup ran and found
+      # no cached whole-suite map (review C1).
+      NO_WHOLE_SUITE_LOOKUP = Object.new
       # Rendered rows in the method fence, elision markers included.
       FENCE_CAP = 10
 
@@ -26,11 +33,14 @@ module Saboteur
       # Sibling digests named on the collapse line; the rest are a count.
       SIBLING_DIGEST_CAP = 3
 
-      def initialize(out, palette, all_mutants: false, classifier: SurvivorClassification)
+      def initialize(out, palette, all_mutants: false, classifier: SurvivorClassification,
+                     whole_suite_map: NO_WHOLE_SUITE_LOOKUP, run_map: nil)
         @out = out
         @palette = palette
         @all_mutants = all_mutants
         @classifier = classifier
+        @whole_suite_map = whole_suite_map
+        @run_map = run_map
       end
 
       # Survivors in report (ranked) order; accepted ones trail as dim lines.
@@ -39,7 +49,8 @@ module Saboteur
 
         live, accepted = survivors.partition(&:unignored_survivor?)
         @out.puts @palette.paint(:head, "Survivors (#{live.size}) - changes your tests did not catch")
-        groups(live).each_with_index { |group, index| block(report, group, index + 1, live.size) }
+        block_list = groups(live)
+        block_list.each_with_index { |group, index| block(report, group, index + 1, block_list.size) }
         accepted_section(report, accepted)
         hinted = live.select { |result| hint_for(result) }
         @out.puts "\n#{@palette.paint(:dim, SurvivorHints::CAVEAT)}" if hinted.any?
@@ -70,9 +81,12 @@ module Saboteur
         siblings(report, group)
       end
 
+      # The count names blocks, the unit the leading ordinal uses: grouped
+      # siblings read "#3 of 14 blocks", never blocks against mutants (#1147).
       def label_suffix(result, rank, total)
         label = @classifier.label(result)
-        parts = [label, "##{rank} of #{total}"].compact
+        unit = total == 1 ? "block" : "blocks"
+        parts = [("coarse" if result.mutation.coarse), label, "##{rank} of #{total} #{unit}"].compact
         reason = SurvivorHints.label_reason(label)
         "[#{parts.join(" \u00B7 ")}#{": #{reason}" if reason}]"
       end
@@ -176,8 +190,38 @@ module Saboteur
 
       # The covering tests are a group union (#502): the first names where an
       # assertion would pin the change, the count says the rest also passed.
+      #
+      # The list comes from the run's own map, which a scoped run narrows to
+      # the specs it loaded. The cached whole-suite map (when one exists)
+      # tells the rest of the story (review C1): a covering spec the run never
+      # loaded is named as not run here, and a spec pinning the mutant's exact
+      # line marks the block as likely covered elsewhere, instead of reading
+      # as a bare finding. With no whole-suite map, say so rather than
+      # implying the list is complete. A whole-project run's own map IS the
+      # whole-suite map, so its line is unchanged.
       def covered(group)
         tests = group.flat_map(&:covered_by).uniq
+        return legacy_covered(group, tests) if @whole_suite_map.equal?(NO_WHOLE_SUITE_LOOKUP)
+
+        whole = @whole_suite_map&.tests_for(group.first.subject)
+        if whole.nil?
+          @out.puts @palette.paint(:dim, "  covering tests unknown - run a full coverage build")
+          return
+        end
+
+        run_known = @run_map ? @run_map.tests_for(group.first.subject) : tests
+        not_run = whole - run_known
+        return legacy_covered(group, tests) if not_run.empty?
+
+        @out.puts "  covered by #{whole.size} #{whole.one? ? 'spec' : 'specs'}, " \
+                  "incl. #{not_run.first} (not run here)"
+        exact = exact_line_tests(group.first) - run_known
+        return if exact.empty?
+
+        @out.puts @palette.paint(:dim, "  likely covered elsewhere: #{exact.first} pins this line (not run here)")
+      end
+
+      def legacy_covered(group, tests)
         return if tests.empty?
 
         first = group.find { |result| result.covered_by.include?(tests.first) }
@@ -186,6 +230,14 @@ module Saboteur
         @out.puts @palette.paint(:dim, "  #{line}") if line
       end
 
+      # Tests pinning the mutant's exact edit lines in the whole-suite map,
+      # on the same line basis the scheduler used to select the run's tests:
+      # the strongest "already pinned elsewhere" evidence a map can give.
+      def exact_line_tests(result)
+        lines = result.mutation.edits.flat_map { |edit| result.subject.coverage_lines_for(edit) }.uniq
+        @whole_suite_map.tests_for_edit(result.subject, lines)
+      end
+
       # The verdict names what this run did: executed is nil when the run
       # did not record which tests ran, so only the bare verdict is safe.
       def more_covered_line(group, tests)
@@ -235,7 +287,9 @@ module Saboteur
         overflow = rest.size - SIBLING_DIGEST_CAP
         list = "#{list} (+#{overflow} more)" if overflow.positive?
         @out.puts @palette.paint(:dim, "  #{rest.size} more #{rest.one? ? 'mutant' : 'mutants'} here: #{list}")
-        @out.puts @palette.paint(:dim, "       expand: saboteur run --all-mutants#{' --since main' if report.diff?}")
+        words = ["saboteur", "run", "--all-mutants"]
+        words.push("--since", report.since) if report.diff? && report.since
+        @out.puts @palette.paint(:dim, "       expand: #{Shellwords.join(words)}")
       end
 
       # Accepted (ignored) survivors stay visible but never earn a block:

data/lib/saboteur/reporter/survivor_ranking.rb

@@ -5,19 +5,27 @@ module Saboteur
   module Reporter
     # Review priority, not a claim that a survivor is a real defect.
     module SurvivorRanking
-      ORDERING = "coarse first, then more covering tests, larger edited-line span, " \
-                 "nearer changed lines, then file, line and digest"
+      ORDERING = "surviving mutants per statement descending, then fewer covering tests, " \
+                 "coarse first, larger edited-line span, nearer changed lines, " \
+                 "then file, line and digest"
 
       def self.ordered(report, results)
-        results.sort_by { |result| key(report, result) }
+        sizes = results.group_by { |result| statement(report, result) }.transform_values(&:size)
+        results.sort_by { |result| key(report, result, sizes) }
       end
 
-      def self.key(report, result)
-        [result.mutation.coarse ? 0 : 1, -result.covered_by.uniq.size, -edited_lines(result).size,
+      def self.key(report, result, statement_sizes = {})
+        [-statement_sizes.fetch(statement(report, result), 0), result.covered_by.uniq.size,
+         result.mutation.coarse ? 0 : 1, -edited_lines(result).size,
          report.changed_line_distance(result) || Float::INFINITY,
          result.subject.file.delete_prefix("#{report.root}/"), first_line(result), result.digest]
       end
 
+      # Statement identity: same subject at the same first mutated line.
+      def self.statement(report, result)
+        [result.subject.file.delete_prefix("#{report.root}/"), result.subject.id, first_line(result)]
+      end
+
       def self.first_line(result)
         result.subject.line_of(result.mutation.edits.map(&:start_byte).min)
       end

data/lib/saboteur/reporter/terminal.rb

@@ -2,15 +2,18 @@
 # frozen_string_literal: true
 
 require_relative "safe_out"
+require_relative "wording"
 require_relative "baseline_tail"
 require_relative "next_steps"
 require_relative "kill_causes"
 require_relative "survivor_ranking"
 require_relative "palette"
+require_relative "notice"
 require_relative "score_table"
 require_relative "survivor_list"
 require_relative "survivor_classification"
 require_relative "test_matrix"
+require_relative "reuse_note"
 
 module Saboteur
   module Reporter
@@ -25,17 +28,19 @@ module Saboteur
       def initialize(out, verbose: false, quiet: false, color: :auto, overrides: nil,
                      replay_command: nil, all_mutants: false, exit_code: nil,
                      threshold: nil, previous_score: nil, baseline_gate: nil,
-                     scope: "whole project", html_report: nil, baseline: nil, coverage: nil, mutant_phase: nil)
+                     scope: "whole project", baseline: nil, coverage: nil, mutant_phase: nil,
+                     whole_suite_map: SurvivorList::NO_WHOLE_SUITE_LOOKUP, run_map: nil)
         @out = SafeOut.new(out)
         @all_mutants = all_mutants
         @verbose = verbose
         @quiet = quiet
-        # Clean-screen context: scope and report path from the CLI; PR4a plumbs the phase stats.
+        # Clean-screen context: scope from the CLI; PR4a plumbs the phase stats.
         @scope = scope
-        @html_report = html_report
         @baseline = baseline
         @coverage = coverage
         @mutant_phase = mutant_phase
+        @whole_suite_map = whole_suite_map
+        @run_map = run_map
         @palette = Palette.for(out, mode: color, overrides: overrides)
         @score_table = ScoreTable.new(@out, @palette)
         @next_steps = NextSteps.new(@out, @palette, replay_command: replay_command)
@@ -141,9 +146,9 @@ module Saboteur
       # numbers so "4 mutants" is not read as the whole plan (#582).
       def mutant_counts(report)
         planned = report.early_stop&.planned_mutants
-        return "#{report.results.size} mutants" unless planned && planned > report.results.size
+        return Text.counted(report.results.size, "mutant") unless planned && planned > report.results.size
 
-        "#{planned} mutants selected, #{report.results.size} attempted"
+        "#{Text.counted(planned, 'mutant')} selected, #{report.results.size} attempted"
       end
 
       def summary(report)
@@ -151,7 +156,7 @@ module Saboteur
         return clean_screen(report) if !@baseline_gate && clean_run?(report)
 
         seed = report.seed && ", seed #{report.seed} (repeat with --seed #{report.seed})"
-        tally = "saboteur #{VERSION}: #{report.subjects.size} subjects, #{mutant_counts(report)}, " \
+        tally = "saboteur #{VERSION}: #{Text.counted(report.subjects.size, 'subject')}, #{mutant_counts(report)}, " \
                 "wall #{format('%.2f', report.wall_time)} s#{seed}"
         @out.puts @palette.paint(:dim, tally)
         @out.puts report.shard.line if report.shard
@@ -183,8 +188,11 @@ module Saboteur
         total = @palette.paint(:dim, "#{middot} #{format('%.1f', report.wall_time)}s total")
         @out.puts "#{@palette.paint(:pass, win)} #{total}"
         untested = untested_subjects(report)
-        @out.puts "  #{@palette.paint(:warn, untested_win_note(untested))}" if untested.any?
-        clean_reports_line
+        @out.puts "  #{@palette.paint(:warn, Wording.untested_win_note(untested))}" if untested.any?
+        ReuseNote.new(@out).print(report)
+        # The footer owns the report paths (#1187); the clean screen's own
+        # hint is the follow-up run a whole-project win suggests.
+        @out.puts "  #{@palette.paint(:dim, 'next: saboteur run --since origin/main')}" if @scope == "whole project"
       end
 
       # The phase lines and the progress-dots line print only when their data
@@ -206,19 +214,6 @@ module Saboteur
         "#{report.counts[:killed]}/#{report.executed.size} mutants killed"
       end
 
-      def untested_win_note(untested)
-        ids = untested.map(&:id).join(", ")
-        "#{untested.size} subject#{'s' unless untested.one?} not scored - no tests exist: #{ids}"
-      end
-
-      def clean_reports_line
-        return unless @html_report
-
-        line = "reports: #{@html_report}"
-        line += " #{middot} next: saboteur run --since origin/main" if @scope == "whole project"
-        @out.puts "  #{@palette.paint(:dim, line)}"
-      end
-
       def hazard_suppressions(report)
         return unless report.hazard_suppressions.positive?
 
@@ -247,22 +242,26 @@ module Saboteur
         end
 
         line = "Score: #{painted_score(breakdown.value)}#{headline_context(breakdown.value)}"
-        line << if breakdown.tested.zero?
-                  " - nothing tested"
-                else
-                  " (#{breakdown.detected}/#{breakdown.tested} killed, tested subjects)"
-                end
+        line << score_parenthetical(breakdown)
         if @verbose && breakdown.tested.positive?
           line << "#{score_split(breakdown)} (killed+timeout)/(killed+survived+timeout); " \
                   "errors, resource limits and skips excluded"
         end
         if untested.any?
           line << "  #{@palette.paint(:warn, "#{untested.size} subject#{'s' unless untested.one?} " \
-                                             'not scored - no tests exist')}"
+                                             "not scored - #{Wording.no_execution(untested.size)}")}"
         end
         @out.puts line
       end
 
+      # The share of tested mutants the run detected: "killed" alone would
+      # count timeouts too, so Wording names both when one is in the number.
+      def score_parenthetical(breakdown)
+        return " - nothing tested" if breakdown.tested.zero?
+
+        " (#{breakdown.detected}/#{breakdown.tested} #{Wording.detected_word(breakdown)}, tested subjects)"
+      end
+
       # What the score is judged against and where it came from: the
       # threshold it must meet, and the last score the history recorded.
       def headline_context(value)
@@ -304,7 +303,7 @@ module Saboteur
         return if untested.empty?
 
         @out.puts
-        @out.puts @palette.paint(:warn, "Not scored - no tests exist (treat these as your biggest gaps):")
+        @out.puts @palette.paint(:warn, "Not scored - no test executes these (treat these as your biggest gaps):")
         entries = untested.map { |subject| "#{subject.id} (#{subject.location(report.root)})" }
         line = "  #{@palette.paint(:warn, '!')} #{entries.first(MAX_NOT_SCORED).join(" #{middot} ")}"
         line << " #{middot} ... #{entries.size - MAX_NOT_SCORED} more" if entries.size > MAX_NOT_SCORED
@@ -410,9 +409,7 @@ module Saboteur
 
       def details(report)
         report.skip_reasons.each { |reason, count| @out.puts skip_reason_line(reason, count) } if @verbose
-        reused = report.results.count(&:reused?)
-        @out.puts "reused #{reused} of #{report.results.size} verdicts from earlier runs (--incremental)" if
-          reused.positive?
+        ReuseNote.new(@out).print(report)
         @out.puts "invalid mutations dropped (did not parse): #{report.invalid_mutations}" if
           report.invalid_mutations.positive?
         hazard_suppressions(report)
@@ -568,7 +565,7 @@ module Saboteur
       # but are not printed a second time here.
       def warnings(report)
         report.warnings.each do |warning|
-          @out.puts "warning: #{warning}" unless report.live_announced.include?(warning)
+          @out.puts Notice.paint(@palette, "warning: #{warning}") unless report.live_announced.include?(warning)
         end
       end
 
@@ -596,7 +593,9 @@ module Saboteur
       end
 
       def survivors(report)
-        SurvivorList.new(@out, @palette, all_mutants: @all_mutants).call(report, ranked_survivors(report))
+        SurvivorList.new(@out, @palette, all_mutants: @all_mutants,
+                                         whole_suite_map: @whole_suite_map, run_map: @run_map)
+                    .call(report, ranked_survivors(report))
         @out.puts unless report.survivors.empty?
       end
 

data/lib/saboteur/reporter/wording.rb

@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # One wording for the score parenthetical and the not-scored note, so
+    # the terminal screen and the HTML page never drift (#1145, #1146).
+    module Wording
+      module_function
+
+      # detected counts timeouts, the tally does not: name both when a
+      # timeout is in the number, or "killed" means two things in adjacent
+      # lines (#1146).
+      def detected_word(breakdown)
+        breakdown.timeouts.positive? ? "killed or timed out" : "killed"
+      end
+
+      # A subject with no coverage may have tests that stub it away: the
+      # honest claim is about execution, not existence (#1145).
+      def no_execution(untested_count)
+        untested_count == 1 ? "no test executes it" : "no test executes them"
+      end
+
+      # The score table's per-file note fragment: count, subject noun and
+      # the execution claim in one shape (#1145).
+      def untested_note(count)
+        "#{count} subject#{'s' unless count == 1} - #{no_execution(count)}"
+      end
+
+      # The clean screen's one-line note for subjects no run scored.
+      def untested_win_note(untested)
+        ids = untested.map(&:id).join(", ")
+        "#{untested.size} subject#{'s' unless untested.one?} not scored - #{no_execution(untested.size)}: #{ids}"
+      end
+    end
+  end
+end