active_mutator 0.1.1 → 0.3.0

data/lib/active_mutator/closure_reload.rb

@@ -0,0 +1,202 @@
+module ActiveMutator
+  # Fork-side insertion for class-body mutants. A def mutant can be
+  # class_eval'd over the live constant; class-level code cannot (re-running
+  # `validates` ADDS a validator, it doesn't replace one). So: remove the
+  # constant and re-eval the whole mutated file. Anything already attached to
+  # the OLD object — classes that include the module, subclasses, extend
+  # sites — would go stale, so they are removed and re-evaled too (pristine
+  # sources), dependency-first. The fork dies after the run; nothing is
+  # restored.
+  #
+  # Every guard failure raises Skip; the Worker reports the mutant as
+  # `skipped` with the reason. Skipping is honest: a mutant we cannot insert
+  # faithfully must not be counted as survived OR killed.
+  #
+  # Known limitations (inherent to remove-and-reload; accepted trade-offs):
+  #   - References that hold the target BY VALUE rather than by ancestry are
+  #     not discovered and keep pointing at the pre-remove_const object:
+  #     aliases (`ALIAS = MyClass`), arrays/registries the target was pushed
+  #     into, memoized instances, class variables captured at load time.
+  #   - `refine`-based modules are anonymous and do not appear in normal
+  #     `ancestors`, so refinements of the target are not discovered/reloaded.
+  #   - Re-evaling the target AND each attacher re-runs their class-body side
+  #     effects. Non-idempotent load-time effects (self-registration into a
+  #     global registry, DescendantsTracker-style hooks) therefore run twice; a
+  #     spec asserting such a count can see it doubled (false kill) or masked
+  #     (false survival).
+  #   - The re-eval order pins the target first (every attacher depends on it)
+  #     then sorts the rest by instance-ancestor depth. An `extend`
+  #     relationship BETWEEN two non-target attachers can still re-eval out of
+  #     order (rare); a full topological sort is deliberately not attempted.
+  class ClosureReload
+    Skip = Class.new(StandardError)
+
+    # The MUTATED target source could not be re-evaled — the mutation broke the
+    # class so it no longer loads. Every covering spec loads the class, so the
+    # suite would fail: the Worker maps this to a kill, not an error.
+    MutantLoadError = Class.new(StandardError)
+
+    DEFAULT_CAP = 10
+
+    class << self
+      # Assigned by Runner from config before scheduling; forks inherit it.
+      attr_writer :cap
+
+      def cap = @cap || DEFAULT_CAP
+    end
+
+    def initialize(subject, mutated_source)
+      @subject = subject
+      @mutated_source = mutated_source
+    end
+
+    def call(cap: self.class.cap)
+      target = resolve_target
+      closure = compute_closure(target)
+      if closure.size > cap
+        raise Skip, "reload closure (#{closure.size} constants) exceeds cap (#{cap})"
+      end
+
+      # Re-eval must load dependencies before dependents. Every closure member
+      # carries the target directly (single-pass discovery invariant), so the
+      # target must be re-eval'd first — pin it to the front. `ancestors.size`
+      # can't do this alone: an `extend` puts the target in the extender's
+      # SINGLETON ancestry, so a module that extends the target has an instance
+      # ancestry SMALLER than the target's and would sort before it (NameError
+      # on re-eval). For the remaining attachers, ascending instance-ancestor
+      # depth is a valid order among include/subclass relationships (a
+      # superclass before its subclass, an included module before its
+      # includer); depth is captured while the constants are still live, since
+      # it can't be read after remove_const.
+      rest = closure.reject { |m| m.equal?(target) }
+      ordered = [target, *rest.sort_by { |m| m.ancestors.size }]
+      sources = ordered.map { |mod| [mod.name, source_for(mod)] }
+      sources.each { |name, _| remove_constant(name) }
+      sources.each_with_index do |(_, (file, src)), idx|
+        eval(src, TOPLEVEL_BINDING, file, 1) # rubocop:disable Security/Eval
+      rescue ScriptError, StandardError => e
+        # idx.zero? is the MUTATED target, which by construction depends on
+        # nothing else in the closure (every other member carries the target,
+        # not vice versa). Its source failing to load is therefore the
+        # mutation's own doing — a kill, not a tool error.
+        #
+        # A PRISTINE dependent (idx > 0) failing means the ancestry-depth order
+        # couldn't satisfy a cross-attacher reference (see the ordering note
+        # above): we can't faithfully reinstate the closure, so this is an
+        # honest Skip, not a survived/killed verdict and not a bare error.
+        raise MutantLoadError, e.message if idx.zero?
+
+        raise Skip, "reload re-eval failed (#{e.message}); closure could not be reinstated in dependency order"
+      end
+      nil
+    end
+
+    private
+
+    def resolve_target
+      scope = @subject.constant_scope
+      target = begin
+        Object.const_get(scope)
+      rescue NameError
+        raise Skip, "constant #{scope} not loaded"
+      end
+      file, = Object.const_source_location(scope)
+      unless file && File.identical?(file, @subject.file)
+        raise Skip, "#{scope} defined at #{file || "?"}, not #{@subject.file} (reopened constant)"
+      end
+      target
+    end
+
+    # Single discovery pass. Ruby's `ancestors` is transitive, so one scan for
+    # everything carrying the target already yields every transitive attacher:
+    # an attacher-of-an-attacher (a subclass of an includer, an includer of an
+    # includer) carries the target directly too. No BFS/dedup is needed — the
+    # re-eval order is imposed later by pinning the target first and sorting the
+    # rest by ancestry depth (see #call), not by discovery order and not by a
+    # full topological sort (deliberately not attempted; see class docstring).
+    def compute_closure(target)
+      [target, *attachers(target)]
+    end
+
+    # Everything stale after removing `mod`: includers and subclasses carry
+    # it in `ancestors`; extend-sites carry it in their singleton class's
+    # ancestors, so singleton classes map back through attached_object. `.uniq`
+    # collapses a member found both ways (a class that both includes and
+    # extends the target).
+    def attachers(mod)
+      ObjectSpace.each_object(Module).filter_map do |m|
+        next if m.equal?(mod)
+        next unless carries?(m, mod)
+
+        if m.singleton_class?
+          m = m.attached_object
+          unless m.is_a?(Module)
+            raise Skip, "an object instance is extended with #{mod.name || mod.inspect}; not reloadable"
+          end
+        end
+
+        m
+      end.uniq
+    end
+
+    # ObjectSpace hands back every Module in the VM, including ones we cannot
+    # introspect — e.g. a module whose #ancestors is overridden to raise. A
+    # module we cannot read is not a reloadable dependency of the target, so
+    # treat it as unrelated rather than aborting the whole scan. Trade-off: a
+    # genuine attacher whose #ancestors raises would be silently dropped
+    # (acceptable — pathological).
+    #
+    # The rescue is deliberately broader than StandardError: #ancestors on a
+    # foreign object can raise Exception-level errors that are NOT StandardError
+    # — the canonical case is an expired RSpec verifying double
+    # (ExpiredTestDoubleError < MockExpectationError < Exception) left in
+    # ObjectSpace by another spec. Control-flow errors (a signal such as an
+    # interrupt, or an explicit exit) are re-raised so a run stays
+    # interruptible; everything else means "not a dependency, skip it".
+    def carries?(mod, target)
+      mod.ancestors.include?(target)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      raise if e.is_a?(SignalException) || e.is_a?(SystemExit)
+
+      false
+    end
+
+    def source_for(mod)
+      name = mod.name
+      raise Skip, "anonymous #{mod.is_a?(Class) ? "class" : "module"} in reload closure" unless name
+
+      return [@subject.file, @mutated_source] if name == @subject.constant_scope
+
+      file, = Object.const_source_location(name)
+      raise Skip, "#{name}: no source file (native or dynamically defined)" unless file && File.exist?(file)
+
+      src = File.read(file)
+      unless single_constant_file?(src)
+        raise Skip, "#{name}: #{file} defines multiple top-level constants; not reloadable"
+      end
+
+      [file, src]
+    end
+
+    # Same Zeitwerk-shape rule the SubjectFinder gate applies to the target
+    # file: re-evaling a multi-constant file would re-run macros on constants
+    # that were NOT removed (accumulation bugs). Shared with SubjectFinder.
+    def single_constant_file?(source)
+      result = Prism.parse(source)
+      return false unless result.success?
+
+      ClassShape.single_top_level_constant?(result.value)
+    end
+
+    def remove_constant(name)
+      parts = name.split("::")
+      leaf = parts.pop
+      parent = parts.empty? ? Object : Object.const_get(parts.join("::"))
+      parent.send(:remove_const, leaf)
+    rescue NameError
+      # Either a parent namespace earlier in the closure was already removed
+      # (taking this nested constant with it), or the leaf is already gone.
+      # Nothing to remove — the re-eval pass reinstates it from its own file.
+    end
+  end
+end

