saboteur 0.7.0 → 0.8.0

data/lib/saboteur/subject.rb

@@ -2,12 +2,17 @@
 # frozen_string_literal: true
 
 module Saboteur
-  # One lexical scope enclosing a def: `module X`, `class X` or `class << self`.
+  # One lexical scope enclosing a def: `module X`, `class X`, a class-factory
+  # block (`X = Data.define(:x) do`) or `class << self`.
   Scope = Data.define(:kind, :path) do
+    # A factory scope wraps the def in `X.class_eval do`: reopening it as
+    # `class X` would fight the generated class (a Module.new X is not even
+    # a class), while class_eval adds the method to the class already there.
     def header
       case kind
       when :module then "module #{path}"
       when :class then "class #{path}"
+      when :factory then "#{path}.class_eval do"
       when :sclass then "class << self"
       end
     end
@@ -15,6 +20,13 @@ module Saboteur
     def sclass?
       kind == :sclass
     end
+
+    # A factory scope names a runtime owner (the generated class) but opens
+    # no lexical constant scope: `Outer = Class.new do Inner = ... end` binds
+    # Inner on the enclosing lexical scope, never on Outer (#339).
+    def factory?
+      kind == :factory
+    end
   end
 
   # A method defined with `def`: the unit saboteur mutates.
@@ -60,6 +72,17 @@ module Saboteur
       "#{owner}#{singleton ? '.' : '#'}#{name}"
     end
 
+    # The node whose children are the method's statements: the block body
+    # for `define_method(:m) { ... }` (#194), the def body otherwise.
+    def body_node
+      return node.body unless node.is_a?(Prism::CallNode)
+
+      # define_method carries its body in the block; scope and the lambda
+      # form of define_singleton_method carry it in the lambda argument.
+      lambda = node.arguments&.arguments&.find { |arg| arg.is_a?(Prism::LambdaNode) }
+      (lambda || node.block)&.body
+    end
+
     def source
       @source ||= file_source.byteslice(start_byte, end_byte - start_byte).force_encoding(Encoding::UTF_8)
     end
@@ -88,10 +111,10 @@ module Saboteur
     # 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)
+      pattern_lines = pattern_coverage_lines(body_node, edit)
       return pattern_lines if pattern_lines
 
-      statement = innermost_statement(node.body, edit.start_byte, edit.end_byte)
+      statement = innermost_statement(body_node, edit.start_byte, edit.end_byte)
       return coverage_lines unless statement
 
       first = statement.location.start_line
@@ -102,7 +125,7 @@ module Saboteur
     # True when anything in the body can turn an error into a value: a
     # rescue or else clause, a modifier rescue, a nested begin/rescue.
     def recovers?
-      rescuing?(node.body)
+      rescuing?(body_node)
     end
 
     # The 1-based line of the file that holds this byte offset.
@@ -140,6 +163,12 @@ module Saboteur
       text.force_encoding(Encoding::UTF_8)
     end
 
+    # Def subjects prefer surgical re-evaluation; a ConstantSubject always
+    # re-evaluates its whole file (there is no method to redefine).
+    def whole_file_only?
+      false
+    end
+
     def to_s
       id
     end
@@ -159,10 +188,15 @@ module Saboteur
       child.compact_child_nodes.any? { |grandchild| rescuing?(grandchild) }
     end
 
-    def innermost_statement(node, start_byte, end_byte, found = nil)
+    # An interpolation's own statements (#{"..."}) are eager: they run on
+    # the enclosing statement's lines, so they never demote it (#498). A
+    # continuation line of a multi-line interpolated statement can lack a
+    # per-example line hit, so attribution must span from the statement's
+    # first line.
+    def innermost_statement(node, start_byte, end_byte, found = nil, embedded: false)
       return found if node.nil?
 
-      if node.is_a?(Prism::StatementsNode)
+      if node.is_a?(Prism::StatementsNode) && !embedded
         statement = node.body.find do |child|
           child.location.start_offset <= start_byte && end_byte <= child.location.end_offset
         end
@@ -174,7 +208,8 @@ module Saboteur
       node.compact_child_nodes.each do |child|
         next unless child.location.start_offset <= start_byte && end_byte <= child.location.end_offset
 
-        return innermost_statement(child, start_byte, end_byte, found)
+        return innermost_statement(child, start_byte, end_byte, found,
+                                   embedded: embedded || node.is_a?(Prism::EmbeddedStatementsNode))
       end
       found
     end

