saboteur 0.11.2 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45635354d2b8067e2de9a11025677af615e3eb54da14dfcd26f0afbdcdd00073
-  data.tar.gz: 40a395d6909fb4bcec99596c6b34e4b40edf1b72c76b349ab25cb3ae44b48726
+  metadata.gz: e9537980fed0394bdadcbd64d8e637e55cfb42925b5673d2ee30e6f0b18bb13e
+  data.tar.gz: a628132a21155e240bc856c99707f46323f280929344048be98a746fa74d1c9b
 SHA512:
-  metadata.gz: 3f3dd155c87c3c6a45d1fd66a66cc5ec21d8c56dd5113dab2568cd07cc957ee2ba34bfc1b773cf4610aeee822e354bf36cc747418bcee24902365563f5f2b5c2
-  data.tar.gz: 23f785f27b3396a38195f44d6a418d819d6c7359fe34a8ec9f8422855206b53a5ebd634eb70d8c8d40cf622787a9795d99395950932a5870a2418d8651520aa9
+  metadata.gz: c96be31b305e173850739c426f5343fb6a24b416cb5f923b30cfea4a8764fb0c9dd3eeeb5dc8b00af132e16267e8e4135ea84d2d5669b38e35433323e94c072c
+  data.tar.gz: 9763cf728f40ad70a714665bc4cdf09ce0a9d516d7da9101bb137f60cdb378a5715d321d8b71d725ac635736b167a9ce6ec3b8c5e99632ef1f204cea49ad3e94

data/CHANGELOG.md

