saboteur 0.11.2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45635354d2b8067e2de9a11025677af615e3eb54da14dfcd26f0afbdcdd00073
-  data.tar.gz: 40a395d6909fb4bcec99596c6b34e4b40edf1b72c76b349ab25cb3ae44b48726
+  metadata.gz: 7e61c3755190680c12faf62b3a0bcad5f74750da7ff3e3716736e8b9aa733c46
+  data.tar.gz: 85dc6bbddcc174034da44607b55c5c438c883bc5e0c5954a68d8115abb4b5984
 SHA512:
-  metadata.gz: 3f3dd155c87c3c6a45d1fd66a66cc5ec21d8c56dd5113dab2568cd07cc957ee2ba34bfc1b773cf4610aeee822e354bf36cc747418bcee24902365563f5f2b5c2
-  data.tar.gz: 23f785f27b3396a38195f44d6a418d819d6c7359fe34a8ec9f8422855206b53a5ebd634eb70d8c8d40cf622787a9795d99395950932a5870a2418d8651520aa9
+  metadata.gz: eceece31e29ceb03758b67aaa4ecfddcf1f6ca1f864358706fabcb8c9fed1f725da5548cd4f810684ac85250651f234b182452dd0525309711b616b997bf8026
+  data.tar.gz: f62d86ac983b24a550ba5696372fee7f9883be0103e823997f5fdd64c7150b42a8d88aae38881cd65ecd3b2141b39c22c9b7513552506a6499dddceb30128a69

data/CHANGELOG.md

@@ -6,6 +6,35 @@ All notable changes are documented here. The format follows
 
 ## [Unreleased]
 
+## [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/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,

data/lib/saboteur/cli/survivors_command.rb

@@ -89,6 +89,7 @@ module Saboteur
           "  #{SurvivorGuidance::REPLAY_CAVEAT}",
           "",
           SurvivorGuidance::IGNORE_INTRO,
+          "  #{SurvivorGuidance::IGNORE_CONFIG}",
           "  #{ignore_entry(survivor, subject)}"
         ].join("\n")
       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

@@ -77,9 +77,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
 

data/lib/saboteur/engine.rb

@@ -199,7 +199,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 +227,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 +246,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/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/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)
@@ -592,11 +609,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.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: saboteur
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.12.0
 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