data/lib/saboteur/subject_finder.rb

@@ -10,15 +10,17 @@ 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, and
-  # `def obj.x` for obj != self. Defs in blocks (`Class.new do`, `included do`)
+  # `def obj.x` for obj != self. Defs in blocks (`included do`, builders)
   # 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.
+  # names them instead of leaving them out - except the four core class
+  # factories: `X = Data.define`, `Struct.new`, `Class.new` or `Module.new`
+  # with a block names X as the owner, and its defs are ordinary subjects
+  # that re-evaluate through X.class_eval (#290). 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)"
+    CALL_DEFINED_SINGLETONS = %i[scope define_singleton_method].freeze
     CLASS_FACTORIES = { Data: :define, Struct: :new, Class: :new, Module: :new }.freeze
 
     # source: the text to parse when it is not the file on disk (the file as
@@ -51,24 +53,142 @@ module Saboteur
       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)
+        scope = Scope.new(kind: :module, path: node.constant_path.slice)
+        walk(node.body, lexical_nesting(nesting) + [scope], out, **ctx)
       when Prism::ClassNode
-        walk(node.body, nesting + [Scope.new(kind: :class, path: node.constant_path.slice)], out, **ctx)
+        scope = Scope.new(kind: :class, path: node.constant_path.slice)
+        walk(node.body, lexical_nesting(nesting) + [scope], 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
+        walk_statements(node, nesting, out, **ctx)
       when Prism::DefNode
         add_subject(node, nesting, out, previous: previous, **ctx)
+      when Prism::CallNode
+        walk_call(node, nesting, out, **ctx)
       else
         node.compact_child_nodes.each { |child| walk(child, nesting, out, **ctx) }
       end
     end
 
+    # `define_method(:m) { ... }` is a method definition: the block body is
+    # the method body, and re-evaluating the whole call redefines the method
+    # on the enclosing owner (#194). Only a bare call with a literal name and
+    # a block counts; a computed name, an explicit receiver, or a lambda
+    # argument says nothing the finder can name.
+    # A define_method subject's body is its block; any other call is walked
+    # through its children.
+    def walk_call(node, nesting, out, **ctx)
+      return walk_heredoc_eval(node, nesting, out, **ctx) if heredoc_eval?(node)
+      return walk_children(node, nesting, out, **ctx) unless call_defined_method?(node)
+
+      in_sclass = nesting.last&.sclass? || false
+      owner = owner_path(nesting)
+      owner ||= ANONYMOUS_OWNER if ctx[:in_block]
+      return walk_children(node, nesting, out, **ctx) unless owner
+
+      name = node.arguments.arguments.first.unescaped.to_sym
+      # scope and define_singleton_method define on the class itself;
+      # define_method follows the surrounding nesting like a def (#194).
+      singleton = in_sclass || CALL_DEFINED_SINGLETONS.include?(node.name)
+      subject = Subject.new(name: name, owner: owner, singleton: singleton, sclass: in_sclass,
+                            file: ctx[:file], node: node, file_source: ctx[:source], nesting: nesting,
+                            frozen_literals: ctx[:frozen], sig_span: nil)
+      subject.skip_reason = "defined inside a block" if ctx[:in_block]
+      out << subject
+    end
+
+    # Statements carry `previous` so a def can see the sig comment above it.
+    def walk_statements(node, nesting, out, **ctx)
+      previous_child = nil
+      node.body.each do |child|
+        walk(child, nesting, out, previous: previous_child, **ctx)
+        previous_child = child
+      end
+    end
+
+    def walk_children(node, nesting, out, **ctx)
+      node.compact_child_nodes.each { |child| walk(child, nesting, out, **ctx) }
+    end
+
+    # `class_eval <<-RUBY ... RUBY` with a non-interpolated heredoc defines
+    # methods on the enclosing owner (#544). Only a bare call with one
+    # heredoc argument counts: an explicit receiver names another owner, and
+    # an interpolated heredoc does not map to file bytes 1:1, so it stays on
+    # the code-in-strings warning (#467).
+    def heredoc_eval?(node)
+      return false unless %i[class_eval module_eval].include?(node.name) && node.receiver.nil? && node.block.nil?
+
+      arguments = node.arguments&.arguments
+      return false unless arguments&.size == 1
+
+      heredoc = arguments.first
+      heredoc.is_a?(Prism::StringNode) && heredoc.opening_loc&.slice&.start_with?("<<")
+    end
+
+    # The heredoc body's bytes sit in the real file 1:1, so blanking every
+    # byte outside the body (keeping newlines) parses the defs at their
+    # real offsets and lines: mutants apply through the ordinary file-bytes
+    # path. The enclosing nesting supplies the owner. A body that does not
+    # parse defines nothing.
+    def walk_heredoc_eval(node, nesting, out, **ctx)
+      location = node.arguments.arguments.first.content_loc
+      virtual = blank_outside(ctx[:source], location.start_offset...location.end_offset)
+      result = Prism.parse(virtual, filepath: ctx[:file])
+      return if result.failure?
+
+      walk(result.value, nesting, out, **ctx)
+    end
+
+    # source with every byte outside range spaced over, except newlines:
+    # offsets and lines inside range stay exactly as in the real file.
+    def blank_outside(source, range)
+      source.bytes.each_with_index.map { |byte, index| range.cover?(index) || byte == 10 ? byte : 32 }.pack("C*")
+            .force_encoding(source.encoding)
+    end
+
+    def define_method_subject?(node)
+      return false unless node.name == :define_method && node.receiver.nil?
+      return false unless node.block.is_a?(Prism::BlockNode)
+
+      # With two arguments the second is the body and the block is dead code.
+      return false unless node.arguments&.arguments&.size == 1
+
+      name_arg = node.arguments.arguments.first
+      name_arg.is_a?(Prism::SymbolNode) || name_arg.is_a?(Prism::StringNode)
+    end
+
+    # Calls that define a method, all with a literal first argument for the
+    # name: define_method (instance, or singleton inside class << self) and
+    # the two class-level shapes the human-essentials dogfood exposed,
+    # `scope :name, -> { ... }` and define_singleton_method (#194). The
+    # whole call is the subject's source and re-evaluates on the owner.
+    def call_defined_method?(node)
+      return false unless node.receiver.nil?
+      return false unless literal_name?(node)
+
+      case node.name
+      when :define_method then define_method_subject?(node)
+      when :define_singleton_method then lambda_body?(node) || block_only?(node)
+      # Rails scope: exactly a literal name and a lambda body.
+      when :scope then lambda_body?(node) && node.arguments.arguments.size == 2
+      else false
+      end
+    end
+
+    def literal_name?(node)
+      name_arg = node.arguments&.arguments&.first
+      name_arg.is_a?(Prism::SymbolNode) || name_arg.is_a?(Prism::StringNode)
+    end
+
+    def lambda_body?(node)
+      node.block.nil? && node.arguments&.arguments&.last.is_a?(Prism::LambdaNode)
+    end
+
+    def block_only?(node)
+      node.block.is_a?(Prism::BlockNode) && node.arguments&.arguments&.size == 1
+    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.
@@ -77,9 +197,24 @@ module Saboteur
       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.
+      # factory's own block belongs to the new class. The block's body is
+      # walked directly, not as a block: the factory names its class, so the
+      # defs re-evaluate through X.class_eval and are ordinary subjects
+      # (#290), while a block nested deeper still marks its defs skipped.
       (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)
+      walk(call.block.body, lexical_nesting(nesting) + [Scope.new(kind: :factory, path: node.name.to_s)], out, **ctx)
+    end
+
+    # Constant-introducing declarations (class/module keywords and factory
+    # assignments) bind on the enclosing lexical scope: factory blocks open
+    # none, so their scopes never join a new constant's path (#339) - unless
+    # an sclass follows the factory: `class << self` inside a factory block
+    # attaches to the factory's class at runtime (class_eval sets self), and
+    # the sclass needs the factory's path to name that attachment (#438).
+    def lexical_nesting(nesting)
+      nesting.each_with_index.reject do |scope, index|
+        scope.factory? && nesting[(index + 1)..].none?(&:sclass?)
+      end.map(&:first)
     end
 
     def class_factory?(call)
@@ -123,26 +258,35 @@ module Saboteur
     end
 
     # Lexical path of the enclosing class/module. `class ::Foo` restarts at the top.
+    # A bare `class << self` scope leaves the owner alone (its defs are the
+    # attached class's singleton methods), but a factory constant assigned
+    # through it binds on the singleton class (#352), so the sclass renders
+    # as a `singleton_class` path segment when a factory scope sits after it
+    # (#406): `Host.singleton_class::Widget`, mirroring the constant side
+    # (#380).
     def owner_path(nesting)
-      parts = nesting.reject(&:sclass?).map(&:path)
-      return nil if parts.empty?
+      segments = nesting.each_with_index.filter_map do |scope, index|
+        if scope.sclass?
+          :singleton_class if nesting[(index + 1)..].any?(&:factory?)
+        else
+          scope.path
+        end
+      end
+      return nil if segments.empty?
 
-      parts.each_with_object([]) do |path, acc|
-        acc.clear if path.start_with?("::")
-        acc << path.delete_prefix("::")
-      end.join("::")
+      segments.each_with_object(+"") do |segment, out|
+        if segment == :singleton_class
+          out << ".singleton_class"
+        else
+          out.clear if segment.start_with?("::")
+          out << "::" unless out.empty?
+          out << segment.delete_prefix("::")
+        end
+      end
     end
 
     def mark_refinements(subjects, program)
-      return unless uses_refinements?(program)
-
-      subjects.each { |subject| subject.skip_reason = "refinements" }
-    end
-
-    def uses_refinements?(node)
-      return true if node.is_a?(Prism::CallNode) && node.name == :using && node.receiver.nil?
-
-      node.compact_child_nodes.any? { |child| uses_refinements?(child) }
+      RefinementActivations.mark(subjects, program)
     end
   end
 end

data/lib/saboteur/version.rb

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

data/lib/saboteur/working_tree.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "open3"
+require_relative "text"
 
 module Saboteur
   # The state of the working source a run looked at: the commit it was on and
@@ -11,23 +12,25 @@ module Saboteur
   # 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?
+    # One uncommitted change: its path relative to the root (the new path
+    # of a rename, the old path of a deletion) and whether git tracks it.
+    Change = Data.define(:path, :tracked)
 
-        dirty ? "dirty" : "clean"
+    State = Data.define(:head, :dirty, :changed_files, :changes) do
+      def initialize(head:, dirty:, changed_files:, changes: [])
+        super
       end
 
-      # Shown before a run: mutants run your code and can change the tree.
-      def warning
-        return unless dirty
+      def label
+        return "unknown" if dirty.nil?
 
-        "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."
+        dirty ? "dirty" : "clean"
       end
     end
 
     UNKNOWN = State.new(head: nil, dirty: nil, changed_files: nil)
+    UNTRACKED = "??"
+    RENAMED_OR_COPIED = /[RC]/
 
     # ignored: paths relative to root that are not source (saboteur's cache and reports).
     def initialize(root, ignored: [])
@@ -35,22 +38,42 @@ module Saboteur
       @ignored = ignored
     end
 
+    # git status names paths from the top of the repository; the prefix
+    # turns them into paths relative to the root.
     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?
+      head, _, head_status = Open3.capture3("git", "rev-parse", "HEAD", "--show-prefix", chdir: @root)
+      status, _, status_status = Open3.capture3(*status_command, chdir: @root)
+      return UNKNOWN unless head_status.success? && status_status.success?
 
-      count = changes.lines.size
-      State.new(head: head.strip, dirty: count.positive?, changed_files: count)
+      sha, prefix = head.lines.map(&:chomp)
+      changes = changes_in(status, Text.utf8_identity(prefix.to_s))
+      State.new(head: sha, dirty: changes.any?, changed_files: changes.size, changes: changes)
     rescue SystemCallError
       UNKNOWN
     end
 
     private
 
+    # Porcelain v1 with -z: "XY path" entries separated by NUL, a rename or
+    # copy followed by one more entry holding its old path.
+    def changes_in(status, prefix)
+      entries = status.b.split("\0")
+      changes = []
+      until entries.empty?
+        entry = entries.shift
+        code = entry[0, 2]
+        entries.shift if code.match?(RENAMED_OR_COPIED)
+        path = Text.utf8_identity(entry[3..]).delete_prefix(prefix)
+        changes << Change.new(path: path, tracked: code != UNTRACKED)
+      end
+      changes
+    end
+
+    # -z implies --porcelain=v1, and status takes no revisions, so the
+    # pathspecs need no "--" in front.
     def status_command
       excluded = @ignored.map { |path| ":(exclude)#{path}" }
-      ["git", "status", "--porcelain", "--untracked-files=all", "--", ".", *excluded]
+      ["git", "status", "-z", "--untracked-files=all", ".", *excluded]
     end
   end
 end

data/lib/saboteur.rb

@@ -43,25 +43,36 @@ module Saboteur
   end
 end
 
+require_relative "saboteur/coverage_reads"
 require_relative "saboteur/hooks"
 require_relative "saboteur/mutation_source/base"
 require_relative "saboteur/mutation_source/builtin"
 require_relative "saboteur/integration/base"
 require_relative "saboteur/subject"
+require_relative "saboteur/refinement_activations"
 require_relative "saboteur/subject_finder"
+require_relative "saboteur/constant_subject"
+require_relative "saboteur/constant_subject_finder"
+require_relative "saboteur/constant_reads"
+require_relative "saboteur/mutation_source/constant_literals"
 require_relative "saboteur/execution/protocol"
 require_relative "saboteur/execution/process_table"
 require_relative "saboteur/execution/process_tree"
+require_relative "saboteur/execution/marker_sweep"
 require_relative "saboteur/execution/supervisor"
 require_relative "saboteur/execution/reevaluator"
 require_relative "saboteur/execution/wrapper"
 require_relative "saboteur/execution/runner"
+require_relative "saboteur/execution/external_runner"
 require_relative "saboteur/execution/worker_pool"
 require_relative "saboteur/execution/fork_readiness"
 require_relative "saboteur/execution/sandbox"
+require_relative "saboteur/execution/seatbelt"
 require_relative "saboteur/selection/coverage_map"
+require_relative "saboteur/selection/external_test_map"
 require_relative "saboteur/selection/recorder"
 require_relative "saboteur/selection/git_diff"
+require_relative "saboteur/selection/source_scope"
 require_relative "saboteur/result"
 require_relative "saboteur/custom_map"
 require_relative "saboteur/gates"
@@ -72,8 +83,10 @@ require_relative "saboteur/reporter/diff"
 require_relative "saboteur/reporter/findings"
 require_relative "saboteur/reporter/agent"
 require_relative "saboteur/working_tree"
+require_relative "saboteur/dirty_tree_warning"
 require_relative "saboteur/agent_skill"
 require_relative "saboteur/reporter/terminal"
 require_relative "saboteur/reporter/stryker"
+require_relative "saboteur/reporter/survivor_classification"
 require_relative "saboteur/reporter/html"
 require_relative "saboteur/engine"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: saboteur
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Vamsi Pavan Mahesh Gunturu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-16 00:00:00.000000000 Z
+date: 2026-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fiddle
@@ -74,13 +74,23 @@ files:
 - lib/saboteur/cli.rb
 - lib/saboteur/cli/exit_status.rb
 - lib/saboteur/cli/help_options.rb
+- lib/saboteur/cli/history_command.rb
 - lib/saboteur/cli/presets.rb
 - lib/saboteur/cli/run_budget_options.rb
 - lib/saboteur/cli/run_reporting.rb
+- lib/saboteur/cli/selection_options.rb
+- lib/saboteur/cli/shard_options.rb
+- lib/saboteur/cli/source_set.rb
+- lib/saboteur/cli/survivors_command.rb
 - lib/saboteur/config.rb
 - lib/saboteur/config_file.rb
+- lib/saboteur/constant_reads.rb
+- lib/saboteur/constant_subject.rb
+- lib/saboteur/constant_subject_finder.rb
+- lib/saboteur/coverage_reads.rb
 - lib/saboteur/crash_report.rb
 - lib/saboteur/custom_map.rb
+- lib/saboteur/dirty_tree_warning.rb
 - lib/saboteur/doctor.rb
 - lib/saboteur/engine.rb
 - lib/saboteur/engine/baseline_guard.rb
@@ -92,15 +102,22 @@ files:
 - lib/saboteur/engine/coverage_guard.rb
 - lib/saboteur/engine/coverage_store.rb
 - lib/saboteur/engine/data_inputs.rb
+- lib/saboteur/engine/defined_order_prefix.rb
 - lib/saboteur/engine/diagnostics.rb
 - lib/saboteur/engine/diff_scope.rb
 - lib/saboteur/engine/distribution.rb
 - lib/saboteur/engine/early_stop_recording.rb
+- lib/saboteur/engine/gated_run.rb
+- lib/saboteur/engine/load_coverage.rb
+- lib/saboteur/engine/out_of_scope_guard.rb
+- lib/saboteur/engine/pipelines.rb
 - lib/saboteur/engine/result_cache.rb
 - lib/saboteur/engine/run_budget.rb
 - lib/saboteur/engine/run_fingerprint.rb
 - lib/saboteur/engine/sandbox_policy.rb
 - lib/saboteur/engine/scheduler.rb
+- lib/saboteur/engine/selection_announcement.rb
+- lib/saboteur/engine/shard.rb
 - lib/saboteur/engine/subject_selection.rb
 - lib/saboteur/engine/suite_files.rb
 - lib/saboteur/engine/test_guess.rb
@@ -108,19 +125,24 @@ files:
 - lib/saboteur/engine/unchanged_syntax.rb
 - lib/saboteur/engine/unscoped_suite_warning.rb
 - lib/saboteur/engine/verdict_check.rb
+- lib/saboteur/execution/external_runner.rb
 - lib/saboteur/execution/fork_readiness.rb
+- lib/saboteur/execution/marker_sweep.rb
+- lib/saboteur/execution/peak_memory.rb
 - lib/saboteur/execution/process_table.rb
 - lib/saboteur/execution/process_tree.rb
 - lib/saboteur/execution/protocol.rb
 - lib/saboteur/execution/reevaluator.rb
 - lib/saboteur/execution/runner.rb
 - lib/saboteur/execution/sandbox.rb
+- lib/saboteur/execution/seatbelt.rb
 - lib/saboteur/execution/stale_captures.rb
 - lib/saboteur/execution/supervisor.rb
 - lib/saboteur/execution/worker_pool.rb
 - lib/saboteur/execution/wrapper.rb
 - lib/saboteur/frameworks/database_hosts.rb
 - lib/saboteur/frameworks/rails.rb
+- lib/saboteur/frameworks/sqlite_memory_database.rb
 - lib/saboteur/gates.rb
 - lib/saboteur/help.rb
 - lib/saboteur/hooks.rb
@@ -135,8 +157,11 @@ files:
 - lib/saboteur/mutation_source/builtin.rb
 - lib/saboteur/mutation_source/chain_removal.rb
 - lib/saboteur/mutation_source/condition_negation.rb
+- lib/saboteur/mutation_source/constant_literals.rb
 - lib/saboteur/mutation_source/edit.rb
+- lib/saboteur/mutation_source/element_removal.rb
 - lib/saboteur/mutation_source/endpoint_replacement.rb
+- lib/saboteur/mutation_source/entry_edits.rb
 - lib/saboteur/mutation_source/filter_replacement.rb
 - lib/saboteur/mutation_source/hazard_guard.rb
 - lib/saboteur/mutation_source/interpolation_removal.rb
@@ -150,7 +175,9 @@ files:
 - lib/saboteur/mutation_source/operator_visit.rb
 - lib/saboteur/mutation_source/pair_removal.rb
 - lib/saboteur/mutation_source/range_replacement.rb
+- lib/saboteur/mutation_source/regex_replacement.rb
 - lib/saboteur/preview.rb
+- lib/saboteur/refinement_activations.rb
 - lib/saboteur/replay.rb
 - lib/saboteur/reporter/agent.rb
 - lib/saboteur/reporter/agent_clipping.rb
@@ -161,6 +188,7 @@ files:
 - lib/saboteur/reporter/findings.rb
 - lib/saboteur/reporter/history_paths.rb
 - lib/saboteur/reporter/history_policy.rb
+- lib/saboteur/reporter/history_reader.rb
 - lib/saboteur/reporter/history_record.rb
 - lib/saboteur/reporter/html.rb
 - lib/saboteur/reporter/mutation_text.rb
@@ -170,6 +198,7 @@ files:
 - lib/saboteur/reporter/score_history.rb
 - lib/saboteur/reporter/score_table.rb
 - lib/saboteur/reporter/stryker.rb
+- lib/saboteur/reporter/survivor_classification.rb
 - lib/saboteur/reporter/survivor_hints.rb
 - lib/saboteur/reporter/survivor_list.rb
 - lib/saboteur/reporter/survivor_ranking.rb
@@ -178,8 +207,12 @@ files:
 - lib/saboteur/result.rb
 - lib/saboteur/score.rb
 - lib/saboteur/selection/coverage_map.rb
+- lib/saboteur/selection/dependency_shield.rb
+- lib/saboteur/selection/external_test_map.rb
 - lib/saboteur/selection/git_diff.rb
+- lib/saboteur/selection/layout_only_lines.rb
 - lib/saboteur/selection/recorder.rb
+- lib/saboteur/selection/source_scope.rb
 - lib/saboteur/selection/untracked_changes.rb
 - lib/saboteur/subject.rb
 - lib/saboteur/subject_finder.rb