@@ -6,6 +6,63 @@ All notable changes are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.12.1] - 2026-10-22
+
+### Changed
+
+- `--quiet` now stays quiet from startup: the start header, baseline
+  line, inference detail and progress bar no longer print. A `--since`
+  diff that selects no mutants exits 0 with a plain "nothing to gate"
+  note instead of failing a score threshold, and `--ignore-empty` is a
+  deprecated no-op. A diff with suppressed, omitted or undiscovered
+  mutants, or with an unverifiable scope, still gates (#1268, #1142,
+  #1149).
+- `saboteur survivors` lists survivors ranked by default, matching
+  `run`, and owns its own command surface and help (#1269, #1150).
+
+### Fixed
+
+- An error-dominated run no longer prints a bare score: the terminal
+  closing line and the HTML report headline and summary say `n/a`, like
+  the terminal headline already did (#1275, #1271, #1276, #1272).
+
+### Tests
+
+- New end-to-end pins for per-path score gates, the `Score: n/a`
+  headline, the README get-started flow, parallel coverage parts and
+  the trace recorder, survivor triage labels, kills split by cause and
+  a docs-only `--since` diff under a threshold (#1270, #1273, #1278,
+  #1279, #1280, #1281, #1277, #1159, #1158).
+
+## [0.12.0] - 2026-10-22
+
+### Added
+
+- The default report is short: a findings list, the top three expanded
+  survivor blocks and `--details` for the rest, with a per-phase
+  wall-time speed footer and the slowest mutant. Fixed template lines
+  fit 80 columns and the piped-progress margin is wider so the summary
+  fits 80-column logs (#1256, #1152).
+- A run on a Rails app with no `config/saboteur.rb` now defaults
+  `include` to `app/**/*.rb` and says so in the missing-config notice,
+  instead of exiting 2. A written config, even an empty one, keeps the
+  plain defaults, and a CLI `--include` still wins (#1257, #1171).
+- The terminal summary prints one dim line under Score when mutants sit
+  on lines no test runs, saying they are not in the score and that the
+  JSON report lists them as `NoCoverage` (#1259, #1190).
+
+### Changed
+
+- Uncovered survivors are labeled `input_gap`, separate from assertion
+  gaps (#1254, #1157).
+
+### Tests
+
+- End-to-end pins for `--shard K/N` and the score history, badge and
+  trend commands, and for a stub-only method reported as not executed
+  (#1260, #1261, #1158, #1159). The survivor-ranking regression
+  fixture is the real money gem `allocation.rb` (#1262, #1160).
+
 ## [0.11.2] - 2026-10-22
 
 ### Added

data/lib/saboteur/cli/exit_status.rb

@@ -15,7 +15,7 @@ module Saboteur
       def exit_code(report)
         return EXIT_BUDGET if budget_exhausted?(report)
 
-        return EXIT_OK if ignore_empty_diff?(report)
+        return EXIT_OK if empty_clean_diff?(report)
 
         return EXIT_TOOL if untested_partial?(report)
 
@@ -29,14 +29,18 @@ module Saboteur
         gates.failed?(report, @err, record_cause: !quality_failed) || quality_failed ? EXIT_SURVIVORS : EXIT_OK
       end
 
-      # --ignore-empty: a --since diff that selected no mutants exits 0 with
-      # a note; suppressed, omitted or undiscovered mutants still gate.
-      def ignore_empty_diff?(report)
-        return false unless config["ignore_empty"] && config["since"] && report.results.empty?
+      # A --since diff that selected no mutants exits 0 with a plain note,
+      # with or without --ignore-empty: a docs-only change has no score, so a
+      # threshold must not fail it (#1142). Suppressed, omitted or
+      # undiscovered mutants still gate - the selection must be honestly
+      # empty, not just empty-handed.
+      def empty_clean_diff?(report)
+        return false unless config["since"] && report.results.empty?
+        return false if unverifiable_scope?(report)
         return false unless report.omissions.empty? && report.inline_suppressions.empty? &&
                             report.discovery_failures.empty?
 
-        @err.puts("saboteur: no mutants in the diff - nothing to gate (--ignore-empty)")
+        @err.puts("saboteur: no mutants in the diff - nothing to gate")
         true
       end
 

data/lib/saboteur/cli/output_options.rb

@@ -42,6 +42,10 @@ module Saboteur
         end
         opts.on("--all-mutants", "Text report: list every survived mutant;",
                 "default: one finding per statement, with the label mix") { set(:all_mutants, true) }
+        # D1: the default whole-project report lists findings and expands the
+        # top three; --details restores a block for every finding.
+        opts.on("--details", "Text report: full blocks for every finding;",
+                "default: one-line list plus the top 3 blocks") { set(:details, true) }
         opts.on("--no-color", "Deprecated alias for --color=never") { @color = :never }
       end
     end

data/lib/saboteur/cli/run_command.rb

@@ -25,7 +25,13 @@ module Saboteur
         return if @format == "agent" || config.config_file_present
 
         path = options[:config] || Config::FILE
-        notice = "saboteur: no #{path} - using defaults (Rails: bundle exec rails generate saboteur:install writes one)"
+        notice =
+          if config["include"] == Config::RAILS_INCLUDE && !config.explicit?("include")
+            "saboteur: no #{path} - Rails app detected, mutating app/**/*.rb " \
+              "(bundle exec rails generate saboteur:install writes a config)"
+          else
+            "saboteur: no #{path} - using defaults (Rails: bundle exec rails generate saboteur:install writes one)"
+          end
         @err.puts(palette.paint(:dim, notice))
       end
 

data/lib/saboteur/cli/run_reporting.rb

@@ -21,7 +21,7 @@ module Saboteur
         Reporter::Terminal.new(@out, verbose: @verbose || false, quiet: @quiet || false, color: @color || :auto,
                                      overrides: config["palette"], threshold: config["threshold"],
                                      replay_command: survivor_replay_command(report, engine),
-                                     all_mutants: options[:all_mutants] || false,
+                                     all_mutants: options[:all_mutants] || false, details: options[:details] || false,
                                      exit_code: code, previous_score: previous_score, scope: scope_label,
                                      whole_suite_map: whole_suite_map_for(engine),
                                      run_map: engine&.run_coverage_map,
@@ -81,7 +81,7 @@ module Saboteur
 
         # Text mode only: the engine prints a per-subject marks line when
         # --verbose is on (#262); --agent output stays as it is.
-        engine = Engine.new(config, **arguments, verbose: @verbose || false)
+        engine = Engine.new(config, **arguments, verbose: @verbose || false, quiet: @quiet || false)
         text_run(engine.call, engine)
       end
 

data/lib/saboteur/cli/selection_options.rb

@@ -22,8 +22,9 @@ module Saboteur
         opts.on("--id DIGEST", "Replay exactly one current mutant by its full digest") { |v| set(:id, v) }
         opts.on("--shard K/N", "Run one of N deterministic candidate shards (for example 1/4)") { |v| set(:shard, v) }
         opts.on("--since REF", "Only mutate subjects changed since git REF") { |v| options[:since] = v }
-        opts.on("--ignore-empty", "A --since diff that selects no mutants exits 0 with a note instead of " \
-                                  "failing a score gate") { set(:ignore_empty, true) }
+        opts.on("--ignore-empty", "Deprecated no-op: the no-mutant diff case always exits 0 (#1142)") do
+          set(:ignore_empty, true)
+        end
         flaky_desc = "Confirm a fresh verdict (survivors, decisive) with one reordered rerun"
         opts.on("--flaky-check MODE", %w[off survivors decisive], flaky_desc) { |v| set(:flaky_check, v) }
         opts.on("--subject EXPR", "Klass#meth, Klass.meth or a namespace; repeatable") { |v| add_subject(v) }

data/lib/saboteur/cli/survivors_command.rb

@@ -2,8 +2,10 @@
 # frozen_string_literal: true
 
 require "json"
+require "stringio"
 
 require_relative "../survivor_guidance"
+require_relative "../reporter/palette"
 require_relative "../reporter/survivor_hints"
 
 module Saboteur
@@ -17,6 +19,11 @@ module Saboteur
       # Where `saboteur run` writes the JSON report unless configured otherwise.
       DEFAULT_REPORT = Config::DEFAULTS["json_report"]
 
+      # survivors owns its usage line (#1150): the report path is optional
+      # because the run always writes the same default.
+      SURVIVORS_USAGE = "Usage: saboteur survivors [options] [REPORT] - REPORT defaults to " \
+                        ".saboteur/report.json"
+
       private
 
       def survivors_command
@@ -27,28 +34,50 @@ module Saboteur
       end
 
       def survivors_command_inner
-        parser = OptionParser.new do |opts|
-          opts.on("--ranked", "Review-priority order: the report's ranked findings first")
-          opts.on("--file SUBSTR", "Only survivors whose path contains SUBSTR")
-          opts.on("--operator NAME", "Only survivors of operator NAME")
-          opts.on("--triage LABEL", "Only survivors classified LABEL (for example boundary)")
-          opts.on("--show DIGEST", "Diff, replay command and ignore template for one survivor")
-        end
         options = {}
-        args = parser.parse!(@argv, into: options)
+        parser = survivors_parser(options)
+        args = parse_survivors_args(parser, options)
+        if options[:help]
+          @out.puts(parser)
+          return EXIT_OK
+        end
         path = args.shift || DEFAULT_REPORT
-        raise UsageError, "unexpected arguments: #{args.join(' ')}" if args.any?
+        raise UsageError, "unexpected arguments: #{args.join(' ')}\n#{parser}" if args.any?
 
         report = load_survivor_report(path)
-        browser = SurvivorsBrowser.new(report)
+        browser = SurvivorsBrowser.new(report, palette: Reporter::Palette.for(@out, mode: options.fetch(:color, :auto)))
         if options[:show]
           @out.puts(browser.show(options[:show]))
         else
-          @out.puts(browser.list(**options.slice(:ranked, :file, :operator, :triage)))
+          @out.puts(browser.list(**options.slice(:file, :operator, :triage)))
         end
         EXIT_OK
       end
 
+      # The same colour flags as run (#1150), plus the browser filters.
+      def survivors_parser(options)
+        OptionParser.new do |opts|
+          opts.banner = SURVIVORS_USAGE
+          opts.on("--ranked", "Review-priority order (the default): the terminal report's ordering")
+          opts.on("--file SUBSTR", "Only survivors whose path contains SUBSTR")
+          opts.on("--operator NAME", "Only survivors of operator NAME")
+          opts.on("--triage LABEL", "Only survivors classified LABEL (for example boundary)")
+          opts.on("--show DIGEST", "Diff, replay command and ignore template for one survivor")
+          opts.on("--color [MODE]", %w[always never auto],
+                  "Colour the output: always, never, or auto when MODE is omitted") do |mode|
+            options[:color] = (mode || :always).to_sym
+          end
+          opts.on("--no-color", "Alias for --color=never") { options[:color] = :never }
+          opts.on("--help", "Show this help") { options[:help] = true }
+        end
+      end
+
+      def parse_survivors_args(parser, options)
+        parser.parse!(@argv, into: options)
+      rescue OptionParser::ParseError => e
+        raise UsageError, "#{e.message}\n#{parser}"
+      end
+
       def load_survivor_report(path)
         unless File.file?(path)
           hint = path == DEFAULT_REPORT ? "; run saboteur first, or pass a report path" : ""
@@ -64,14 +93,21 @@ module Saboteur
     # Reads the report's files section (the complete mutant list), not the
     # capped findings, so survivors beyond the findings limit still list.
     class SurvivorsBrowser
-      def initialize(report)
+      # Sibling digests named on a collapse line; the rest are a count - the
+      # same shape the terminal report's collapse uses (#1150).
+      SIBLING_DIGEST_CAP = 3
+
+      def initialize(report, palette: Reporter::Palette.for(StringIO.new))
         @report = report
         @findings = report.dig("saboteur", "findings") || {}
+        @palette = palette
       end
 
-      def list(ranked: false, file: nil, operator: nil, triage: nil)
-        survivors = filtered(file, operator, triage)
-        survivors = ranked_order(survivors) if ranked
+      # One ordering everywhere (#1150): the terminal report's ranked order
+      # is the default, exactly as the findings carry it; --ranked stays
+      # accepted for compatibility.
+      def list(file: nil, operator: nil, triage: nil, **)
+        survivors = ranked_order(filtered(file, operator, triage))
         return "no survivors#{filters_note(file, operator, triage)}" if survivors.empty?
 
         [header(survivors.size, file, operator, triage), *rows(survivors)]
@@ -89,6 +125,7 @@ module Saboteur
           "  #{SurvivorGuidance::REPLAY_CAVEAT}",
           "",
           SurvivorGuidance::IGNORE_INTRO,
+          "  #{SurvivorGuidance::IGNORE_CONFIG}",
           "  #{ignore_entry(survivor, subject)}"
         ].join("\n")
       end
@@ -159,19 +196,32 @@ module Saboteur
       def header(size, file, operator, triage)
         text = "#{size} survivor#{'s' unless size == 1}#{filters_note(file, operator, triage)}"
         truncated = @findings["survivorsTruncated"].to_i
-        return text unless truncated.positive?
-
-        "#{text} (the report's ranked findings name only the first #{@findings['limit'] || 10})"
+        if truncated.positive?
+          text = "#{text} (the report's ranked findings name only the first #{@findings['limit'] || 10})"
+        end
+        @palette.paint(:head, text)
       end
 
+      # The terminal collapse: sibling mutants on one statement fold into the
+      # first row, which names up to SIBLING_DIGEST_CAP of their digests.
       def rows(survivors)
-        survivors.each_with_index.map do |s, i|
-          format("%3<i>d. %<path>s:%<line>d  %-28<operator>s %<digest>s  %<classification>s",
-                 i: i + 1, path: s[:path], line: s[:line], operator: s[:operator], digest: s[:digest],
-                 classification: s[:classification] || "-")
+        survivors.group_by { |s| [s[:path], s[:line]] }.values.each_with_index.map do |group, i|
+          first, *siblings = group
+          format("%3<i>d. %<path>s:%<line>d  %-28<operator>s %<digest>s  %<classification>s%<suffix>s",
+                 i: i + 1, path: first[:path], line: first[:line], operator: first[:operator],
+                 digest: first[:digest], classification: first[:classification] || "-",
+                 suffix: siblings_suffix(siblings))
         end
       end
 
+      def siblings_suffix(siblings)
+        return "" if siblings.empty?
+
+        named = siblings.first(SIBLING_DIGEST_CAP).map { |s| s[:digest] }.join(", ")
+        rest = siblings.size - SIBLING_DIGEST_CAP
+        "  (+#{siblings.size} here: #{named}#{", +#{rest} more" if rest.positive?})"
+      end
+
       def ignore_entry(survivor, subject)
         block = if subject
                   SurvivorGuidance.ignore_block(survivor[:digest], subject)
@@ -191,12 +241,17 @@ module Saboteur
                 subject: m["subject"], covered: m["coveredBy"] || [], source: entry["source"] }
             end
           end
-          survivors.sort_by { |s| [s[:path], s[:line], s[:digest]] }
+          survivors
         end
       end
 
+      # Ranked order straight from the report: the uncapped findings "order"
+      # list first, with the capped findings as the fallback for older
+      # reports; anything unknown trails in file order.
       def ranked_order(survivors)
-        rank = @findings.fetch("survivors", []).each_with_index.to_h { |f, i| [f["digest"], i] }
+        order = @findings["order"] ||
+                (@findings.fetch("survivors", []) + @findings.fetch("accepted", [])).map { |f| f["digest"] }
+        rank = order.each_with_index.to_h
         survivors.sort_by { |s| [rank[s[:digest]] || Float::INFINITY, -s[:covered].size, s[:path], s[:line], s[:digest]] }
       end
 

data/lib/saboteur/cli.rb

@@ -139,7 +139,7 @@ module Saboteur
 
     def agent_requested? = self.class.agent_requested?(@argv)
 
-    def overrides = options.except(:config, :id, :suite, :list_operators, :dry_run, :all_mutants, :quiet)
+    def overrides = options.except(:config, :id, :suite, :list_operators, :dry_run, :all_mutants, :quiet, :details)
 
     def add_subject(expr) = (options[:subjects] ||= []) << expr
 

data/lib/saboteur/config.rb

@@ -18,6 +18,11 @@ module Saboteur
     LEGACY_IGNORE_FILE = ".saboteur-ignore.yml"
     IGNORE_FILE = "config/saboteur_ignore.rb"
 
+    # A Rails app (config/application.rb + app/) without a config file gets
+    # the generator's include instead of the gem-shaped default, so a first
+    # run mutates app/ rather than refusing over an empty source set (#1171).
+    RAILS_INCLUDE = ["app/**/*.rb"].freeze
+
     # Settings that say where saboteur writes, never what it mutates: left
     # out of the run fingerprint, baseline evidence and score-history scope.
     OUTPUT_KEYS = %w[cache_dir json_report html_report score_history resume].freeze
@@ -145,9 +150,21 @@ module Saboteur
               "saboteur no longer reads #{LEGACY_IGNORE_FILE}; move its entries to #{IGNORE_FILE} (see README)."
       end
 
-      from_file = File.file?(path) ? ConfigFile.load(path) : {}
-      new(from_file.merge(stringify(overrides)), root: root, config_file_present: File.file?(path))
+      file_present = File.file?(path)
+      from_file = file_present ? ConfigFile.load(path) : {}
+      # Only a missing file triggers detection: a written config, even an
+      # empty one, means the defaults were chosen. The detected include is
+      # not an explicit key - the user set nothing.
+      detected = !file_present && rails_app?(root) ? { "include" => RAILS_INCLUDE } : {}
+      cli = stringify(overrides)
+      merged = detected.merge(from_file).merge(cli)
+      new(merged, root: root, explicit: from_file.keys | cli.keys, config_file_present: file_present)
+    end
+
+    def self.rails_app?(root)
+      File.file?(File.join(root, "config", "application.rb")) && File.directory?(File.join(root, "app"))
     end
+    private_class_method :rails_app?
 
     def self.stringify(hash)
       hash.to_h { |key, value| [key.to_s, value] }.compact

data/lib/saboteur/engine/diagnostics.rb

@@ -17,6 +17,12 @@ module Saboteur
       # be watched: the heartbeat then adds the count, the percentage and an
       # estimate of the time left to its elapsed-time line.
       class ProgressHeartbeat
+        # --quiet substitute: responds to the supervisor's calls, prints nothing.
+        NULL = Object.new.tap do |noop|
+          def noop.watch(*) = self
+          def noop.tick = nil
+        end
+
         COUNT = %r{(\d+)/([1-9]\d*) examples finished}
         TAIL_BYTES = 4096
 
@@ -77,9 +83,10 @@ module Saboteur
       # progress (see start_progress); the letter is legend-only.
       LEGEND = ".:killed S:survived T:timeout E:error s:skipped L:resource limit"
 
-      # Chunk sizing: leave room for the "  (n/total ...)" suffix, never
-      # below the floor.
-      CHUNK_MARGIN = 10
+      # Chunk sizing: leave room for the full "  n/total (100%) ETA 123m45s"
+      # summary suffix (32 columns), never below the floor, so a piped line
+      # fits an 80-column CI log instead of wrapping mid-summary.
+      CHUNK_MARGIN = 32
       CHUNK_FLOOR = 40
       DEFAULT_WIDTH = 80
 
@@ -90,9 +97,10 @@ module Saboteur
       attr_reader :warnings, :live_announced, :invalid_mutations, :generation_events, :omissions, :discovery_failures,
                   :hazard_suppressions, :inline_suppressions, :verbose, :quiet_start
 
-      def initialize(err, verbose: false, palette: nil, quiet_start: true)
+      def initialize(err, verbose: false, palette: nil, quiet_start: true, quiet: false)
         @err = err
         @verbose = verbose
+        @quiet = quiet
         @quiet_start = quiet_start
         @palette = palette || Reporter::Palette.for(err)
         @warnings = []
@@ -182,7 +190,7 @@ module Saboteur
       # Chatter the default view folds into the quiet-start lines;
       # --verbose prints it byte-for-byte as before.
       def detail(message)
-        inform(message) if @verbose || !@quiet_start
+        inform(message) if !@quiet && (@verbose || !@quiet_start)
       end
 
       # A selection explanation the default view carries as one dim
@@ -198,7 +206,7 @@ module Saboteur
       # The quiet start: three lines, then progress. --verbose keeps
       # today's chatter instead and never prints these.
       def quiet_start_header(scope:, seed:, operators:)
-        return if @verbose || !@quiet_start
+        return if @quiet || @verbose || !@quiet_start
 
         dot = @palette.glyph(:middot)
         line = "saboteur #{Saboteur::VERSION} #{dot} #{scope} #{dot} seed #{seed} #{dot} " \
@@ -207,7 +215,7 @@ module Saboteur
       end
 
       def quiet_baseline(passes:, elapsed:, tests:, cached:)
-        return if @verbose || !@quiet_start
+        return if @quiet || @verbose || !@quiet_start
 
         check = @palette.paint(:pass, @palette.glyph(:check))
         suffix = cached ? " (cached)" : ""
@@ -218,7 +226,7 @@ module Saboteur
       end
 
       def quiet_inference(spec_count)
-        return if spec_count.nil? || @verbose || !@quiet_start
+        return if spec_count.nil? || @quiet || @verbose || !@quiet_start
 
         files = spec_count == 1 ? "spec file" : "spec files"
         @err.puts(@palette.paint(:dim, "spec inference: #{spec_count} #{files} (details: --verbose)"))
@@ -251,6 +259,10 @@ module Saboteur
       # fork time. Prints "<label>: N s elapsed" about every interval
       # seconds, so a long phase does not look stuck.
       def progress_heartbeat(label, interval: 30)
+        # --quiet: the contract is findings, score and verdict - no elapsed
+        # chatter; the heartbeat's ticks become no-ops.
+        return ProgressHeartbeat::NULL if @quiet
+
         ProgressHeartbeat.new(self, label, interval: interval)
       end
 
@@ -260,6 +272,8 @@ module Saboteur
       # The count lives in one file the workers inherit, so every worker adds
       # to the same number.
       def start_progress(total)
+        return if @quiet
+
         @progress_total = total
         @progress_started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         @progress_file = Tempfile.new("saboteur-progress")
@@ -270,6 +284,8 @@ module Saboteur
       end
 
       def progress(result)
+        return if @quiet
+
         mark = MARKS.fetch(result.status, "?")
         return plain_progress(painted_mark(mark)) unless @progress_file
 

data/lib/saboteur/engine.rb

@@ -46,10 +46,11 @@ module Saboteur
     attr_reader :guessed_tests
 
     def initialize(config, err: $stderr, digest: nil, capture_evidence: false, evidence_files: [], verbose: false,
-                   palette: nil, quiet_start: true)
+                   palette: nil, quiet_start: true, quiet: false)
       @config = config
       @hooks = Hooks.new
-      @diagnostics = Diagnostics.new(err, verbose: verbose, palette: palette, quiet_start: quiet_start)
+      @diagnostics = Diagnostics.new(err, verbose: verbose, palette: palette, quiet_start: quiet_start,
+                                          quiet: quiet)
       @completed_baseline_passes = 0
       @baseline_elapsed = 0.0
       @root = File.realpath(config.root)
@@ -199,7 +200,8 @@ module Saboteur
                  matrix: config["matrix"], inline_suppressions: @diagnostics.inline_suppressions,
                  operator_policy: config.operator_policy, discovery_failures: @diagnostics.discovery_failures,
                  test_command: config["test_command"], reuse_label: reuse_label, since: config["since"],
-                 shard: @shard, memory: @memory_report, referenced: @guessed_referenced || {})
+                 shard: @shard, memory: @memory_report, referenced: @guessed_referenced || {},
+                 phase_timings: @phase_timings)
     end
 
     def complete_evidence(results, subjects)
@@ -226,14 +228,13 @@ module Saboteur
 
     def mutate(subjects, files, integration, scope, ignore_list, load_lines: {}, load_methods: {})
       store = coverage_store(integration, load_lines, load_methods)
-      full_passes = config["baseline_passes"] + (store.reusable?(files) ? 0 : 1)
-      warn_unscoped(integration, full_passes)
-      announce_quiet_start(store, files)
-      check_baseline(integration, full_passes)
+      map_reusable = store.reusable?(files)
+      full_passes = config["baseline_passes"] + (map_reusable ? 0 : 1)
+      baseline_preflight(store, integration, files, full_passes)
       refuse_unaffordable_coverage_build(store, files)
       return [] if abandon_for_budget?(subjects)
 
-      map = store.fetch(files)
+      map, map_seconds = timed_map_fetch(store, files)
       inform_about_run(subjects, map)
       cache = result_cache(map, files)
       scheduler = scheduler_for(map, integration, cache)
@@ -246,13 +247,41 @@ module Saboteur
       # mutant when serial. Pack the heap now that the map and candidates
       # are retained, to reduce later copying of shared pages.
       Execution::ForkReadiness.prepare_heap
-      results = run_and_confirm(runnable_subjects, runnable_lists, scheduler, cache, ignore_list)
+      results = run_and_confirm_timed(runnable_subjects, runnable_lists, scheduler, cache, ignore_list,
+                                      map_cached: map_reusable, map_seconds:)
       cache&.save
       results
     rescue BudgetPhaseTimeout => e
       budget_phase_stop(e, subjects)
     end
 
+    # The map phase's monotonic split, for the speed footer.
+    def timed_map_fetch(store, files)
+      started = monotonic
+      [store.fetch(files), monotonic - started]
+    end
+
+    # Baseline phase: announce, then verify the unchanged tree passes.
+    def baseline_preflight(store, integration, files, full_passes)
+      warn_unscoped(integration, full_passes)
+      announce_quiet_start(store, files)
+      check_baseline(integration, full_passes)
+    end
+
+    # The mutant phase plus the run's three disjoint timing intervals
+    # (baseline inside check_baseline, map build, mutants) and the worker
+    # count, recorded for the terminal's speed footer.
+    def run_and_confirm_timed(subjects, lists, scheduler, cache, ignore_list, map_cached:, map_seconds:)
+      started = monotonic
+      results = run_and_confirm(subjects, lists, scheduler, cache, ignore_list)
+      # @baseline_elapsed is a Float from initialize on, so no fallback is needed.
+      @phase_timings = PhaseTimings.new(baseline_seconds: @baseline_elapsed,
+                                        map_seconds:, map_cached:,
+                                        mutants_seconds: monotonic - started,
+                                        jobs: config["jobs"])
+      results
+    end
+
     # The candidate run plus the opt-in post-run confirmation pass (#1063):
     # confirmation runs after the last result, before the verdict cache is
     # written, so a confirmed kill overwrites the survivor verdict the run

data/lib/saboteur/help.rb

@@ -140,15 +140,15 @@ module Saboteur
         name: "survivors",
         summary: "Browse a report's survivors in the terminal, read-only",
         description: "Reads the Stryker JSON report without booting the project or rerunning tests. " \
-                     "Lists every survivor with rank, file, line, operator, digest and triage label; " \
-                     "filters with --file, --operator and --triage; --ranked uses the report's ranked " \
-                     "findings order. --show DIGEST prints the diff, the exact replay command and an " \
-                     "ignore-file entry template for that mutant. It never edits the ignore file.",
+                     "Lists every survivor with rank, file, line, operator, digest and triage label, " \
+                     "in the report's ranked findings order; filters with --file, --operator and " \
+                     "--triage; --ranked is kept for compatibility. --show DIGEST prints the diff, " \
+                     "the exact replay command and an ignore-file entry template for that mutant. " \
+                     "It never edits the ignore file.",
         takes_options: false,
         exit_codes: { 0 => "Survivors listed or shown (including none).",
                       2 => "Missing, malformed or unreadable report; bad arguments." },
         examples: [["List survivors from the last run", "saboteur survivors .saboteur/report.json"],
-                   ["Review-priority order", "saboteur survivors .saboteur/report.json --ranked"],
                    ["Diff, replay command and ignore template for one mutant",
                     "saboteur survivors .saboteur/report.json --show 1a2b3c4d5e6f7a8b"]]
       ),

data/lib/saboteur/reporter/default_findings.rb

@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "mutation_text"
+require_relative "survivor_classification"
+require_relative "survivor_list"
+
+module Saboteur
+  module Reporter
+    # Default whole-project findings (D1): the one-line-per-finding list the
+    # --quiet report popularised, then full blocks for the top
+    # SurvivorRanking picks only, then a dim closer naming the rest. A
+    # --since run or --details keeps the full block list.
+    class DefaultFindings
+      # Blocks a default run expands; the closer counts what is left out.
+      TOP_BLOCKS = 3
+
+      # Two lines: the fixed text alone is 87 columns at rest; keep it inside 80.
+      CLOSER = "... %<more>d more %<findings>s - saboteur survivors .saboteur/report.json,\nor re-run with --details"
+
+      def initialize(out, palette, all_mutants: false, details: false,
+                     whole_suite_map: SurvivorList::NO_WHOLE_SUITE_LOOKUP, run_map: nil)
+        @out = out
+        @palette = palette
+        @all_mutants = all_mutants
+        @details = details
+        @whole_suite_map = whole_suite_map
+        @run_map = run_map
+      end
+
+      def call(report, ranked)
+        live = ranked.select(&:unignored_survivor?)
+        return full(report, ranked) if @details || report.diff? || live.empty?
+
+        @out.puts(list_lines(report, live))
+        @out.puts
+        SurvivorList.new(@out, @palette, all_mutants: @all_mutants, limit: TOP_BLOCKS,
+                                         whole_suite_map: @whole_suite_map, run_map: @run_map).call(report, ranked)
+        more = finding_count(report, live) - TOP_BLOCKS
+        findings = "finding#{'s' unless more == 1}"
+        @out.puts @palette.paint(:dim, format(CLOSER, more:, findings:)) if more.positive?
+        @out.puts
+      end
+
+      private
+
+      # --details and --since runs: every finding expanded, exactly the
+      # pre-D1 default.
+      def full(report, ranked)
+        SurvivorList.new(@out, @palette, all_mutants: @all_mutants,
+                                         whole_suite_map: @whole_suite_map, run_map: @run_map).call(report, ranked)
+        @out.puts unless report.survivors.empty?
+      end
+
+      # The quiet list's line shape: path:line subject, label and digest,
+      # sibling mutants on the statement collapsed to a count (#1126/#1133).
+      def list_lines(report, live)
+        groups(report, live).map do |(path, line, subject_id), results|
+          first, *rest = results
+          label = SurvivorClassification.label(first)
+          text = "#{path}:#{line} #{subject_id}#{" [#{label}]" if label} - #{first.digest}"
+          rest.any? ? "#{text} (+#{rest.size} more)" : text
+        end
+      end
+
+      # --all-mutants gives every survivor its own block, so the closer
+      # counts mutants rather than statements.
+      def finding_count(report, live)
+        @all_mutants ? live.size : groups(report, live).size
+      end
+
+      def groups(report, live)
+        live.group_by do |result|
+          [relative(result.subject.file, report.root), MutationText.line(result), result.subject.id]
+        end
+      end
+
+      def relative(file, root)
+        file.delete_prefix("#{root}/")
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/findings.rb

@@ -12,6 +12,8 @@ module Saboteur
     # Survivors accepted on the ignore list are listed apart, with their
     # reason. The full, unbounded mutant data stays in the report's files
     # section; survivorsTruncated says how many more findings live only there.
+    # The uncapped ranked digest list lets offline readers (the survivors
+    # command) print the terminal's ordering without recomputing it (#1150).
     module Findings
       VERSION = 1
 
@@ -30,7 +32,8 @@ module Saboteur
             survivors: listed(report, live),
             survivorsTruncated: truncated(live),
             accepted: listed(report, accepted),
-            acceptedTruncated: truncated(accepted)
+            acceptedTruncated: truncated(accepted),
+            order: full_order(report, live, accepted)
           }
         end
 
@@ -44,6 +47,12 @@ module Saboteur
           [results.size - LIMIT, 0].max
         end
 
+        # Every survivor digest in terminal order: live ranked first, then
+        # accepted - uncapped, unlike the findings lists themselves.
+        def full_order(report, live, accepted)
+          (ordered(report, live) + ordered(report, accepted)).map(&:digest)
+        end
+
         def ordered(report, results)
           SurvivorRanking.ordered(report, results)
         end

data/lib/saboteur/reporter/html.rb

@@ -151,6 +151,8 @@ module Saboteur
       # the same contract as the terminal headline.
       def headline(report)
         breakdown = report.score_breakdown
+        return error_dominated_headline(report) if report.majority_errored?
+
         text = "<p><strong>Covered mutation score: #{score_text(report.score)}</strong>"
         if breakdown.tested.positive?
           text << " (#{breakdown.detected}/#{breakdown.tested} #{Wording.detected_word(breakdown)}, tested subjects)"
@@ -195,12 +197,21 @@ module Saboteur
         "#{Text.counted(report.subjects.size, 'subject')}, #{Text.counted(report.results.size, 'mutant')}"
       end
 
+      # An error-dominated run shows no bare score, like the terminal headline
+      # (#557, #1272): the share covers only the few mutants that were scored.
+      def error_dominated_headline(report)
+        breakdown = report.score_breakdown
+        "<p><strong>Covered mutation score: n/a</strong> (#{breakdown.tested} of #{report.executed.size} " \
+          "mutants scored, #{score_text(breakdown.value)} of scored) - most executed mutants errored, " \
+          "so the run tested almost nothing</p>"
+      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>
+          <p><strong>Covered mutation score: #{score_text(report.majority_errored? ? nil : report.score)}</strong>
           (#{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

data/lib/saboteur/reporter/next_steps.rb

@@ -33,6 +33,7 @@ module Saboteur
           @out.puts "    #{SurvivorGuidance::REPLAY_CAVEAT}"
         end
         @out.puts "  #{SurvivorGuidance::IGNORE_INTRO}"
+        @out.puts "    #{SurvivorGuidance::IGNORE_CONFIG}"
         @out.puts "    Saboteur.ignore do |i|"
         @out.puts "      #{SurvivorGuidance.ignore_entry(survivor.digest, survivor.subject.id)}"
         @out.puts "    end"

data/lib/saboteur/reporter/review_comments.rb

@@ -30,7 +30,9 @@ module Saboteur
       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
+      HINTS = GapKinds::KINDS.to_h { |label| [label, GAP_HINT] }
+                             .merge("tool_limit" => TOOL_LIMIT_HINT,
+                                    "input_gap" => "No test reaches this line. Exercise it with a varied input.").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)

data/lib/saboteur/reporter/speed_footer.rb

@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # PR16's speed footer: the run's wall time split by phase, so
+    # "saboteur is slow" gets a number with an owner (Stryker and
+    # cargo-mutants both print phase timings). A diagnostic, not part of
+    # the clean screen: default runs print it only when an overhead phase
+    # (baseline or map - never the mutant phase, which IS the work) ate
+    # more than OVERHEAD_SHARE of the wall past OVERHEAD_FLOOR seconds;
+    # --verbose always prints it.
+    class SpeedFooter
+      OVERHEAD_SHARE = 0.25
+      OVERHEAD_FLOOR = 2.0
+      # A mutant slower than SLOW_MUTANT_FACTOR times the median mutant
+      # past SLOW_MUTANT_FLOOR seconds is an outlier worth naming.
+      SLOW_MUTANT_FACTOR = 5
+      SLOW_MUTANT_FLOOR = 1.0
+
+      def initialize(out, palette, verbose: false)
+        @out = out
+        @palette = palette
+        @verbose = verbose
+      end
+
+      def call(report)
+        timings = report.phase_timings
+        return unless timings
+        return unless @verbose || overhead_exceeded?(timings, report.wall_time)
+
+        @out.puts @palette.paint(:dim, line(timings, report.wall_time))
+        outlier = slowest_outlier(report.results)
+        return unless outlier
+
+        @out.puts @palette.paint(:dim, "  slowest: #{outlier.subject.id} " \
+                                       "(#{outlier.mutation.operator}, #{format('%.1f', outlier.runtime)}s)")
+      end
+
+      private
+
+      def overhead_exceeded?(timings, wall_time)
+        [timings.baseline_seconds, timings.map_seconds].any? do |seconds|
+          seconds > OVERHEAD_FLOOR && seconds > wall_time * OVERHEAD_SHARE
+        end
+      end
+
+      def line(timings, wall_time)
+        map = timings.map_cached ? "0.0s (cached)" : "#{format('%.1f', timings.map_seconds)}s"
+        "speed footer: done in #{format('%.1f', wall_time)}s - " \
+          "baseline #{format('%.1f', timings.baseline_seconds)}s #{middot} map #{map} #{middot} " \
+          "mutants #{format('%.1f', timings.mutants_seconds)}s (jobs=#{timings.jobs})"
+      end
+
+      def slowest_outlier(results)
+        timed = results.select(&:runtime)
+        return if timed.empty?
+
+        slowest = timed.max_by(&:runtime)
+        return unless slowest.runtime > SLOW_MUTANT_FLOOR && slowest.runtime > median(timed) * SLOW_MUTANT_FACTOR
+
+        slowest
+      end
+
+      def median(results)
+        runtimes = results.map(&:runtime).sort
+        middle = runtimes.size / 2
+        runtimes.size.odd? ? runtimes[middle] : (runtimes[middle - 1] + runtimes[middle]) / 2.0
+      end
+
+      def middot = @palette.glyph(:middot)
+    end
+  end
+end

data/lib/saboteur/reporter/survivor_classification.rb

@@ -28,8 +28,12 @@ module Saboteur
     #     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.
+    #     guesses, so they never get a gap kind.
+    #   input_gap    - no real test covered the mutant at all, so the input
+    #     never varied (D6). Coarse mutants stay unlabeled: their planned
+    #     coverage is a method-level guess, not an observation. The
+    #     deterministic version (the runner records the mutated value
+    #     actually differing) is #1064 follow-up.
     #   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
@@ -37,7 +41,7 @@ module Saboteur
     #
     # A survivor with no matching signal stays unlabeled.
     module SurvivorClassification
-      LABELS = %w[likely_equivalent arid tool_limit].concat(GapKinds::KINDS).freeze
+      LABELS = %w[likely_equivalent arid tool_limit input_gap].concat(GapKinds::KINDS).freeze
 
       class << self
         def label(result, arid: MutationSource::Builtin::DEFAULT_ARID)
@@ -46,6 +50,7 @@ module Saboteur
           return "arid" if arid?(result, arid)
           return "tool_limit" if tool_limited?(result)
           return gap_kind(result) if possible_test_gap?(result)
+          return "input_gap" unless result.mutation.coarse
 
           nil
         end

data/lib/saboteur/reporter/survivor_hints.rb

@@ -96,7 +96,8 @@ module Saboteur
       LABEL_REASONS = {
         "likely_equivalent" => "compiles to the same instructions as the original",
         "arid" => "every edited line matches an arid pattern",
-        "tool_limit" => "the tool could not observe this mutant faithfully"
+        "tool_limit" => "the tool could not observe this mutant faithfully",
+        "input_gap" => "no test reached this mutant, so its input never varied"
       }.merge(GapKinds::REASONS).freeze
 
       module_function

data/lib/saboteur/reporter/survivor_list.rb

@@ -34,26 +34,31 @@ module Saboteur
       SIBLING_DIGEST_CAP = 3
 
       def initialize(out, palette, all_mutants: false, classifier: SurvivorClassification,
-                     whole_suite_map: NO_WHOLE_SUITE_LOOKUP, run_map: nil)
+                     whole_suite_map: NO_WHOLE_SUITE_LOOKUP, run_map: nil, limit: nil)
         @out = out
         @palette = palette
         @all_mutants = all_mutants
         @classifier = classifier
         @whole_suite_map = whole_suite_map
         @run_map = run_map
+        @limit = limit
       end
 
       # Survivors in report (ranked) order; accepted ones trail as dim lines.
+      # A limit renders only the first groups as blocks - the caller names
+      # the rest itself - while the header still counts every live survivor.
       def call(report, survivors)
         return if survivors.empty?
 
         live, accepted = survivors.partition(&:unignored_survivor?)
         @out.puts @palette.paint(:head, "Survivors (#{live.size}) - changes your tests did not catch")
         block_list = groups(live)
-        block_list.each_with_index { |group, index| block(report, group, index + 1, block_list.size) }
+        total = block_list.size
+        shown = @limit ? block_list.first(@limit) : block_list
+        shown.each_with_index { |group, index| block(report, group, index + 1, total) }
         accepted_section(report, accepted)
-        hinted = live.select { |result| hint_for(result) }
-        @out.puts "\n#{@palette.paint(:dim, SurvivorHints::CAVEAT)}" if hinted.any?
+        hinted = @limit ? shown.flatten.select { |result| hint_for(result) } : live.select { |result| hint_for(result) }
+        @out.puts "\n#{@palette.paint(:dim, wrap(SurvivorHints::CAVEAT))}" if hinted.any?
       end
 
       private
@@ -73,6 +78,8 @@ module Saboteur
         path = relative(first.subject.file, report.root)
         @out.puts "\n#{@palette.paint(:head, "#{rank}. #{path}:#{line}")} #{first.subject.id} " \
                   "#{@palette.paint(:dim, label_suffix(first, rank, total))}".rstrip
+        reason = SurvivorHints.label_reason(@classifier.label(first))
+        @out.puts "  #{@palette.paint(:dim, reason)}" if reason
         fence(first, line)
         @out.puts "  #{@palette.paint(:dim, "why it matters: #{why(first.mutation.operator)}")}"
         changed_lines(report, path, first)
@@ -81,14 +88,28 @@ module Saboteur
         siblings(report, group)
       end
 
+      # Fixed furniture fits an 80-column log: word-wrap the caveat. The
+      # JSON agent format keeps SurvivorHints::CAVEAT as one line; only the
+      # terminal rendering wraps. Interpolated lines are exempt.
+      def wrap(text, width = 80)
+        text.split.each_with_object([+""]) do |word, lines|
+          if !lines.last.empty? && lines.last.length + word.length + 1 > width
+            lines << +word
+          else
+            lines.last << (lines.last.empty? ? word : " #{word}")
+          end
+        end.join("\n")
+      end
+
       # The count names blocks, the unit the leading ordinal uses: grouped
       # siblings read "#3 of 14 blocks", never blocks against mutants (#1147).
+      # Label and rank stay on the header line; the reason moves to its own
+      # dim line so the fixed text cannot push the header past 80 columns.
       def label_suffix(result, rank, total)
         label = @classifier.label(result)
         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}]"
+        "[#{parts.join(' · ')}]"
       end
 
       # The enclosing def with the changed line as a -/+ pair; longer

data/lib/saboteur/reporter/terminal.rb

@@ -10,6 +10,8 @@ require_relative "survivor_ranking"
 require_relative "palette"
 require_relative "notice"
 require_relative "score_table"
+require_relative "speed_footer"
+require_relative "default_findings"
 require_relative "survivor_list"
 require_relative "survivor_classification"
 require_relative "test_matrix"
@@ -26,12 +28,13 @@ module Saboteur
       MAX_PASSING_TESTS = 5
 
       def initialize(out, verbose: false, quiet: false, color: :auto, overrides: nil,
-                     replay_command: nil, all_mutants: false, exit_code: nil,
+                     replay_command: nil, all_mutants: false, details: false, exit_code: nil,
                      threshold: nil, previous_score: nil, baseline_gate: 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
+        @details = details
         @verbose = verbose
         @quiet = quiet
         # Clean-screen context: scope from the CLI; PR4a plumbs the phase stats.
@@ -58,7 +61,7 @@ module Saboteur
       def call(report)
         return quiet_call(report) if @quiet
 
-        survivors(report)
+        findings(report)
         errors(report)
         skipped_subjects(report) if @verbose
         test_command_gaps(report)
@@ -69,6 +72,7 @@ module Saboteur
         test_matrix(report)
         operator_policy(report)
         summary(report)
+        SpeedFooter.new(@out, @palette, verbose: @verbose).call(report)
       end
 
       private
@@ -161,6 +165,7 @@ module Saboteur
         @out.puts @palette.paint(:dim, tally)
         @out.puts report.shard.line if report.shard
         score_headline(report)
+        no_coverage_note(report)
         details(report)
         @score_table.call(report)
         not_scored(report)
@@ -210,9 +215,7 @@ module Saboteur
         @out.puts "#{dots}  #{suffix}"
       end
 
-      def win_tally(report)
-        "#{report.counts[:killed]}/#{report.executed.size} mutants killed"
-      end
+      def win_tally(report) = "#{report.counts[:killed]}/#{report.executed.size} mutants killed"
 
       def hazard_suppressions(report)
         return unless report.hazard_suppressions.positive?
@@ -254,6 +257,20 @@ module Saboteur
         @out.puts line
       end
 
+      # NoCoverage mutants ride in the mutant count but outside the score
+      # (#1190): say how many sit on lines no test runs, and how to list
+      # them. Stryker.status maps this skip-reason prefix to NoCoverage.
+      def no_coverage_note(report)
+        count = report.results.count do |result|
+          result.status == :skipped && result.reason&.start_with?("no coverage")
+        end
+        return if count.zero?
+
+        counted = Text.counted(count, "mutant")
+        note = "#{counted} on lines no test runs (not in the score): the JSON report lists them as NoCoverage"
+        @out.puts "  #{@palette.paint(:dim, note)}"
+      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)
@@ -315,7 +332,8 @@ module Saboteur
         parts = state_parts(report)
         parts << "no mutants" if parts.empty?
         line = "saboteur: #{parts.join(', ')} in #{duration(report.wall_time)}"
-        line += " - score #{painted_score(report.score)}"
+        # The headline withholds the score on an error-dominated run (#557); so does this line (#1271).
+        line += " - score #{painted_score(report.majority_errored? ? nil : report.score)}"
         line += " (threshold #{format('%g', @threshold)})" if @threshold
         @out.puts line
       end
@@ -592,11 +610,12 @@ module Saboteur
         @out.puts "  ... #{errored.size - MAX_ERRORS} more" if errored.size > MAX_ERRORS
       end
 
-      def 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?
+      # Default whole-project runs keep the first screen short (D1): the
+      # findings list plus the top blocks; --details or --since expands all.
+      def findings(report)
+        DefaultFindings.new(@out, @palette, all_mutants: @all_mutants, details: @details,
+                                            whole_suite_map: @whole_suite_map,
+                                            run_map: @run_map).call(report, ranked_survivors(report))
       end
 
       # Live survivors precede accepted ones; each group follows SurvivorRanking.

data/lib/saboteur/result.rb

@@ -162,6 +162,18 @@ module Saboteur
     end
   end
 
+  # Per-phase wall time of one run: baseline check, coverage map build,
+  # mutant execution, and the worker count (PR16). Recorded from monotonic
+  # clocks at the phase boundaries; a reused map reports 0.0 s (cached), so
+  # the three phases never double count the cached build and their sum stays
+  # inside the wall time.
+  PhaseTimings = Data.define(:baseline_seconds, :map_seconds, :map_cached, :mutants_seconds, :jobs) do
+    def initialize(baseline_seconds:, map_seconds:, map_cached:, mutants_seconds:, jobs:)
+      super(baseline_seconds:, map_seconds: map_cached ? 0.0 : map_seconds, map_cached:,
+            mutants_seconds:, jobs:)
+    end
+  end
+
   # Everything one run produced.
   class Report
     # More than half of the executed mutants errored: the run tested
@@ -171,7 +183,8 @@ module Saboteur
     attr_reader :results, :subjects, :wall_time, :invalid_mutations, :warnings, :live_announced, :root, :seed,
                 :skipped_subjects, :since,
                 :generation_events, :omissions, :run_evidence, :hazard_suppressions, :early_stop, :inline_suppressions,
-                :operator_policy, :discovery_failures, :memory, :shard, :test_command, :referenced, :reuse_label
+                :operator_policy, :discovery_failures, :memory, :shard, :test_command, :referenced, :reuse_label,
+                :phase_timings
 
     # REVIEW: diff mode; the terminal then shows one survivor per line.
     # seed: the random seed every test run started from (nil when unknown).
@@ -180,7 +193,7 @@ module Saboteur
                    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: [], memory: nil, shard: nil,
-                   test_command: nil, referenced: {}, reuse_label: nil, since: nil)
+                   test_command: nil, referenced: {}, reuse_label: nil, since: nil, phase_timings: nil)
       @results = results
       @subjects = subjects
       @wall_time = wall_time
