saboteur 0.3.0 → 0.5.0

data/lib/saboteur/selection/coverage_map.rb

@@ -16,21 +16,87 @@ module Saboteur
     # to every test in the file of the next test that starts. Each test's
     # duration is recorded so selected tests can run fastest first.
     class CoverageMap
-      FORMAT = 3
+      FORMAT = 8
 
-      attr_reader :lines, :tests, :build_seconds, :durations
+      RAN_AT_LOAD = "ran at load: the code ran while the app loaded; a forked test cannot observe a change here"
+
+      attr_reader :lines, :tests, :build_seconds, :durations, :methods, :load_lines, :branches
 
       # lines: { "/abs/file.rb" => { 12 => ["id1", "id2"] } }
+      # methods: { "/abs/file.rb" => { 12 => ["id1", "id2"] } } keyed by the
+      # def's first line; line coverage never counts an endless def's body,
+      # so methods carry those subjects (issue #107).
       # durations: { "id1" => seconds }
-      def initialize(lines:, tests:, build_seconds: nil, durations: {})
+      def initialize(lines:, tests:, build_seconds: nil, durations: {}, methods: {}, load_lines: {}, branches: {})
         @lines = lines
         @tests = tests
         @build_seconds = build_seconds
         @durations = durations
+        @methods = methods
+        @load_lines = load_lines
+        @branches = branches
       end
 
       def tests_for(subject)
-        tests_for_lines(subject.file, subject.coverage_lines)
+        tests = tests_for_lines(subject.file, subject.coverage_lines)
+        return tests unless tests.empty?
+
+        by_method = methods[CoverageMap.canonical(subject.file)]
+        return [] unless by_method
+
+        span = subject.start_line..subject.end_line
+        ids = by_method.flat_map { |line, method_ids| span.cover?(line) ? method_ids : [] }.uniq
+        sort_test_ids(ids)
+      end
+
+      # Attach the parent's boot counters without losing the child's method coverage.
+      def with_load_lines(load_lines)
+        self.class.new(lines: lines, tests: tests, build_seconds: build_seconds, durations: durations,
+                       methods: methods, load_lines: load_lines, branches: branches)
+      end
+
+      # A requested line ran at load but no test later hit it.
+      def ran_at_load?(file, line_numbers)
+        at_load = load_lines[CoverageMap.canonical(file)]
+        return false unless at_load
+
+        covered = lines[CoverageMap.canonical(file)] || {}
+        line_numbers.any? { |line| at_load.include?(line) && !covered.key?(line) }
+      end
+
+      # Tests for the lines of one edit. A branch no test executes keeps its
+      # "no coverage" skip, but a subject whose lines never record at all
+      # (an endless def) falls back to its method coverage (issue #107).
+      def tests_for_edit(subject, line_numbers)
+        tests = tests_for_lines(subject.file, line_numbers)
+        return tests unless tests.empty?
+        return [] unless tests_for_lines(subject.file, subject.coverage_lines).empty?
+
+        tests_for(subject)
+      end
+
+      # nil means Ruby supplied no arm evidence for this edit (including &&/||).
+      # An empty list means a known arm was never taken. Nested arms intersect.
+      def tests_for_branches(subject, edits)
+        arms = branches.fetch(CoverageMap.canonical(subject.file), {})
+        matching = edits.map do |edit|
+          first = position(subject.file_source, edit.start_byte)
+          last = position(subject.file_source, edit.end_byte)
+          selected = arms.select do |span, ids|
+            (span.first(2) <=> first) <= 0 && (last <=> span.last(2)) <= 0 &&
+              !ran_before_tests?(subject.file, span, ids)
+          end
+          selected.values.reduce { |ids, other| ids & other }
+        end
+        return nil if matching.include?(nil)
+
+        sort_test_ids(matching.flatten.uniq)
+      end
+
+      # True when neither boot nor tests recorded included code. Load-only
+      # evidence is valid, even though it supplies no judged mutation score.
+      def empty?
+        [lines, methods, load_lines].all? { |hits| hits.none? { |_file, values| values.any? } }
       end
 
       # Tests that executed any of the lines, fastest first (suite order breaks