data/lib/active_mutator/config.rb

@@ -4,5 +4,7 @@ module ActiveMutator
   Config = Data.define(:paths, :since, :subject_filter, :jobs, :format, :requires,
                        :timeout_factor, :timeout_floor, :force_baseline, :root,
                        :preload_helper, :serial_patterns, :browser_boot_seconds,
-                       :accept_survivors)
+                       :accept_survivors, :exclude, :max_mutants, :debug_plan,
+                       :fail_at, :adaptive_timeout, :operators,
+                       :class_level, :class_level_closure_cap)
 end

data/lib/active_mutator/config_file.rb

@@ -0,0 +1,92 @@
+require "yaml"
+
+module ActiveMutator
+  # Project config file, layered UNDER CLI flags: CLI.parse seeds its option
+  # defaults from this before OptionParser runs, so any flag given on the
+  # command line wins. Strict on unknown keys and types — a typo silently
+  # ignored would be a config that silently doesn't apply.
+  class ConfigFile
+    FILENAME = ".active_mutator.yml"
+
+    FORMATS = %w[terminal json stryker-json github].freeze
+
+    KEYS = {
+      "jobs" => :integer,
+      "format" => :format,
+      "timeout_factor" => :number,
+      "timeout_floor" => :number,
+      "browser_boot_seconds" => :number,
+      "fail_at" => :score,
+      "exclude" => :string_list,
+      "serial_patterns" => :string_list,
+      "requires" => :string_list,
+      "operators" => :string_list,
+      "preload_helper" => :preload_helper,
+      "adaptive_timeout" => :boolean,
+      "class_level" => :boolean,
+      "class_level_closure_cap" => :positive_integer
+    }.freeze
+
+    def self.load(root)
+      path = File.join(root, FILENAME)
+      return {} unless File.exist?(path)
+
+      data = parse(path)
+      return {} if data.nil?
+      raise Error, "#{FILENAME}: top level must be a mapping" unless data.is_a?(Hash)
+
+      data.to_h do |key, value|
+        validator = KEYS[key]
+        raise Error, "#{FILENAME}: unknown config key: #{key}" unless validator
+
+        [key.to_sym, coerce(key, validator, value)]
+      end
+    end
+
+    def self.parse(path)
+      YAML.safe_load_file(path, aliases: true)
+    rescue Psych::Exception => e
+      raise Error, "#{FILENAME}: #{e.message}"
+    end
+
+    def self.coerce(key, validator, value)
+      case validator
+      when :integer
+        raise Error, "#{FILENAME}: #{key} must be an integer" unless value.is_a?(Integer)
+        value
+      when :positive_integer
+        raise Error, "#{FILENAME}: #{key} must be an integer" unless value.is_a?(Integer)
+        raise Error, "#{FILENAME}: #{key} must be >= 1" unless value >= 1
+        value
+      when :number
+        raise Error, "#{FILENAME}: #{key} must be a number" unless value.is_a?(Numeric)
+        value.to_f
+      when :score
+        raise Error, "#{FILENAME}: #{key} must be a number" unless value.is_a?(Numeric)
+        raise Error, "#{FILENAME}: #{key} must be within 0..100" unless (0..100).cover?(value)
+        value.to_f
+      when :format
+        unless FORMATS.include?(value)
+          raise Error, "#{FILENAME}: format must be one of #{FORMATS.join(", ")}"
+        end
+        value.tr("-", "_").to_sym
+      when :string_list
+        unless value.is_a?(Array) && value.all?(String)
+          raise Error, "#{FILENAME}: #{key} must be a list of strings"
+        end
+        value
+      when :boolean
+        unless [true, false].include?(value)
+          raise Error, "#{FILENAME}: #{key} must be true or false"
+        end
+        value
+      when :preload_helper
+        return :none if value == false
+        raise Error, "#{FILENAME}: preload_helper must be a path or false" unless value.is_a?(String)
+        value
+      else
+        raise Error, "unhandled validator #{validator}"
+      end
+    end
+  end
+end

