saboteur 0.6.0 → 0.7.0

data/lib/saboteur/engine/scheduler.rb

@@ -27,8 +27,9 @@ module Saboteur
         tests.sort_by.with_index { |id, index| [-killers.fetch(id, 0), index] }
       end
 
-      def initialize(config:, runner:, map:, reevaluator:, diagnostics:, cache: nil)
+      def initialize(config:, runner:, map:, reevaluator:, diagnostics:, cache: nil, deadline: nil)
         @config = config
+        @deadline = deadline
         @runner = runner
         @map = map
         @reevaluator = reevaluator
@@ -73,23 +74,53 @@ module Saboteur
 
       # Verdicts that did not hold up are warned about once per subject;
       # only checked verdicts are stored for --incremental.
+      # A spent budget admits no check: forking the unchanged run with no
+      # time left would turn genuine kills into fabricated errors and cache
+      # them. Fresh kills stand unverified instead - outside the score,
+      # never cached - and the distribution marks the subject so the run
+      # reports budget-partial.
       def checked(plan, results)
+        return results.map { |result| unverifiable(result) } if budget_spent?
+
         subject = plan.subject
-        run_unchanged = lambda do |tests, timeout|
-          @runner.run(subject: subject, text: subject.source, test_ids: tests, timeout: timeout,
-                      eval_prefix: eval_prefix(plan))
-                 .tap { |outcome| note_leftovers(subject, "verdict check", outcome) }
-        end
-        check = VerdictCheck.new(run_unchanged: run_unchanged, baseline_timeout: @config["baseline_timeout"])
+        check = VerdictCheck.new(run_unchanged: unchanged_runner(subject, plan),
+                                 baseline_timeout: @config["baseline_timeout"])
         final = check.call(results)
-        final.reject(&:reused?).each { |result| @cache&.record(result) }
-        overturned = final.zip(results).count { |after, before| !after.equal?(before) }
+        # Unverified verdicts are never cached: a budget-cut check proves
+        # nothing, and a stored copy would read as confirmed next run.
+        final.reject { |result| result.reused? || result.status == :unverified }.each { |r| @cache&.record(r) }
+        overturned = final.zip(results).count { |after, before| after.status == :error && !after.equal?(before) }
         if overturned.positive?
           @diagnostics.warn("#{subject.id}: #{overturned} verdict(s) failed with the method unchanged")
         end
         final
       end
 
+      # Admission is per sequence, not just at checked() entry: a check
+      # admitted with time left can hit its capped timeout mid-check, and a
+      # later sequence can arrive after the budget is spent. Neither may
+      # fork with no time left, and neither outcome is a rejected kill -
+      # the check never got its answer (#296).
+      def unchanged_runner(subject, plan)
+        lambda do |tests, timeout|
+          if budget_spent?
+            Execution::Runner::Outcome.new(status: :unverified, runtime: 0.0,
+                                           message: "the --max-duration budget is spent")
+          else
+            capped = budget_capped(timeout)
+            outcome = @runner.run(subject: subject, text: subject.source, test_ids: tests, timeout: capped,
+                                  eval_prefix: eval_prefix(plan))
+            note_leftovers(subject, "verdict check", outcome)
+            if outcome.status == :timeout && capped < timeout
+              Execution::Runner::Outcome.new(status: :unverified, runtime: outcome.runtime,
+                                             message: "the --max-duration budget cut the verdict check short")
+            else
+              outcome
+            end
+          end
+        end
+      end
+
       # When every verdict can be reused, nothing forks: not even the neutral
       # check. Returns the results, or nil at the first one that must run.
       def all_reused(plan, candidates)
@@ -100,10 +131,16 @@ module Saboteur
         end
       end
 
+      # The budget deadline is checked between mutants, so a spent
+      # --max-duration stops inside a long subject too; completed results
+      # are kept and the distribution marks what follows as unreached.
       def run_candidates(candidates, &run_one)
         coarse, fine = candidates.partition { |mutation, _| mutation.coarse }