@@ -213,6 +226,9 @@ module Saboteur
       # or require instead of by name (zero-setup selection).
       @referenced = referenced
       @reuse_label = reuse_label
+      # nil for pipelines without the three phases (--test-command runs):
+      # the terminal prints no speed footer without a full split.
+      @phase_timings = phase_timings
     end
 
     # A --matrix run: every covering test ran per mutant.

data/lib/saboteur/survivor_guidance.rb

@@ -8,8 +8,8 @@ module Saboteur
   # surfaces never drift (#1167).
   module SurvivorGuidance
     REPLAY_CAVEAT = "(add this run's own --config, --since, --subject, --test and source options)"
-    IGNORE_INTRO = "accept an equivalent one: add to your ignore file " \
-                   "(c.ignore_file, default #{Config::IGNORE_FILE}):".freeze
+    IGNORE_INTRO = "accept an equivalent one: add to your ignore file"
+    IGNORE_CONFIG = "(c.ignore_file, default #{Config::IGNORE_FILE}):".freeze
     REASON_PLACEHOLDER = "why it is equivalent"
 
     module_function

data/lib/saboteur/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Saboteur
-  VERSION = "0.11.2"
+  VERSION = "0.12.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: saboteur
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.12.1
 platform: ruby
 authors:
 - Vamsi Pavan Mahesh Gunturu
@@ -225,6 +225,7 @@ files:
 - lib/saboteur/reporter/assets/mutation_report.LICENSE
 - lib/saboteur/reporter/assets/mutation_report.js
 - lib/saboteur/reporter/baseline_tail.rb
+- lib/saboteur/reporter/default_findings.rb
 - lib/saboteur/reporter/diff.rb
 - lib/saboteur/reporter/findings.rb
 - lib/saboteur/reporter/gap_kinds.rb
@@ -244,6 +245,7 @@ files:
 - lib/saboteur/reporter/safe_out.rb
 - lib/saboteur/reporter/score_history.rb
 - lib/saboteur/reporter/score_table.rb
+- lib/saboteur/reporter/speed_footer.rb
 - lib/saboteur/reporter/stryker.rb
 - lib/saboteur/reporter/survivor_classification.rb
 - lib/saboteur/reporter/survivor_hints.rb