data/lib/active_mutator/defined_constants.rb

@@ -0,0 +1,48 @@
+require "prism"
+
+module ActiveMutator
+  # Deepest fully qualified names of classes/modules a source file defines
+  # ("Billing::Invoice"). Two shorthands are deliberately never emitted,
+  # because either would let a single common token match half of any real
+  # spec suite and trip BaselineDelta's full-run fallback on every edit:
+  #   - bare leaves ("Config" for MyApp::Config)
+  #   - pure namespace wrappers ("MyApp" for `module MyApp; class Config`):
+  #     every file in a namespaced app reopens the top module, and every
+  #     spec mentions it.
+  # A wrapper is a node whose non-empty direct body contains ONLY nested
+  # class/module definitions. A module with its own defs/macros/constants is
+  # a real edit target and IS emitted; so is an empty or def-less leaf class
+  # (macro-only ActiveRecord models).
+  #
+  # Guard is errors.any?, not warnings: Prism produces a complete AST for
+  # warnings-only input (`if a = 2`), and those definitions are real.
+  module DefinedConstants
+    def self.in_source(source)
+      result = Prism.parse(source)
+      return [] if result.errors.any?
+
+      names = []
+      walk(result.value, [], names)
+      names.uniq
+    end
+
+    # The walk intentionally descends into block bodies (unlike SubjectFinder,
+    # which skips them): over-inclusion is the safe direction for spec-file
+    # matching, so a constant defined inside a block is still emitted.
+    def self.walk(node, scope, names)
+      if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+        scope = scope + [node.constant_path.slice]
+        names << scope.join("::") unless namespace_wrapper?(node)
+      end
+      node.compact_child_nodes.each { |child| walk(child, scope, names) }
+    end
+    private_class_method :walk
+
+    def self.namespace_wrapper?(node)
+      statements = node.body.is_a?(Prism::StatementsNode) ? node.body.body : []
+      statements.any? &&
+        statements.all? { |s| s.is_a?(Prism::ClassNode) || s.is_a?(Prism::ModuleNode) }
+    end
+    private_class_method :namespace_wrapper?
+  end
+end