@@ -46,19 +112,19 @@ module Saboteur
         by_line = lines[CoverageMap.canonical(file)]
         return [] unless by_line
 
-        ids = line_numbers.flat_map { |line| by_line.fetch(line, []) }.uniq
-        order = test_order
-        ids.sort_by { |id| [durations.fetch(id, Float::INFINITY), order.fetch(id, Float::INFINITY)] }
+        sort_test_ids(line_numbers.flat_map { |line| by_line.fetch(line, []) }.uniq)
       end
 
       # Lines refer to tests by their index in tests, which keeps the cache
       # small for suites with long test ids.
       def to_json(*)
         index = test_order
-        encoded = lines.transform_values do |by_line|
-          by_line.to_h { |line, ids| [line.to_s, ids.map { |id| index.fetch(id) }] }
+        encode = lambda do |hits|
+          hits.transform_values { |by_line| by_line.to_h { |line, ids| [line.to_s, ids.map { |id| index.fetch(id) }] } }
         end
-        JSON.generate(format: FORMAT, tests: tests, build_seconds: build_seconds, lines: encoded,
+        JSON.generate(format: FORMAT, tests: tests, build_seconds: build_seconds, lines: encode.call(lines),
+                      methods: encode.call(methods), load_lines: load_lines,
+                      branches: encode_branches(index),
                       durations: tests.map { |id| durations[id]&.round(6) })
       end
 
@@ -67,11 +133,22 @@ module Saboteur
         raise Error, "coverage map format #{data['format']} is not #{FORMAT}" unless data["format"] == FORMAT
 
         tests = data["tests"]
-        lines = data["lines"].transform_values do |by_line|
-          by_line.to_h { |line, indexes| [line.to_i, indexes.map { |i| tests.fetch(i) }] }
+        decode = lambda do |hits|
+          hits.transform_values do |by_line|
+            by_line.to_h { |line, indexes| [line.to_i, indexes.map { |i| tests.fetch(i) }] }
+          end
         end
         durations = tests.zip(data["durations"]).to_h.compact
-        new(lines: lines, tests: tests, build_seconds: data["build_seconds"], durations: durations)
+        load_lines = (data["load_lines"] || {}).transform_values { |list| list.map(&:to_i) }
+        new(lines: decode.call(data["lines"]), tests: tests, build_seconds: data["build_seconds"],
+            durations: durations, methods: decode.call(data["methods"] || {}), load_lines: load_lines,
+            branches: decode_branches(data.fetch("branches", {}), tests))
+      end
+
+      def self.decode_branches(branches, tests)
+        branches.transform_values do |arms|
+          arms.to_h { |span, ids| [span, ids.map { |id| tests.fetch(id) }] }
+        end
       end
 
       # Cache key over every input that can change which test runs which line.
@@ -105,6 +182,35 @@ module Saboteur
 
       private
 
+      def encode_branches(index)
+        branches.transform_values do |arms|
+          arms.map { |span, ids| [span, ids.map { |id| index.fetch(id) }] }
+        end
+      end
+
+      # An arm whose body the app ran while loading (a def inside an if) has no
+      # per-test hits, yet tests ran the lines inside it. Only lines strictly
+      # between the arm's first and last line count: the boundary lines can
+      # also hold code outside the arm. An arm with no interior line, such as
+      # a one-line arm, cannot be told apart, so its empty list still means
+      # "not taken".
+      def ran_before_tests?(file, span, ids)
+        return false unless ids.empty?
+
+        covered = lines[CoverageMap.canonical(file)] || {}
+        ((span[0] + 1)...span[2]).any? { |line| covered.key?(line) }
+      end
+
+      def position(source, offset)
+        prefix = source.byteslice(0, offset).b
+        [prefix.count("\n") + 1, offset - ((prefix.rindex("\n") || -1) + 1)]
+      end
+
+      def sort_test_ids(ids)
+        order = test_order
+        ids.sort_by { |id| [durations.fetch(id, Float::INFINITY), order.fetch(id, Float::INFINITY)] }
+      end
+
       def test_order
         @test_order ||= tests.each_with_index.to_h
       end

data/lib/saboteur/selection/git_diff.rb

@@ -13,8 +13,35 @@ module Saboteur
 
       module_function
 
+      # Fails before any boot work when REF is not a commit here, as a usage
+      # error (exit 2): the name is wrong, or a shallow checkout lacks it.
+      def verify_ref!(ref, root:)
+        raise ConfigError, "--since needs a git ref, not an option: #{ref}" if ref.start_with?("-")
+
+        _, _, inside = Open3.capture3("git", "rev-parse", "--git-dir", chdir: root)
+        raise ConfigError, "--since needs a git repository" unless inside.success?
+
+        _, _, found = Open3.capture3("git", "rev-parse", "--verify", "--quiet", "#{ref}^{commit}", chdir: root)
+        return if found.success?
+
+        raise ConfigError, "--since #{ref}: not a commit in this repository " \
+                           "(check the name; a shallow checkout may need a deeper fetch)"
+      end
+
+      def merge_base(ref, root:)
+        git(root, "merge-base", ref, "HEAD").strip
+      end
+
+      # The file's text at commit BASE, or nil when it did not exist there.
+      # path is relative to root.
+      def file_at(base, path, root:)
+        out, _, status = Open3.capture3("git", "show", "#{base}:./#{path}", chdir: root)
+        status.success? ? out.b : nil
+      end
+
       def changed_lines(ref, root:)
-        base = git(root, "merge-base", ref, "HEAD").strip
+        verify_ref!(ref, root: root)
+        base = merge_base(ref, root: root)
         top = git(root, "rev-parse", "--show-toplevel").strip
         parse(git(root, "-c", "core.quotePath=false", "diff", "--unified=0", "--no-color", "--no-ext-diff", base,
                   "--"), top)

data/lib/saboteur/selection/recorder.rb

@@ -12,10 +12,14 @@ module Saboteur
       def initialize(files)
         @files = Set.new(files.map { |file| CoverageMap.canonical(file) })
         @canonical = Hash.new { |hash, path| hash[path] = CoverageMap.canonical(path) }
-        @lines = Hash.new { |hash, file| hash[file] = Hash.new { |by_line, line| by_line[line] = [] } }
+        @lines = hit_table
+        @methods = hit_table
+        @branches = hit_table
+        @outside_branches = per_file { Set.new }
         @tests = []
-        @tests_by_file = Hash.new { |hash, file| hash[file] = [] }
-        @outside = Hash.new { |hash, file| hash[file] = Set.new }
+        @tests_by_file = per_file { [] }
+        @outside = per_file { Set.new }
+        @outside_methods = per_file { Set.new }
         @durations = {}
       end
 
@@ -27,33 +31,64 @@ module Saboteur
       def test_started(id, test_file)
         @tests << id
         @tests_by_file[test_file] << id
-        each_hit_line { |file, line| @outside[test_file] << [file, line] }
+        each_hit do |file, line, kind|
+          { line: @outside, method: @outside_methods, branch: @outside_branches }.fetch(kind)[test_file] << [file, line]
+        end
         @started_at = monotonic
       end
 
       def test_finished(id)
         @durations[id] = monotonic - @started_at if @started_at
-        each_hit_line { |file, line| @lines[file][line] << id }
+        each_hit do |file, line, kind|
+          { line: @lines, method: @methods, branch: @branches }.fetch(kind)[file][line] << id
+        end
       end
 
       def result(build_seconds: nil)
-        @outside.each do |test_file, hits|
-          ids = @tests_by_file[test_file]
-          hits.each { |file, line| @lines[file][line] |= ids }
-        end
+        assign_outside(@outside, @lines)
+        assign_outside(@outside_methods, @methods)
+        assign_outside(@outside_branches, @branches)
         lines = @lines.transform_values { |by_line| by_line.transform_values(&:uniq) }
-        CoverageMap.new(lines: lines, tests: @tests, build_seconds: build_seconds, durations: @durations)
+        methods = @methods.transform_values { |by_line| by_line.transform_values(&:uniq) }
+        CoverageMap.new(lines: lines, tests: @tests, build_seconds: build_seconds, durations: @durations,
+                        methods: methods, branches: @branches.transform_values { |arms| arms.transform_values(&:uniq) })
       end
 
       private
 
+      def assign_outside(outside, table)
+        outside.each do |test_file, hits|
+          ids = @tests_by_file[test_file]
+          hits.each { |file, line| table[file][line] |= ids }
+        end
+      end
+
+      def record_branches(file, data)
+        data.fetch(:branches, {}).each do |(_kind, _id, *parent_span), arms|
+          arms.each do |(_arm_kind, _arm_id, *span), count|
+            next if span == parent_span
+
+            @branches[file][span] # Keep zero-hit arms as evidence, not as covered code.
+            yield span if count.positive?
+          end
+        end
+      end
+
+      def hit_table
+        Hash.new { |hash, file| hash[file] = Hash.new { |by_line, line| by_line[line] = [] } }
+      end
+
+      def per_file(&block)
+        Hash.new { |hash, file| hash[file] = block.call }
+      end
+
       def monotonic
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
 
       # Coverage is suspended while the delta is processed, so the recorder's
       # own work (and anything it calls) is never attributed to a test.
-      def each_hit_line
+      def each_hit
         snapshot = Coverage.result(stop: false, clear: true)
         suspended = Coverage.running?
         Coverage.suspend if suspended
@@ -61,8 +96,15 @@ module Saboteur
           file = @canonical[path]
           next unless @files.include?(file)
 
-          # Lines mode (set up by the executable); nil marks a line with no code.
-          data[:lines].each_with_index { |count, index| yield file, index + 1 if count&.positive? }
+          # Lines mode (set up by the executable); nil marks a line with no
+          # code. Methods mode keys are [owner, name, start_line, ...]; an
+          # endless def's body never counts a line hit, but its calls count
+          # here (issue #107).
+          data[:lines].each_with_index { |count, index| yield file, index + 1, :line if count&.positive? }
+          record_branches(file, data) { |span| yield file, span, :branch }
+          data[:methods]&.each do |(_owner, _name, start_line, *), count|
+            yield file, start_line, :method if count.positive?
+          end
         end
       ensure
         Coverage.resume if suspended

data/lib/saboteur/subject.rb

@@ -24,10 +24,11 @@ module Saboteur
   # the latter, because the def text must then be evaluated on the singleton.
   class Subject
     attr_reader :name, :owner, :singleton, :sclass, :file, :start_byte, :end_byte,
-                :start_line, :end_line, :nesting, :node, :file_source, :frozen_literals
+                :start_line, :end_line, :nesting, :node, :file_source, :frozen_literals, :sig_span
     attr_accessor :skip_reason
 
-    def initialize(name:, owner:, singleton:, sclass:, file:, node:, file_source:, nesting:, frozen_literals:)
+    def initialize(name:, owner:, singleton:, sclass:, file:, node:, file_source:, nesting:, frozen_literals:,
+                   sig_span: nil)
       @name = name
       @owner = owner
       @singleton = singleton
@@ -41,9 +42,20 @@ module Saboteur
       @end_byte = node.location.end_offset
       @start_line = node.location.start_line
       @end_line = node.location.end_line
+      @sig_span = sig_span
       @skip_reason = nil
     end
 
+    # The `sig { ... }` call right before the def, when there is one. A
+    # sorbet-wrapped method re-evaluates sig and def together, so the
+    # runtime type checks stay on for the mutant (see Execution::Wrapper).
+    def sig_source
+      return nil unless @sig_span
+
+      first, last = @sig_span
+      file_source.byteslice(first, last - first).force_encoding(Encoding::UTF_8)
+    end
+
     def id
       "#{owner}#{singleton ? '.' : '#'}#{name}"
     end
@@ -71,11 +83,14 @@ module Saboteur
 
     # Lines whose execution means the edited code ran: from the first line of
     # the innermost statement containing the edit to the edit's last line.
-    # A statement's first line always records a coverage event when it runs,
-    # so a test that never ran the edited code cannot have hit these lines.
+    # Pattern headers do not always record line events. Their enclosing case
+    # and clause body supply execution evidence instead.
     # An edit outside every statement (signature, around the def, whole
     # body) maps to the whole method.
     def coverage_lines_for(edit)
+      pattern_lines = pattern_coverage_lines(node.body, edit)
+      return pattern_lines if pattern_lines
+
       statement = innermost_statement(node.body, edit.start_byte, edit.end_byte)
       return coverage_lines unless statement
 
@@ -153,6 +168,27 @@ module Saboteur
       found
     end
 
+    def pattern_coverage_lines(child, edit, case_line = nil)
+      return nil unless child
+
+      case_line = child.location.start_line if child.is_a?(Prism::CaseMatchNode)
+      if child.is_a?(Prism::InNode) && contains_edit?(child.pattern, edit)
+        return [case_line, child.location.start_line, child.statements&.location&.start_line].compact.uniq
+      end
+
+      child.compact_child_nodes.each do |nested|
+        next unless contains_edit?(nested, edit)
+
+        lines = pattern_coverage_lines(nested, edit, case_line)
+        return lines if lines
+      end
+      nil
+    end
+
+    def contains_edit?(child, edit)
+      child.location.start_offset <= edit.start_byte && edit.end_byte <= child.location.end_offset
+    end
+
     def validate_edit!(edit, previous_start)
       unless File.expand_path(edit.file) == File.expand_path(file)
         raise ArgumentError, "edit for #{edit.file} applied to subject in #{file}"

data/lib/saboteur/subject_finder.rb

@@ -9,13 +9,21 @@ module Saboteur
   #
   # Included: instance methods and `def self.x` inside a class or module,
   # defs inside `class << self`, and defs passed to a receiverless call such
-  # as `private def x`. Skipped: top-level defs, defs nested in defs, defs in
-  # blocks (`Class.new do`, `included do`), and `def obj.x` for obj != self.
+  # as `private def x`. Skipped: top-level defs, defs nested in defs, and
+  # `def obj.x` for obj != self. Defs in blocks (`Class.new do`, `included do`)
+  # are found but marked skipped ("defined inside a block"), so the report
+  # names them instead of leaving them out. `X = Data.define`, `Struct.new`,
+  # `Class.new` or `Module.new` with a block names X as the owner; any other
+  # block, and a `A::X = ...` target, keeps the enclosing owner or the
+  # placeholder.
   class SubjectFinder
     Parsed = Data.define(:subjects, :errors)
+    ANONYMOUS_OWNER = "(anonymous block)"
+    CLASS_FACTORIES = { Data: :define, Struct: :new, Class: :new, Module: :new }.freeze
 
-    def call(file)
-      source = File.binread(file)
+    # source: the text to parse when it is not the file on disk (the file as
+    # it was at an earlier commit).
+    def call(file, source: File.binread(file))
       result = Prism.parse(source, filepath: file)
       return Parsed.new(subjects: [], errors: result.errors.map(&:message)) if result.failure?
 
@@ -34,23 +42,53 @@ module Saboteur
       end
     end
 
-    def walk(node, nesting, out, **ctx)
+    def walk(node, nesting, out, previous: nil, **ctx)
+      return if node.nil?
+
       case node
-      when nil, Prism::BlockNode, Prism::LambdaNode
-        nil
+      when Prism::BlockNode, Prism::LambdaNode
+        walk(node.body, nesting, out, **ctx, in_block: true)
+      when Prism::ConstantWriteNode
+        walk_constant_assignment(node, nesting, out, **ctx)
       when Prism::ModuleNode
         walk(node.body, nesting + [Scope.new(kind: :module, path: node.constant_path.slice)], out, **ctx)
       when Prism::ClassNode
         walk(node.body, nesting + [Scope.new(kind: :class, path: node.constant_path.slice)], out, **ctx)
       when Prism::SingletonClassNode
         walk_singleton_class(node, nesting, out, **ctx)
+      when Prism::StatementsNode
+        previous_child = nil
+        node.body.each do |child|
+          walk(child, nesting, out, previous: previous_child, **ctx)
+          previous_child = child
+        end
       when Prism::DefNode
-        add_subject(node, nesting, out, **ctx)
+        add_subject(node, nesting, out, previous: previous, **ctx)
       else
         node.compact_child_nodes.each { |child| walk(child, nesting, out, **ctx) }
       end
     end
 
+    # `Point = Data.define(:x) do ... end`: the defs belong to Point. Only the
+    # four core factories count, called on the bare constant; any other call
+    # that takes a block says nothing about the class it returns.
+    def walk_constant_assignment(node, nesting, out, **ctx)
+      call = node.value
+      return node.compact_child_nodes.each { |child| walk(child, nesting, out, **ctx) } unless class_factory?(call)
+
+      # The receiver and arguments stay in the enclosing scope; only the
+      # factory's own block belongs to the new class.
+      (call.compact_child_nodes - [call.block]).each { |child| walk(child, nesting, out, **ctx) }
+      walk(call.block, nesting + [Scope.new(kind: :class, path: node.name.to_s)], out, **ctx)
+    end
+
+    def class_factory?(call)
+      return false unless call.is_a?(Prism::CallNode) && call.block.is_a?(Prism::BlockNode)
+      return false unless call.receiver.is_a?(Prism::ConstantReadNode)
+
+      CLASS_FACTORIES[call.receiver.name] == call.name
+    end
+
     def walk_singleton_class(node, nesting, out, **ctx)
       return unless node.expression.is_a?(Prism::SelfNode)
       return if nesting.empty? || nesting.last.sclass?
@@ -58,18 +96,30 @@ module Saboteur
       walk(node.body, nesting + [Scope.new(kind: :sclass, path: "self")], out, **ctx)
     end
 
-    def add_subject(node, nesting, out, file:, source:, frozen:)
+    def add_subject(node, nesting, out, file:, source:, frozen:, previous: nil, in_block: false)
       in_sclass = nesting.last&.sclass? || false
       # `def self.x` inside `class << self`, and `def obj.x`, are not subjects.
       return unless node.receiver.nil? || (node.receiver.is_a?(Prism::SelfNode) && !in_sclass)
 
       singleton = in_sclass || !node.receiver.nil?
       owner = owner_path(nesting)
+      owner ||= ANONYMOUS_OWNER if in_block
       return unless owner
 
-      out << Subject.new(name: node.name, owner: owner, singleton: singleton, sclass: in_sclass,
-                         file: file, node: node, file_source: source, nesting: nesting,
-                         frozen_literals: frozen)
+      subject = Subject.new(name: node.name, owner: owner, singleton: singleton, sclass: in_sclass,
+                            file: file, node: node, file_source: source, nesting: nesting,
+                            frozen_literals: frozen, sig_span: sig_span(previous))
+      subject.skip_reason = "defined inside a block" if in_block
+      out << subject
+    end
+
+    # The byte span of a `sig { ... }` or `T.sig { ... }` call on the lines
+    # right before the def, when there is one.
+    def sig_span(previous)
+      return nil unless previous.is_a?(Prism::CallNode) && previous.name == :sig && previous.block
+      return nil unless previous.receiver.nil? || previous.receiver.slice == "T"
+
+      [previous.location.start_offset, previous.location.end_offset]
     end
 
     # Lexical path of the enclosing class/module. `class ::Foo` restarts at the top.

data/lib/saboteur/version.rb

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

data/lib/saboteur/working_tree.rb

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "open3"
+
+module Saboteur
+  # The state of the working source a run looked at: the commit it was on and
+  # (the full SHA) and whether files differed from it, tracked changes and each
+  # untracked file alike.
+  # Saboteur's own output (cache and reports) is passed in as ignored paths, so a
+  # report from an earlier run does not make the tree look dirty. Without git, or
+  # outside a repository, the state is unknown.
+  class WorkingTree
+    State = Data.define(:head, :dirty, :changed_files) do
+      def label
+        return "unknown" if dirty.nil?
+
+        dirty ? "dirty" : "clean"
+      end
+
+      # Shown before a run: mutants run your code and can change the tree.
+      def warning
+        return unless dirty
+
+        "saboteur: warning: #{changed_files} uncommitted change(s) in the working tree. " \
+          "Mutants run your code and could alter or delete files; run on a clean, committed tree or a CI checkout."
+      end
+    end
+
+    UNKNOWN = State.new(head: nil, dirty: nil, changed_files: nil)
+
+    # ignored: paths relative to root that are not source (saboteur's cache and reports).
+    def initialize(root, ignored: [])
+      @root = root
+      @ignored = ignored
+    end
+
+    def state
+      head, head_status = Open3.capture2e("git", "rev-parse", "HEAD", chdir: @root)
+      changes, changes_status = Open3.capture2e(*status_command, chdir: @root)
+      return UNKNOWN unless head_status.success? && changes_status.success?
+
+      count = changes.lines.size
+      State.new(head: head.strip, dirty: count.positive?, changed_files: count)
+    rescue SystemCallError
+      UNKNOWN
+    end
+
+    private
+
+    def status_command
+      excluded = @ignored.map { |path| ":(exclude)#{path}" }
+      ["git", "status", "--porcelain", "--untracked-files=all", "--", ".", *excluded]
+    end
+  end
+end

data/lib/saboteur.rb

@@ -9,6 +9,9 @@ module Saboteur
   # Invalid configuration or input files (exit code 2).
   class ConfigError < Error; end
 
+  # Files vanished from the working tree while mutants ran (exit code 3).
+  class CanaryTripped < Error; end
+
   class << self
     # Set while hook files from config load, so they can call Saboteur.hook.
     attr_accessor :current_hooks
@@ -36,18 +39,25 @@ require_relative "saboteur/execution/process_table"
 require_relative "saboteur/execution/process_tree"
 require_relative "saboteur/execution/supervisor"
 require_relative "saboteur/execution/reevaluator"
+require_relative "saboteur/execution/wrapper"
 require_relative "saboteur/execution/runner"
 require_relative "saboteur/execution/worker_pool"
 require_relative "saboteur/execution/fork_readiness"
+require_relative "saboteur/execution/sandbox"
 require_relative "saboteur/selection/coverage_map"
 require_relative "saboteur/selection/recorder"
 require_relative "saboteur/selection/git_diff"
 require_relative "saboteur/result"
+require_relative "saboteur/custom_map"
+require_relative "saboteur/gates"
 require_relative "saboteur/config"
 require_relative "saboteur/ignore_list"
 require_relative "saboteur/frameworks/rails"
 require_relative "saboteur/reporter/diff"
 require_relative "saboteur/reporter/findings"
+require_relative "saboteur/reporter/agent"
+require_relative "saboteur/working_tree"
+require_relative "saboteur/agent_skill"
 require_relative "saboteur/reporter/terminal"
 require_relative "saboteur/reporter/stryker"
 require_relative "saboteur/reporter/html"