-        results = coarse.map { |mutation, text| run_one.call(mutation, text) }
-        results + fine.map { |mutation, text| run_one.call(mutation, text) }
+        (coarse + fine).each_with_object([]) do |(mutation, text), results|
+          break results if @deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= @deadline
+
+          results << run_one.call(mutation, text)
+        end
       end
 
       # A stored verdict that still holds, as a result; nil when it must run.
@@ -206,19 +243,78 @@ module Saboteur
       # baseline_timeout. If the deadline from that real runtime is longer,
       # the mutant runs again with it, and later mutants of the subject get
       # the measured slowdown. A timeout that remains is the mutant's own.
+      # A --max-duration deadline caps every admission the scheduler makes:
+      # verdict checks and timeout calibrations get only the time left.
+      def budget_capped(timeout)
+        return timeout unless @deadline
+
+        remaining = @deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        remaining.clamp(0.0, timeout)
+      end
+
+      def budget_spent?
+        @deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= @deadline
+      end
+
+      # A fresh kill whose check the budget skipped proves nothing yet: it
+      # becomes unverified, outside the score, and is never cached.
+      def unverifiable(result)
+        return result if result.reused? || result.status != :killed
+
+        result.as_unverified("verdict check skipped: the --max-duration budget is spent")
+      end
+
+      # A timeout the budget keeps the calibration from judging proves
+      # nothing either: no zero-time forks, and a retry cut short does not
+      # count as detected.
       def calibrate(plan, mutation, text, tests, timeout)
-        unchanged = @runner.run(subject: plan.subject, text: plan.subject.source, test_ids: tests,
-                                timeout: @config["baseline_timeout"], eval_prefix: eval_prefix(plan))
-        note_leftovers(plan.subject, "timeout check", unchanged)
+        if budget_spent?
+          return unverified_outcome(timeout, "timeout calibration skipped: the --max-duration budget is spent")
+        end
+
+        unchanged, shortened = unchanged_timing(plan, tests)
+        if unchanged.status == :timeout && shortened
+          return unverified_outcome(unchanged.runtime, "the --max-duration budget cut the timeout calibration short")
+        end
         return unchanged_failed(unchanged) unless unchanged.status == :survived
 
+        retry_longer(plan, mutation, text, tests, [timeout, unchanged.runtime])
+      end
+
+      # The unchanged method under the budget-capped baseline timeout, and
+      # whether the cap shortened it.
+      def unchanged_timing(plan, tests)
+        capped = budget_capped(@config["baseline_timeout"])
+        outcome = @runner.run(subject: plan.subject, text: plan.subject.source, test_ids: tests,
+                              timeout: capped, eval_prefix: eval_prefix(plan))
+        note_leftovers(plan.subject, "timeout check", outcome)
+        [outcome, capped < @config["baseline_timeout"]]
+      end
+
+      def retry_longer(plan, mutation, text, tests, limit)
+        timeout, unchanged_runtime = limit
         recorded = @map.recorded_runtime(tests)
-        plan.slowdown = [plan.slowdown, unchanged.runtime / recorded].max if recorded&.positive?
-        longer = deadline(unchanged.runtime)
+        plan.slowdown = [plan.slowdown, unchanged_runtime / recorded].max if recorded&.positive?
+        longer = deadline(unchanged_runtime)
         return Execution::Runner::Outcome.new(status: :timeout, runtime: timeout) if longer <= timeout
+        # The unchanged timing may have used the final allowance: no
+        # zero-time retry fork (#296).
+        if budget_spent?
+          return unverified_outcome(timeout, "the --max-duration budget is spent before the mutant retry")
+        end
+
+        retry_timeout = budget_capped(longer)
+        retried = @runner.run(subject: plan.subject, text: text, test_ids: tests, timeout: retry_timeout,
+                              mutation: mutation, eval_prefix: eval_prefix(plan))
+        return retried unless retried.status == :timeout && retry_timeout < longer
+
+        unverified_outcome(retried.runtime, "the --max-duration budget cut the mutant retry short")
+      end
 