data/lib/active_mutator/edit.rb

@@ -1,5 +1,11 @@
 module ActiveMutator
   # A single mutation as a text edit: replace `range` (exclusive byte Range)
-  # in the original source with `replacement`.
-  Edit = Data.define(:range, :replacement, :description)
+  # in the original source with `replacement`. `operator` is the producing
+  # operator's demodulized class name ("CallSwap"), "Unknown" outside the
+  # operator pipeline.
+  Edit = Data.define(:range, :replacement, :description, :operator) do
+    def initialize(range:, replacement:, description:, operator: "Unknown")
+      super
+    end
+  end
 end

data/lib/active_mutator/engine.rb

@@ -8,7 +8,9 @@ module ActiveMutator
       result = Prism.parse(source)
       raise Error, "#{subject.file} no longer parses" unless result.success?
 
-      def_node = find_def(result.value, subject.byte_range.begin)
+      return analyze_class_body(subject, source, result) if subject.class_body?
+
+      def_node = find_node(result.value, subject.byte_range.begin, Prism::DefNode)
       raise Error, "subject not found: #{subject.name}" unless def_node
 
       invalid = 0
@@ -22,27 +24,139 @@ module ActiveMutator
 
     private
 
-    def find_def(node, start_offset)
-      return node if node.is_a?(Prism::DefNode) && node.location.start_offset == start_offset
+    def analyze_class_body(subject, source, result)
+      class_node = find_node(result.value, subject.byte_range.begin, Prism::ClassNode, Prism::ModuleNode)
+      raise Error, "subject not found: #{subject.name}" unless class_node
+
+      invalid = 0
+      mutations = collect_class_body_edits(class_node).filter_map do |edit|
+        mutation, valid = build_class_body_mutation(subject, source, edit)
+        invalid += 1 unless valid
+        mutation
+      end
+      Analysis.new(mutations: mutations, invalid_count: invalid)
+    end
+
+    # Depth-first search for the node of one of `types` whose byte range starts
+    # at `start_offset`. Def-level and class-body subject location share this;
+    # only the node type(s) differ (DefNode vs Class/ModuleNode).
+    def find_node(node, start_offset, *types)
+      return node if types.any? { |t| node.is_a?(t) } && node.location.start_offset == start_offset
 
       node.compact_child_nodes.each do |child|
-        found = find_def(child, start_offset)
+        found = find_node(child, start_offset, *types)
         return found if found
       end
       nil
     end
 
+    # Class-level code only: defs, nested class/modules and `class << self`
+    # bodies are owned by other subjects. Lambdas (scope bodies, if: procs) ARE
+    # descended, as are the ActiveSupport::Concern DSL blocks (`included`,
+    # `prepended`, `class_methods`) whose bodies re-run as class-level code in
+    # the includer (issue #31). Every OTHER block (association extensions,
+    # custom DSLs that run in an unknown context) stays pruned — mutating those
+    # risks false survivors. Edits that would delete a whole owned statement
+    # (StatementDeletion sees the enclosing StatementsNode) are discarded.
+    # Owned ranges are collected recursively while walking, not just from the
+    # class body's direct children: a def can nest inside class-level control
+    # flow (`if`/`unless`/`begin`), and deleting it there is equally out of
+    # scope.
+    def collect_class_body_edits(class_node)
+      owned = []
+      edits = []
+      class_walk(class_node.body, owned) do |node|
+        @operators.each do |op|
+          edits.concat(op.edits(node))
+        rescue StandardError => e
+          raise Error, "operator #{op.class.name} failed on #{node.class.name}: #{e.message}"
+        end
+      end
+      edits.reject { |e| owned.include?(e.range) }
+    end
+
+    def owned_statement?(node) = ClassShape.owned_by_other_subject?(node)
+
+    # ActiveSupport::Concern DSL calls whose block body re-runs as class-level
+    # code in the includer, so it is in scope for class-body mutation.
+    CONCERN_BLOCK_CALLS = %i[included prepended class_methods].freeze
+
+    def concern_dsl_block?(node)
+      node.is_a?(Prism::CallNode) && node.receiver.nil? &&
+        CONCERN_BLOCK_CALLS.include?(node.name) && node.block.is_a?(Prism::BlockNode)
+    end
+
+    # No nil guard needed (unlike #walk): the entry node is the class body's
+    # StatementsNode, guaranteed present for a class-body subject, and
+    # compact_child_nodes never yields nil.
+    def class_walk(node, owned, &blk)
+      if owned_statement?(node)
+        owned << (node.location.start_offset...node.location.end_offset)
+      elsif node.is_a?(Prism::BlockNode)
+        # Pruned: a block's run-time context is unknown (see collect comment).
+      elsif concern_dsl_block?(node)
+        # Inside a concern block the statements have no subject of their own, so
+        # mutate everything (including nested def bodies) exactly like the
+        # def-level #walk — do NOT recurse via class_walk (it would prune the
+        # block) and do NOT mark the interior defs owned. The concern call node
+        # itself is not yielded: the whole-block deletion edit already comes
+        # from the enclosing StatementsNode, and no operator targets a bare
+        # receiverless call.
+        walk(node.block.body, &blk)
+      else
+        yield node
+        node.compact_child_nodes.each { |child| class_walk(child, owned, &blk) }
+      end
+    end
+
+    # The mutant is the whole file. The def-shaped fields are filled with the
+    # file source so the Mutation shape stays uniform; Worker routes
+    # class-body mutants through ClosureReload (whole-file re-eval), never
+    # through Inserter's class_eval.
+    def build_class_body_mutation(subject, source, edit)
+      original = source.byteslice(edit.range)
+      return [nil, true] if edit.replacement == original # no-op guard
+
+      mutated = Splicer.apply(source, [edit])
+      parsed = Prism.parse(mutated)
+      return [nil, false] unless parsed.success?
+      return [nil, false] unless find_node(parsed.value, subject.byte_range.begin, Prism::ClassNode, Prism::ModuleNode)
+
+      [Mutation.new(
+        subject: subject,
+        edit: edit,
+        original_snippet: original,
+        line: source.byteslice(0, edit.range.begin).count("\n") + 1,
+        mutated_file_source: mutated,
+        mutated_def_source: mutated,
+        mutated_def_line: 1
+      ), true]
+    end
+
     def collect_edits(def_node)
       edits = []
       walk(def_node.body) do |node|