-        @runner.run(subject: plan.subject, text: text, test_ids: tests, timeout: longer, mutation: mutation,
-                    eval_prefix: eval_prefix(plan))
+      # A budget-cut calibration proves nothing about the mutant: outside
+      # the score, and never cached.
+      def unverified_outcome(runtime, message)
+        Execution::Runner::Outcome.new(status: :unverified, runtime: runtime, message: message)
       end
 
       def unchanged_failed(unchanged)

data/lib/saboteur/engine/subject_selection.rb

@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require_relative "../text"
+
 module Saboteur
   class Engine
     # The subjects to mutate: every def in the included files, narrowed by
@@ -13,11 +15,12 @@ module Saboteur
         @config = config
         @diagnostics = diagnostics
         @root = File.realpath(config.root)
-        @changed_lines = nil
       end
 
       def select(files)
+        @files = files
         subjects = find(files)
+        @discovered = subjects
         subjects = by_pattern(subjects, @config["subjects"]) if @config["subjects"].any?
         subjects = by_change(subjects, @config["since"]) if @config["since"]
         subjects
@@ -28,6 +31,22 @@ module Saboteur
         id == pattern || %w[# . ::].any? { |separator| id.start_with?("#{pattern}#{separator}") }
       end
 
+      # The files (absolute paths) holding a subject matching any pattern,
+      # returned relative to root. --subject inference guesses specs for
+      # exactly these, so one unrelated spec-less file cannot block a
+      # one-method run.
+      def self.files_matching(root, files, patterns)
+        finder = SubjectFinder.new
+        prefix = "#{root}/"
+        files.filter_map do |file|
+          parsed = finder.call(file)
+          matching = parsed.subjects.any? do |subject|
+            patterns.any? { |pattern| match?(subject.id, pattern) }
+          end
+          file.delete_prefix(prefix) if matching
+        end.sort
+      end
+
       private
 
       def find(files)
@@ -54,14 +73,74 @@ module Saboteur
       end
 
       def by_change(subjects, ref)
-        @changed_lines = Selection::GitDiff.changed_lines(ref, root: @root)
+        @changed_lines = Selection::GitDiff.changed_lines(ref, root: @root, include: @files.to_set,
+                                                               diagnostics: @diagnostics)
                                            .transform_keys { |file| Selection::CoverageMap.canonical(file) }
-        changed = subjects.select do |subject|
-          @changed_lines[subject.file]&.any? { |line| subject.contains_line?(line) }
-        end
+        changed = changed_subjects(subjects)
+        warn_changed_files_without_subjects
+        warn_excluded_changed_files
         drop_unchanged_syntax(changed, ref)
       end
 
+      # subject.file carries the locale tag under a non-UTF-8 locale
+      # while the diff keys are UTF-8; retag losslessly before lookup so
+      # a non-ASCII path matches by its exact bytes (#231).
+      def changed_subjects(subjects)
+        subjects.select do |subject|
+          key = Selection::CoverageMap.canonical(Text.utf8_identity(subject.file))
+          lines = @changed_lines[key]
+          lines && subject.overlaps_lines?(lines)
+        end
+      end
+
+      # A changed Ruby file in scope whose changed lines cover no subject
+      # silently contributes nothing to the run (#232): warn, or a typo, an
+      # unparseable file or a selection bug passes as a clean selection.
+      # Comment-only changes stay quiet: their file matched subjects before
+      # drop_unchanged_syntax pruned them, and that prune is reported. A
+      # diff touching no included Ruby file is a legitimate empty scope.
+      def warn_changed_files_without_subjects
+        canonical = ->(file) { Selection::CoverageMap.canonical(Text.utf8_identity(file)) }
+        included = @files.map(&canonical)
+        matched = changed_subjects(@discovered).map { |subject| canonical.call(subject.file) }
+        unmatched = (@changed_lines.keys.select { |file| file.end_with?(".rb") } & included) - matched
+        return if unmatched.empty?
+
+        names = unmatched.first(5).map { |file| file.delete_prefix("#{@root}/") }.join(", ")
+        more = unmatched.size > 5 ? ", ..." : ""
+        @diagnostics.warn("--since: #{unmatched.size} changed Ruby file(s) have no subjects covering " \
+                          "the changed lines, so nothing is mutated from them: #{names}#{more}. The " \
+                          "file may not parse, or every change may sit outside a method.")
+      end
+
+      # A changed Ruby file that an include pattern covers but c.exclude
+      # removes yields zero candidates with no other sign - this repo's own
+      # config excludes lib/saboteur/execution/**, so harness changes once
+      # dogfooded as a clean empty scope (#282). Names at most five.
+      def warn_excluded_changed_files
+        untracked = Selection::UntrackedChanges.paths(@root)
+        hits = excluded_territory & (@changed_lines.keys + untracked)
+        return if hits.empty?
+
+        names = hits.sort.first(5).map { |file| file.delete_prefix("#{@root}/") }.join(", ")
+        more = hits.size > 5 ? ", ..." : ""
+        @diagnostics.warn("--since: #{hits.size} changed Ruby file(s) are covered by c.include but removed by " \
+                          "c.exclude, so nothing is mutated from them: #{names}#{more}. Narrow or remove the " \
+                          "c.exclude entry, or pass the file as a positional source operand (configured " \
+                          "excludes are then ignored).")
+      end
+
+      # Ruby files an include pattern and an exclude pattern both match,
+      # canonicalized the way the diff map keys are.
+      def excluded_territory
+        canonical = lambda do |file|
+          Selection::CoverageMap.canonical(File.expand_path(Text.utf8_identity(file), @config.root))
+        end
+        territory = @config["include"].flat_map { |pattern| Dir.glob(pattern, base: @config.root) }
+        excluded = @config["exclude"].flat_map { |pattern| Dir.glob(pattern, base: @config.root) }
+        (territory & excluded).select { |file| file.end_with?(".rb") }.map(&canonical)
+      end
+
       # A method whose only changes are comments, blank lines or spacing has
       # nothing new to test.
       def drop_unchanged_syntax(subjects, ref)

data/lib/saboteur/engine/suite_files.rb

@@ -3,6 +3,7 @@
 
 require "digest"
 require "shellwords"
+require_relative "../text"
 require_relative "data_inputs"
 
 module Saboteur
@@ -56,7 +57,8 @@ module Saboteur
       # `--require name` resolves through RSpec's load path: spec/, lib/ and
       # any -I directory.
       def required_by_options
-        tokens = option_files.flat_map { |file| Shellwords.split(File.read(file)) } + @config["rspec_args"]
+        tokens = option_files.flat_map { |file| Shellwords.split(Text.utf8_identity(File.read(file))) } +
+                 @config["rspec_args"]
         load_path = LOAD_PATH + option_values(tokens, "-I", "--include")
         option_values(tokens, *REQUIRE_FLAGS).filter_map { |name| resolve(name, load_path) }
       end

data/lib/saboteur/engine/test_guess.rb

@@ -1,43 +1,167 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require "pathname"
+
 module Saboteur
   class Engine
-    # --guess-tests: the specs that sit next to the changed source files by
+    # The specs that sit next to the mutated source files by
     # naming convention (lib/a/b.rb -> spec/a/b_spec.rb). A guess, not a
     # coverage fact: a spec that only reaches the file through another one
     # is not found. Packwerk packs (a directory with a package.yml) map to the
     # spec directory inside the same pack, and controllers also map to request
-    # specs. The run scopes to the guesses only when every changed file has one.
+    # specs. With --since, only files whose changed lines carry a mutation
+    # subject need a guessed spec; without --since, every included file with
+    # a mutation subject needs one. A file that needs a spec and has none
+    # stops the run before boot.
     class TestGuess
-      Result = Data.define(:specs, :unmatched, :changed)
+      # hints: unmatched file -> its conventional spec path (which does
+      # not exist; that is why the file is unmatched), for the stop-before-boot
+      # error. The result also builds its own messages, so a stubbed guess in
+      # the engine's specs formats exactly like a real one.
+      Result = Data.define(:specs, :unmatched, :subjectless, :changed, :hints) do
+        # The stop-before-boot usage error: names each expected spec and the
+        # ways out as an append-only instruction - never a reconstructed
+        # command, which could carry a hostile ref or a wrong source scope.
+        def unmatched_message
+          pairs = unmatched.map { |file| "#{file} (expected #{hints.fetch(file)})" }
+          "no spec found for #{pairs.join(', ')}, so nothing ran. Re-run the same command with --test " \
+            "followed by your existing spec paths, or append --all to use the whole suite without " \
+            "changing the source scope."
+        end
+
+        # Why the subjectless files needed no spec.
+        def subjectless_message(since:)
+          detail = since ? "no changed mutation subjects" : "no mutation subjects"
+          "inferred specs: no spec is required for #{subjectless.join(', ')}: they have #{detail}"
+        end
+
+        # The warning for a guess-scoped run: the guessed specs now stand as
+        # explicit tests, with the cross-file coverage caveat that brings.
+        def scope_message(since:)
+          what = since ? "a changed file" : "a source file"
+          "inferred specs: running only #{specs.join(', ')}. A spec that reaches " \
+            "#{what} only through another file does not run, so a mutant only it would kill can " \
+            "survive, and a line no inferred spec executes is reported as NoCoverage"
+        end
+      end
 
       SOURCE_ROOTS = %w[lib app].freeze
 
-      def initialize(config)
+      def initialize(config, diagnostics: nil)
+        @diagnostics = diagnostics
         @root = File.realpath(config.root)
         @config = config
       end
 
-      # specs: existing spec files (relative paths); unmatched: changed
-      # source files with no guessed spec; changed: how many source files
-      # changed.
       def call
-        changed = changed_sources
-        guesses = changed.to_h { |file| [file, guess_for(file)] }
-        Result.new(specs: guesses.values.compact.uniq.sort, unmatched: guesses.select { |_, spec| spec.nil? }.keys,
-                   changed: changed.size)
+        @config["since"] ? call_diff : call_all
+      end
+
+      # Subject-scoped inference (--subject runs): only the named subjects'
+      # files need a guessed spec; every one of them has a subject by
+      # construction, so there is no subjectless bucket. With --since the
+      # diff narrows the scope further: a named subject whose file is
+      # unchanged, whose changed lines sit in other methods, or whose change
+      # is comment or formatting only is out of scope and needs no spec.
+      def call_for(files, patterns = [])
+        files = effective_subject_files(files, patterns) if @config["since"]
+        guesses = files.to_h { |file| [file, guess_for(file)] }
+        result(guesses, [], files.size)
+      end
+
+      # specs: existing spec files (relative paths) guessed for the files in
+      # scope; unmatched: such files with no guessed spec; subjectless: files
+      # with no mutation subject the run checks, which neither need nor get a
+      # spec; changed: how many source files are in scope; hints: each
+      # unmatched file's conventional spec path.
+      def call_diff
+        lines_by_file = changed_lines_by_file
+        subjectless = subjectless_files(lines_by_file)
+        # Only files with a changed mutation subject get a guessed spec: a
+        # subjectless file mutates nothing, so its spec would only narrow the
+        # run for no reason.
+        guesses = lines_by_file.except(*subjectless).to_h { |file| [file, guess_for(file)] }
+        result(guesses, subjectless, lines_by_file.size)
+      end
+
+      # Without --since every included file is in scope: a file needs its
+      # guessed spec unless it holds no mutation subject at all.
+      def call_all
+        finder = SubjectFinder.new
+        guesses = {}
+        subjectless = []
+        included_files.each do |file|
+          if finder.call(File.join(@root, file)).subjects.empty?
+            subjectless << file
+          else
+            guesses[file] = guess_for(file)
+          end
+        end
+        result(guesses, subjectless.sort, guesses.size + subjectless.size)
       end
 
       private
 
-      # Changed files that saboteur would mutate, relative to the root.
-      def changed_sources
+      # The named subjects' files inside the diff scope: the subject must
+      # sit on a changed line and survive the comment/formatting prune,
+      # mirroring the run's subject selection.
+      def effective_subject_files(files, patterns)
+        lines_by_file = changed_lines_by_file
+        comparison = UnchangedSyntax.new(Selection::GitDiff.merge_base(@config["since"], root: @root), root: @root)
+        finder = SubjectFinder.new
+        files.select do |file|
+          lines = lines_by_file[file]
+          next false unless lines
+
+          finder.call(File.join(@root, file)).subjects.any? do |subject|
+            patterns.any? { |pattern| SubjectSelection.match?(subject.id, pattern) } &&
+              subject.overlaps_lines?(lines) &&
+              !comparison.unchanged?(subject)
+          end
+        end
+      end
+
+      def result(guesses, subjectless, changed)
+        unmatched = guesses.select { |_, spec| spec.nil? }.keys
+        Result.new(specs: guesses.values.compact.uniq.sort,
+                   unmatched: unmatched,
+                   subjectless: subjectless,
+                   changed: changed,
+                   hints: unmatched.to_h { |file| [file, candidates_for(file).first] })
+      end
+
+      # Included files relative to the root, sorted for stable output.
+      def included_files
+        prefix = "#{@root}/"
+        @config.included_files.filter_map { |file| file.delete_prefix(prefix) if file.start_with?(prefix) }.sort
+      end
+
+      # Changed files that saboteur would mutate, relative to the root, with
+      # their changed line numbers.
+      def changed_lines_by_file
         included = @config.included_files.to_set
-        changed = Selection::GitDiff.changed_lines(@config["since"], root: @root).keys
-        changed.map { |file| Selection::CoverageMap.canonical(file) }
-               .select { |file| included.include?(file) }
-               .map { |file| file.delete_prefix("#{@root}/") }.sort
+        Selection::GitDiff.changed_lines(@config["since"], root: @root, include: included,
+                                                           diagnostics: @diagnostics)
+                          .each_with_object({}) do |(file, lines), map|
+          canonical = Selection::CoverageMap.canonical(file)
+          map[canonical.delete_prefix("#{@root}/")] = lines if included.include?(canonical)
+        end.sort.to_h
+      end
+
+      # Changed files whose changed lines carry no mutation subject: the run
+      # mutates nothing in them, so they cannot require a spec. Mirrors the
+      # run's subject selection, including its comment/formatting-only skip:
+      # a deletion whose remaining context lines are blank or comments, or a
+      # comment-only change inside a method, leaves the file subjectless.
+      def subjectless_files(lines_by_file)
+        comparison = UnchangedSyntax.new(Selection::GitDiff.merge_base(@config["since"], root: @root), root: @root)
+        finder = SubjectFinder.new
+        lines_by_file.reject do |file, lines|
+          subjects = finder.call(File.join(@root, file)).subjects
+          subjects.select { |subject| subject.overlaps_lines?(lines) }
+                  .any? { |subject| !comparison.unchanged?(subject) }
+        end.keys
       end
 
       def guess_for(file)
@@ -71,14 +195,13 @@ module Saboteur
 
       # The nearest ancestor directory holding a package.yml (a packwerk
       # pack), relative to the root. The root itself is not a pack here:
-      # its specs follow the plain mapping.
+      # Pathname#ascend stops above "." for these relative paths.
       def pack_of(file)
-        dir = File.dirname(file)
-        until dir == "."
+        Pathname(file).ascend do |path|
+          dir = path.to_s
           return dir if pack_dirs.include?(dir)
-
-          dir = File.dirname(dir)
         end
+        nil
       end
 
       def pack_dirs

data/lib/saboteur/engine/thread_warnings.rb

@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  class Engine
+    # Threads do not survive fork, so a run names the ones alive when the
+    # workers fork: by the name the owner gave the thread, else the first
+    # frame of its backtrace, so the user can tell whether they matter (a
+    # connection pool reaper, Sidekiq, an SDK's background flusher).
+    # Known-harmless threads say so inline; an unknown thread gets the
+    # generic caveat (#263).
+    module ThreadWarnings
+      # Well-known fork-time threads, with the condition each assurance
+      # hangs on. Evidence: rails-mode children reconnect the database
+      # (lib/saboteur/frameworks/rails.rb, after_fork); whether the debug
+      # gem's console also attaches to forked children depends on its
+      # fork_mode, whose default is :both, i.e. attach (RUBY_DEBUG_FORK_MODE;
+      # ruby/debug's config.rb and SESSION.activate on_fork: true in
+      # session.rb).
+      KNOWN_FORK_THREADS = {
+        "AR Pool Reaper" => "ActiveRecord's connection-pool reaper: expected harmless when children " \
+                            "reconnect the database after fork (rails mode does) - it only maintains " \
+                            "the parent's pool",
+        "DEBUGGER__::SESSION@server" => "the debug gem's remote-console server: what it does in " \
+                                        "children depends on RUBY_DEBUG_FORK_MODE - with parent no " \
+                                        "debugger runs in children; with child or both (the gem's " \
+                                        "default) the debugger activates in children and can pause or " \
+                                        "interfere with supervised mutation runs. For an unattended " \
+                                        "run, do not start the remote debugger at all: drop " \
+                                        "RUBY_DEBUG_OPEN or require \"debug\" without :open"
+      }.freeze
+
+      def self.warn(diagnostics)
+        others = Thread.list - [Thread.current]
+        return if others.empty?
+
+        unknown = false
+        list = others.map do |thread|
+          name = thread.name || thread.backtrace&.first || "unknown"
+          explanation = KNOWN_FORK_THREADS[name]
+          unknown = true unless explanation
+          explanation ? "#{name} (#{explanation})" : name
+        end.join(", ")
+        message = "#{others.size} other thread(s) alive at fork time; they do not run in children: #{list}"
+        if unknown
+          message += "; a thread that does not run in a child cannot do background work a mutant's test may " \
+                     "rely on (a pool reaper, a flusher), so results can differ when one is left behind"
+        end
+        diagnostics.warn(message)
+      end
+    end
+  end
+end

data/lib/saboteur/engine/unscoped_suite_warning.rb

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  class Engine
+    # A whole-suite run (--all, c.test_selection = :all, or a --since diff
+    # with nothing to infer from) runs the loaded suite for the baseline
+    # checks; a cold coverage cache adds one more pass. Say so - with the
+    # example count and the real pass count - before those hours pass; past
+    # a size threshold, add the way to scope it (#260). The check count
+    # comes from c.baseline_passes (#55).
+    module UnscopedSuiteWarning
+      # A suite this size pays hours for an unscoped run; below it the cost
+      # summary alone is enough, without the --test lecture (#260).
+      COSTLY_SUITE_EXAMPLES = 1_000
+      REUSED_MAP_NOTE = "; the cached coverage map is reused"
+
+      def self.call(config:, diagnostics:, integration:, full_passes:)
+        return unless config["tests"].empty?
+        return unless config["since"] || config["all"] || config["test_selection"] == "all"
+
+        examples = integration.all_tests.size
+        coverage = full_passes == config["baseline_passes"] ? REUSED_MAP_NOTE : " + 1 coverage map build"
+        message = "running the loaded suite unscoped: #{examples} examples in #{integration.test_files.size} " \
+                  "spec files; #{full_passes} full passes (#{checks_label(config)}#{coverage})."
+        if examples >= COSTLY_SUITE_EXAMPLES
+          message += " Pass --test to run only the specs you name: faster, but a mutant of a changed method is then " \
+                     "killed only by those specs, so specs elsewhere that call this code are not run. " \
+                     "The default inferred selection runs the specs named after the mutated files, " \
+                     "a guess that can miss specs elsewhere."
+        end
+        diagnostics.warn(message)
+        diagnostics.inform(message)
+      end
+
+      def self.checks_label(config)
+        "#{config['baseline_passes']} baseline check#{'s' unless config['baseline_passes'] == 1}"
+      end
+    end
+  end
+end