-        @operators.each { |op| edits.concat(op.edits(node)) }
+        @operators.each do |op|
+          edits.concat(op.edits(node))
+        rescue StandardError => e
+          # Fail loud but attributed: a buggy (likely third-party) operator
+          # should point at itself, not surface as a bare crash mid-analysis.
+          raise Error, "operator #{op.class.name} failed on #{node.class.name}: #{e.message}"
+        end
       end
       edits
     end
 
     def walk(node, &blk)
       return if node.nil?
-      return if node.is_a?(Prism::DefNode) # nested defs are separate subjects
+      # Descend into nested DefNodes rather than treating them as separate
+      # subjects. Giving a nested def its own subject identity is a trap:
+      # every call of the outer method re-executes the nested `def`, which
+      # would silently revert a directly-inserted mutant mid-run (phantom
+      # survivors). Instead we mutate the nested body as part of the outer
+      # def's re-evaled source. (SubjectFinder still emits no subject for
+      # nested defs.) walk is called as walk(def_node.body), so the outer
+      # DefNode itself never passes through here.
 
       yield node
       node.compact_child_nodes.each { |child| walk(child, &blk) }
@@ -58,7 +172,7 @@ module ActiveMutator
       parsed = Prism.parse(mutated)
       return [nil, false] unless parsed.success?
 
-      new_def = find_def(parsed.value, subject.byte_range.begin)
+      new_def = find_node(parsed.value, subject.byte_range.begin, Prism::DefNode)
       return [nil, false] unless new_def
 
       [Mutation.new(

data/lib/active_mutator/inserter.rb

@@ -1,13 +1,16 @@
 module ActiveMutator
   # Redefines the subject's method with its mutated source. `class_eval` of a
   # `def` handles instance methods; a `def self.x` source string defines the
-  # singleton method the same way. Top-level subjects eval at main scope.
+  # singleton method the same way. An sclass subject's source is a plain
+  # `def foo` that must land on the constant's singleton class, so we route it
+  # through `.singleton_class.class_eval`. Top-level subjects eval at main scope.
   class Inserter
     def insert(mutation)
       subject = mutation.subject
       if subject.constant_scope
-        Object.const_get(subject.constant_scope)
-              .class_eval(mutation.mutated_def_source, subject.file, mutation.mutated_def_line)
+        target = Object.const_get(subject.constant_scope)
+        target = target.singleton_class if subject.sclass
+        target.class_eval(mutation.mutated_def_source, subject.file, mutation.mutated_def_line)
       else
         eval(mutation.mutated_def_source, TOPLEVEL_BINDING, # rubocop:disable Security/Eval
              subject.file, mutation.mutated_def_line)

data/lib/active_mutator/operators/base.rb

@@ -18,7 +18,8 @@ module ActiveMutator
       def loc_range(loc) = loc.start_offset...loc.end_offset
 
       def edit(range, replacement, description)
-        Edit.new(range: range, replacement: replacement, description: description)
+        Edit.new(range: range, replacement: replacement, description: description,
+                 operator: self.class.name.split("::").last)
       end
     end
   end

data/lib/active_mutator/operators/call_swap.rb

@@ -9,6 +9,22 @@ module ActiveMutator
         min: "max", max: "min",
         first: "last", last: "first",
         any?: "none?", none?: "any?",
+        # all? is one-way: any? already pairs with none?, so all?→any? adds a
+        # distinct mutant without a redundant reverse edge.
+        all?: "any?",
+        take: "drop", drop: "take",
+        min_by: "max_by", max_by: "min_by",
+        # sort→reverse is one-way by design: reverse already has a strong
+        # forward mutant here, and reverse→sort would double-map `reverse`
+        # against nothing useful (reverse has no MAP entry to preserve).
+        sort: "reverse",
+        # detect/find→first is one-way: first ignores the retained block, so
+        # the mutant usually differs (equivalent only when element 0 already
+        # satisfies the predicate). No reverse edge: `first` is taken by
+        # first→last above.
+        detect: "first", find: "first",
+        # Evaluated and rejected: sum (initial-arg arity mismatch),
+        # find_index (no safe partner — rindex is Array-only).
         # Rails-aware pack:
         present?: "blank?", blank?: "present?",
         save: "save!", save!: "save"

data/lib/active_mutator/operators/literal.rb

@@ -23,8 +23,8 @@ module ActiveMutator
 
       def string_edits(node)
         opening = node.opening_loc&.slice
-        return [] unless opening                  # quote-less parts (interpolation)
-        return [] if opening.start_with?("<<")    # heredocs: v1 limit
+        return [] unless opening                # quote-less parts (interpolation)
+        return heredoc_edits(node) if opening.start_with?("<<")
 
         if node.unescaped.empty?
           [edit(loc_range(node.location), %("active_mutator"), %(replace "" with "active_mutator"))]
@@ -32,6 +32,18 @@ module ActiveMutator
           [edit(loc_range(node.location), %(""), %(replace string with ""))]
         end
       end
+
+      # The node span covers the `<<~X` opening token; splicing there breaks
+      # the source. Mutate the body content range instead: nonempty body →
+      # empty heredoc (opening line directly followed by the terminator).
+      # The guard is on the DEDENTED VALUE (unescaped), not content_loc: a
+      # squiggly body that dedents to "" would only lose whitespace bytes —
+      # an equivalent mutant — so it is skipped even though content is nonempty.
+      def heredoc_edits(node)
+        return [] if node.unescaped.empty?
+
+        [edit(loc_range(node.content_loc), "", "empty heredoc body")]
+      end
     end
   end
 end

data/lib/active_mutator/reporter/github.rb

@@ -0,0 +1,36 @@
+module ActiveMutator
+  module Reporter
+    # GitHub Actions workflow-command projection (issue #19): one ::warning
+    # annotation per surviving mutant, inlined on the PR diff. Everything
+    # else mirrors the terminal reporter so CI logs stay readable.
+    class Github
+      def initialize(root:, out: $stdout)
+        @root = root
+        @terminal = Terminal.new(out: out)
+        @out = out
+      end
+
+      def on_result(result) = @terminal.on_result(result)
+
+      def summary(results, invalid_count:)
+        @terminal.summary(results, invalid_count: invalid_count)
+        results.select { |r| r.status == :survived }.each { |r| annotate(r) }
+      end
+
+      private
+
+      def annotate(result)
+        m = result.mutation
+        file = m.subject.file.delete_prefix(@root.chomp("/") + "/")
+        message = "#{m.subject.name}: #{m.description} | - #{m.original_snippet} | + #{m.edit.replacement}"
+        @out.puts "::warning file=#{file},line=#{m.line},title=Surviving mutant::#{encode(message)}"
+      end
+
+      # GitHub workflow commands terminate at a raw newline; percent-encode
+      # per https://github.com/actions/toolkit runner rules.
+      def encode(message)
+        message.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A")
+      end
+    end
+  end
+end

data/lib/active_mutator/reporter/json.rb

@@ -15,6 +15,7 @@ module ActiveMutator
           "score" => Terminal.score(counts),
           "counts" => counts.transform_keys(&:to_s),
           "invalid" => invalid_count,
+          "operators" => OperatorStats.call(results),
           "results" => results.map { |r| serialize(r) },
           "exit_reason" => counts.fetch(:survived, 0).positive? ? "unaccepted_survivors" : "clean"
         )