active_mutator 0.6.1 → 0.7.0

data/lib/active_mutator/runner.rb

@@ -5,63 +5,35 @@ module ActiveMutator
     # What discovery saw, beyond the final subject list. `scanned_files` are
     # root-relative source files after path expansion and excludes, minus
     # spec_paths; `since_candidates` are the --since diff's files among them;
-    # `since_matched_all` are the since-covered subjects before --no-class-level
-    # drops class bodies; `since_filter` is the --since SinceFilter (nil
+    # `since_matched_all` are the since-covered subjects before --subject and
+    # --no-class-level narrow them; `since_filter` is the --since SinceFilter (nil
     # without --since). The last three feed the --allow-empty verdict (#46).
     Discovery = Data.define(:subjects, :scanned_files, :since_candidates, :since_matched_all, :since_filter)
 
-    def initialize(config, reporter: nil)
+    SIGNALS = { "INT" => :sigint, "TERM" => :sigterm }.freeze
+    # An aborted run never passes, whatever --fail-at says.
+    EXIT_CODES = { sigint: 130, sigterm: 143, memory_ceiling: 3 }.freeze
+
+    def initialize(config, reporter: nil, events: nil)
       @config = config
       @reporter = reporter || build_reporter
+      @events = events || build_events
+      @abort = AbortFlag.new
     end
 
+    # The traps go in first so boot, planning, and the baseline are covered
+    # too, and come out last so the host gets its own handlers back.
     def call
-      ENV["ACTIVE_MUTATOR"] = "1"
-      load_operators
-      ClosureReload.cap = @config.class_level_closure_cap
-      preload!
-      preload_spec_helper!
-      discovery = discover
-      subjects = discovery.subjects
-      analyses = subjects.map { |s| Engine.new.analyze(s) }
-      mutations = analyses.flat_map(&:mutations)
-      mutations = mutations.first(@config.max_mutants) if @config.max_mutants
-      invalid_count = analyses.sum(&:invalid_count)
-      # Decide emptiness before the baseline: a scoped run that plans nothing
-      # has no use for a coverage map, and building one spawns the whole spec
-      # suite (#47).
-      if mutations.empty? && (@config.since || @config.subject_filter)
-        return debug_plan([], []) if @config.debug_plan
-
-        return empty_plan_exit(invalid_count, discovery)
-      end
-
-      map = Baseline.new(root: @config.root, spec_paths: @config.spec_paths)
-              .coverage_map(force: @config.force_baseline)
-      @reporter.coverage_map = map if @reporter.respond_to?(:coverage_map=)
-
-      fingerprints = Fingerprint.for_mutations(mutations, root: @config.root)
-      ledger = AcceptedLedger.load(@config.root)
-      scanned_files = prune_scope(subjects)
-      warn_stale(ledger, fingerprints.values, scanned_files)
-
-      items, pre_results, phase1_ids = plan_work(mutations, map, ledger: ledger, fingerprints: fingerprints)
-      return debug_plan(items, pre_results) if @config.debug_plan
-
-      pre_results.each { |r| @reporter.on_result(r) }
-      calibrators = if @config.adaptive_timeout
-                      { parallel: TimeoutCalibrator.new, serial: TimeoutCalibrator.new }
-                    end
-      scheduler = Scheduler.new(jobs: @config.jobs, on_result: @reporter.method(:on_result),
-                                calibrators: calibrators)
-      results = scheduler.run(items) + pre_results
-      # Phase 2 runs on its own scheduler (built lazily inside), so pass nil.
-      results = escalate_class_body_survivors(results, nil, map, phase1_ids: phase1_ids)
-
-      accept_survivors!(ledger, results, fingerprints, scanned_files) if @config.accept_survivors
-
-      @reporter.summary(results, invalid_count: invalid_count)
-      exit_code(results)
+      previous_traps = trap_signals
+      events_file = open_events_file
+      sampler = start_sampler
+      run
+    rescue Aborted => e
+      aborted_exit(e)
+    ensure
+      sampler&.stop
+      events_file&.close
+      restore_traps(previous_traps)
     end
 
     # Returns [work_items, pre_results, phase1_ids]. phase1_ids maps each
@@ -122,8 +94,16 @@ module ActiveMutator
       end
       return results if items.empty?
 
-      scheduler ||= Scheduler.new(jobs: @config.jobs)
-      escalated = scheduler.run(items.values).to_h { |res| [res.mutation, res] }
+      # Numbered after phase 1's mutants, so seq stays unique across the run.
+      scheduler ||= Scheduler.new(jobs: @config.jobs, events: @events, first_seq: phase1_ids.size + 1, abort: @abort)
+      escalated = begin
+        @events.phase(:escalating, mutants: items.size) do
+          scheduler.run(items.values).to_h { |res| [res.mutation, res] }
+        end
+      rescue Aborted => e
+        # Every phase-1 verdict is final; a half-done escalation proves nothing.
+        raise e.with_results(results)
+      end
       results.map do |r|
         # A replacement only ever exists for a survived candidate (items is
         # built solely from those), so no redundant status re-check is needed.
@@ -158,12 +138,116 @@ module ActiveMutator
 
     private
 
+    def run
+      @events.phase(:boot) { boot! }
+      discovery, analyses = @events.phase(:planning) do
+        found = discover
+        [found, found.subjects.map { |s| Engine.new.analyze(s) }]
+      end
+      subjects = discovery.subjects
+      mutations = analyses.flat_map(&:mutations)
+      mutations = mutations.first(@config.max_mutants) if @config.max_mutants
+      @planned = mutations.size
+      @invalid_count = analyses.sum(&:invalid_count)
+      # Decide emptiness before the baseline: a scoped run that plans nothing
+      # has no use for a coverage map, and building one spawns the whole spec
+      # suite (#47).
+      if mutations.empty? && (@config.since || @config.subject_filter)
+        return debug_plan([], []) if @config.debug_plan
+
+        return empty_plan_exit(@invalid_count, discovery)
+      end
+
+      map = Baseline.new(root: @config.root, spec_paths: @config.spec_paths, events: @events, abort: @abort)
+              .coverage_map(force: @config.force_baseline)
+      @reporter.coverage_map = map if @reporter.respond_to?(:coverage_map=)
+
+      fingerprints = Fingerprint.for_mutations(mutations, root: @config.root)
+      ledger = AcceptedLedger.load(@config.root)
+      scanned_files = prune_scope(subjects)
+      warn_stale(ledger, fingerprints.values, scanned_files)
+
+      items, pre_results, phase1_ids = plan_work(mutations, map, ledger: ledger, fingerprints: fingerprints)
+      return debug_plan(items, pre_results) if @config.debug_plan
+
+      # From here on a trip only records its reason. Raised at once, it could
+      # land between two steps (the sample as mutating ends, the spec reads
+      # before escalation) and drop every finished verdict. Each step checks
+      # the flag instead and raises with the results it has.
+      results = @abort.deferred do
+        done = @events.phase(:mutating, mutants: items.size) { mutate(items, pre_results) }
+        stop_if_tripped!(done)
+        # Phase 2 runs on its own scheduler (built lazily inside), so pass nil.
+        done = escalate_class_body_survivors(done, nil, map, phase1_ids: phase1_ids)
+        stop_if_tripped!(done)
+
+        reporting(done) do
+          accept_survivors!(ledger, done, fingerprints, scanned_files) if @config.accept_survivors
+          @reporter.summary(done, invalid_count: @invalid_count)
+        end
+        done
+      end
+      exit_code(results)
+    end
+
+    def mutate(items, pre_results)
+      pre_results.each { |r| @reporter.on_result(r) }
+      calibrators = if @config.adaptive_timeout
+                      { parallel: TimeoutCalibrator.new, serial: TimeoutCalibrator.new }
+                    end
+      scheduler = Scheduler.new(jobs: @config.jobs, on_result: @reporter.method(:on_result),
+                                calibrators: calibrators, events: @events, abort: @abort)
+      scheduler.run(items) + pre_results
+    rescue Aborted => e
+      raise e.with_results(e.results + pre_results)
+    end
+
+    # The trap only trips the flag: no I/O is safe inside a handler. The
+    # main loop does the killing and raises Aborted.
+    def trap_signals
+      SIGNALS.to_h { |sig, reason| [sig, trap(sig) { @abort.trip!(reason) }] }
+    end
+
+    # Passed back as is: a nil handler means the host ignored the signal.
+    def restore_traps(previous)
+      previous.each { |sig, handler| trap(sig, handler) }
+    end
+
+    # No --accept-survivors here: a partial run must not rewrite the ledger.
+    # Once the report starts, a signal only records its reason: the report
+    # finishes, and `--format json` stays one document. The run still exits
+    # as aborted, so a memory breach or a CI cancel never passes.
+    def reporting(results = [], &)
+      @abort.deferred do
+        @reported = true
+        @events.phase(:reporting, &)
+      end
+      stop_if_tripped!(results)
+    end
+
+    def stop_if_tripped!(results)
+      raise Aborted.new(@abort.reason, results: results) if @abort.tripped?
+    end
+
+    # No summary if the full one already went out: a signal landing after
+    # the report would otherwise print a second one.
+    def aborted_exit(error)
+      counts = Reporter::Terminal.counts(error.results)
+      @events.emit(:abort, reason: error.reason, in_flight: error.in_flight, planned: @planned,
+                           counts: counts, score: error.results.empty? ? nil : Reporter::Terminal.score(counts))
+      unless @reported
+        @reporter.summary(error.results, invalid_count: @invalid_count || 0,
+                                         aborted: { reason: error.reason, in_flight: error.in_flight, planned: @planned })
+      end
+      EXIT_CODES.fetch(error.reason)
+    end
+
     # A scoped run that plans nothing must not report "100%" and pass --fail-at:
     # the usual cause is a --since range or --subject filter that matched no
     # mutable code, or class-body code dropped by --no-class-level (#23 covers
     # the zero-subject case for explicit paths).
     def empty_plan_exit(invalid_count, discovery)
-      @reporter.summary([], invalid_count: invalid_count, empty_plan: true)
+      reporting { @reporter.summary([], invalid_count: invalid_count, empty_plan: true) }
       causes = []
       causes << "--since #{@config.since} matched no mutable code" if @config.since
       causes << "--subject #{@config.subject_filter} matched no subjects" if @config.subject_filter
@@ -178,20 +262,29 @@ module ActiveMutator
     end
 
     # --allow-empty forgives an empty plan only when the --since diff touched no
-    # candidate source file (docs-only, spec-only, excluded paths) or changed
-    # only comments in them. A candidate whose code changed but planned
+    # candidate source file (docs-only, spec-only, excluded paths), changed
+    # only comments in them, or deleted code no subject spans (a removed
+    # method). A candidate whose code changed but planned
     # nothing is the case worth failing on, unless the only code it touched
     # is class-body code that --no-class-level dropped. --subject alone has no
     # diff to judge, so it stays an unconditional 0.
     def allow_empty_exit(discovery)
       return 0 unless @config.since
-      return 0 if discovery.since_candidates.empty?
 
+      filter = discovery.since_filter
+      matched_files = discovery.since_matched_all.map { |s| relative(s.file) }
+      # A deletion no subject spans leaves nothing to mutate. One inside a
+      # subject that still planned nothing falls through to the checks below.
+      deleted = discovery.since_candidates.select do |file|
+        filter.deletion_only?(file) && !matched_files.include?(file) &&
+          Prism.parse_file(File.join(@config.root, file)).success?
+      end
       # Checked only here, on the empty-plan path: it runs `git show` per file.
-      candidates = discovery.since_candidates.reject { |file| discovery.since_filter.comment_only?(file) }
+      commented = (discovery.since_candidates - deleted).select { |f| filter.comment_only?(f) }
+      candidates = discovery.since_candidates - deleted - commented
       if candidates.empty?
-        warn "active_mutator: forgiving empty plan: only comments changed in " \
-             "#{discovery.since_candidates.join(", ")}"
+        warn "active_mutator: forgiving empty plan: deletions in #{deleted.join(", ")} left no method to mutate" if deleted.any?
+        warn "active_mutator: forgiving empty plan: only comments changed in #{commented.join(", ")}" if commented.any?
         return 0
       end
 
@@ -247,6 +340,14 @@ module ActiveMutator
       end.flatten.uniq.sort
     end
 
+    def boot!
+      ENV["ACTIVE_MUTATOR"] = "1"
+      load_operators
+      ClosureReload.cap = @config.class_level_closure_cap
+      preload!
+      preload_spec_helper!
+    end
+
     # Custom operators must exist in the PARENT before Engine analysis:
     # subclassing Operators::Base self-registers, and forks inherit the
     # loaded class. `requires` can't serve — those load inside the fork's
@@ -286,6 +387,41 @@ module ActiveMutator
       @config.spec_paths.map { |sp| "#{sp}/#{rest}_spec.rb" }
     end
 
+    # Only when something reads the samples. Subscribed last, so each phase
+    # line prints before the sample taken at it.
+    def start_sampler
+      watch_memory if @config.max_rss
+      return unless @events.listening?
+
+      sampler = Sampler.new(events: @events, interval: @config.sample_interval)
+      @events.subscribe(sampler)
+      sampler.start
+    end
+
+    # Without --diagnostics, the 90% warning and the breach still reach stderr.
+    def watch_memory
+      notices = %i[memory_warning memory_ceiling]
+      @events.subscribe(Diagnostics::Text.new(root: @config.root, only: notices)) unless @config.diagnostics
+      @events.subscribe(MemoryCeiling.new(max_rss_kb: @config.max_rss, events: @events, abort: @abort))
+    end
+
+    # Opened per call, not per Runner, so the file is closed on every exit.
+    def open_events_file
+      return unless @config.events_file
+
+      file = File.open(File.expand_path(@config.events_file, @config.root), "w")
+      @events.subscribe(Diagnostics::Ndjson.new(file))
+      file
+    rescue SystemCallError => e
+      raise Error, "cannot write --events file: #{e.message}"
+    end
+
+    def build_events
+      events = Events.new
+      events.subscribe(Diagnostics::Text.new(root: @config.root)) if @config.diagnostics
+      events
+    end
+
     def build_reporter
       case @config.format
       when :json then Reporter::Json.new
@@ -316,18 +452,17 @@ module ActiveMutator
         .sort
       scanned_files = files.map { |f| relative(f) }.reject { |rel| under_spec_paths?(rel) }
       subjects = files.flat_map { |file| SubjectFinder.call(file) }
-      if @config.subject_filter
-        matcher = SubjectMatcher.new(@config.subject_filter)
-        subjects = subjects.select { |s| matcher.match?(s.name) }
-      end
       since_candidates = []
       if @config.since
         filter = SinceFilter.new(ref: @config.since, root: @config.root)
         subjects = subjects.select { |s| filter.cover?(s) }
         since_candidates = filter.changed_files & scanned_files
       end
-      # Class bodies drop out LAST so since_matched_all still knows about them.
       since_matched_all = subjects
+      if @config.subject_filter
+        matcher = SubjectMatcher.new(@config.subject_filter)
+        subjects = subjects.select { |s| matcher.match?(s.name) }
+      end
       subjects = subjects.reject(&:class_body?) unless @config.class_level
       Discovery.new(subjects: subjects, scanned_files: scanned_files,
                     since_candidates: since_candidates, since_matched_all: since_matched_all,

data/lib/active_mutator/sampler.rb

@@ -0,0 +1,69 @@
+module ActiveMutator
+  # Samples the gem's own memory: the parent, every live worker, and the
+  # baseline child. Either side alone tells half the story (0.6.0 died in
+  # the parent, right after the child). It learns worker and child pids from
+  # the event stream, samples at every phase boundary, and, once started,
+  # every `interval` seconds on its own thread. That thread only reads files
+  # and emits, so forks from the main thread stay safe: a fork copies only
+  # the calling thread.
+  class Sampler
+    def initialize(events:, interval:, probe: MemoryProbe.new, parent_pid: Process.pid)
+      @events = events
+      @interval = interval
+      @probe = probe
+      @parent_pid = parent_pid
+      @workers = {} # pid => seq
+      @lock = Mutex.new
+    end
+
+    # Events listener: follows pids, and samples at each phase boundary.
+    def call(event)
+      fields = event.fields
+      case event.type
+      when :mutant_start then @lock.synchronize { @workers[fields[:pid]] = fields[:seq] }
+      when :mutant_end then @lock.synchronize { @workers.delete(fields[:pid]) }
+      when :phase_start, :phase_end
+        follow_baseline(fields) if fields[:phase] == :baseline
+        tick
+      end
+    end
+
+    # One sample, emitted as a `memory` event. Returns the total in KB (Pss
+    # where the platform has it, else RSS, which overcounts shared pages),
+    # nil when nothing could be read. Public so specs call it directly.
+    def tick
+      workers, baseline_pid = @lock.synchronize { [@workers.dup, @baseline_pid] }
+      readings = @probe.processes([@parent_pid, *workers.keys, baseline_pid].compact)
+      live = workers.filter_map { |pid, seq| readings[pid]&.then { |r| { pid: pid, seq: seq, **sizes(r) } } }
+      baseline = readings[baseline_pid]&.then { |r| { pid: baseline_pid, **sizes(r) } }
+      total = readings.empty? ? nil : readings.each_value.sum { |r| r[:pss_kb] || r[:rss_kb] }
+      @events.emit(:memory, parent: readings[@parent_pid]&.then { |r| sizes(r) }, workers: live,
+                            baseline: baseline, total_pss_kb: total, system: @probe.system)
+      total
+    end
+
+    def start
+      @thread = Thread.new do
+        loop do
+          sleep @interval
+          tick
+        end
+      end
+      self
+    end
+
+    def stop
+      @thread&.kill&.join
+    end
+
+    private
+
+    # phase_start carries the child's pid; phase_end carries none, so it
+    # clears it.
+    def follow_baseline(fields)
+      @lock.synchronize { @baseline_pid = fields[:pid] }
+    end
+
+    def sizes(reading) = reading.slice(:rss_kb, :pss_kb)
+  end
+end

data/lib/active_mutator/scheduler.rb

@@ -8,43 +8,63 @@ module ActiveMutator
   class Scheduler
     OrphanedError = Class.new(Error)
 
+    # first_seq: phase-2 escalation runs on its own scheduler; starting its
+    # sequence after phase 1's keeps mutant numbers unique across the run.
     def initialize(jobs:, worker: Worker.method(:run), on_result: nil,
-                   calibrators: nil, orphaned: -> { Process.ppid == 1 })
+                   calibrators: nil, orphaned: -> { Process.ppid == 1 },
+                   events: Events.new, first_seq: 1, abort: AbortFlag.new)
+      @abort = abort
       @jobs = jobs
       @worker = worker
       @on_result = on_result
       @calibrators = calibrators
       @orphaned = orphaned
+      @events = events
+      @next_seq = first_seq
       @last_logged_scale = {} # lane => last scale logged for that lane
     end
 
+    # Signals are the Runner's: its AbortFlag trips, and the poll loop here
+    # kills every worker and raises Aborted with what finished.
     def run(items)
-      previous_traps = nil
       running = {}
-      previous_traps = install_signal_handlers(running)
       results = []
-      # Browser-covered mutants each boot Chrome + an app server; running them
-      # concurrently melts CPUs and manufactures false timeouts. Parallel lane
-      # first at full width, then the serial lane one at a time.
-      results.concat(run_pool(items.select { |i| i.lane == :parallel }, @jobs, running))
-      results.concat(run_pool(items.select { |i| i.lane == :serial }, 1, running))
+      @abort.deferred do
+        # Browser-covered mutants each boot Chrome + an app server; running
+        # them concurrently melts CPUs and manufactures false timeouts.
+        # Parallel lane first at full width, then the serial lane one at a time.
+        run_pool(items.select { |i| i.lane == :parallel }, @jobs, running, results)
+        run_pool(items.select { |i| i.lane == :serial }, 1, running, results)
+      end
       results
     ensure
-      restore_traps(previous_traps) if previous_traps
+      cleanup(running)
     end
 
     private
 
-    def run_pool(items, width, running)
+    def run_pool(items, width, running, results)
       queue = items.dup
-      results = []
       until queue.empty? && running.empty?
         abort_if_orphaned!(running)
-        spawn(queue.shift, running) while running.size < width && !queue.empty?
+        abort!(running, results) if @abort.tripped?
+        # A trip mid-fill stops the forking; the next pass kills what started.
+        spawn(queue.shift, running) while running.size < width && !queue.empty? && !@abort.tripped?
         reap(running, results)
         sleep 0.02 unless running.empty?
       end
-      results
+    end
+
+    # CI allows only seconds between SIGTERM and SIGKILL, so kill every
+    # worker group and move on without waiting for any of them.
+    def abort!(running, results)
+      in_flight = running.map do |pid, entry|
+        m = entry[:item].mutation
+        { seq: entry[:seq], pid: pid, subject: m.subject.name, file: m.subject.file, line: m.line,
+          description: m.description }
+      end
+      cleanup(running, wait: false)
+      raise Aborted.new(@abort.reason, results: results, in_flight: in_flight)
     end
 
     # SIGKILL on the parent (or a closed terminal, or CI teardown) cannot be
@@ -54,18 +74,27 @@ module ActiveMutator
     def abort_if_orphaned!(running)
       return unless @orphaned.call
 
-      running.each_key do |pid|
-        kill(pid)
-      rescue StandardError
+      raise OrphanedError, "parent process died; aborting mutation run"
+    end
+
+    def cleanup(running, wait: true)
+      running.each_key { |pid| signal_group(pid) }
+      running.each do |pid, entry|
+        entry[:reader].close
+        entry[:stderr_file].close!
+        Process.waitpid(pid) if wait
+      rescue Errno::ECHILD
         nil
       end
       running.clear
-      raise OrphanedError, "parent process died; aborting mutation run"
     end
 
     STDERR_TAIL_LINES = 20
 
     def spawn(item, running)
+      calibrator = calibrator_for(item)
+      budget = calibrator ? calibrator.budget_for(item) : item.timeout
+      log_scale(calibrator, item.lane)
       reader, writer = IO.pipe
       stderr_file = Tempfile.new("active_mutator-worker")
       pid = fork do
@@ -78,55 +107,86 @@ module ActiveMutator
         # harmless everywhere else.
         ENV["PGGSSENCMODE"] ||= "disable"
         @worker.call(item.mutation, item.example_ids, writer)
+        # A second line, after the worker's own report: the worker can exit
+        # between two memory samples, so it reports its peak itself.
+        writer.puts("", JSON.generate("peak_rss_kb" => MemoryProbe.peak_rss_kb))
         writer.close
         Process.exit!(0)
       end
       writer.close
-      calibrator = calibrator_for(item)
-      budget = calibrator ? calibrator.budget_for(item) : item.timeout
-      log_scale(calibrator, item.lane)
       started = now
+      seq = @next_seq
+      @next_seq += 1
       running[pid] = { reader: reader, item: item, started: started, stderr_file: stderr_file,
-                       budget: budget, deadline: started + budget }
+                       budget: budget, deadline: started + budget, seq: seq, payload: +"" }
+      emit_start(item, pid, seq, budget) if @events.listening?
+    ensure
+      unless pid
+        reader&.close
+        writer&.close
+        stderr_file&.close!
+      end
+    end
+
+    def emit_start(item, pid, seq, budget)
+      m = item.mutation
+      @events.emit(:mutant_start, seq: seq, pid: pid, lane: item.lane, budget: budget,
+                                  examples: item.example_ids.size, subject: m.subject.name,
+                                  file: m.subject.file, line: m.line, description: m.description)
     end
 
     def reap(running, results)
       running.to_a.each do |pid, entry|
-        done, _status = Process.waitpid2(pid, Process::WNOHANG)
-        if done
-          running.delete(pid)
+        # Read while the worker runs so a full pipe cannot prevent its exit.
+        # A descendant may retain the writer after that exit; keep the group
+        # tracked until EOF so aborts and the deadline still apply to it.
+        chunk = entry[:reader].read_nonblock(65_536, exception: false)
+        entry[:payload] << chunk if chunk.is_a?(String)
+        entry[:eof] = true if chunk.nil?
+        entry[:exited] ||= Process.waitpid(pid, Process::WNOHANG)
+        if entry[:exited] && entry[:eof]
           result = finish(entry)
-          if result.status == :killed
-            calibrator_for(entry[:item])&.record(now - entry[:started], entry[:budget])
-          end
-          results << result
+          calibrator_for(entry[:item])&.record(result.seconds, entry[:budget]) if result.status == :killed
+          results << complete(pid, entry, result)
+          running.delete(pid)
         elsif now > entry[:deadline]
           kill(pid)
-          running.delete(pid)
           entry[:reader].close
           entry[:stderr_file].close!
-          details = format("timed out after %.1fs (budget %.1fs)", now - entry[:started], entry[:budget])
-          results << report(Result.new(mutation: entry[:item].mutation, status: :timeout, details: details))
+          seconds = now - entry[:started]
+          details = format("timed out after %.1fs (budget %.1fs)", seconds, entry[:budget])
+          results << complete(pid, entry, Result.new(mutation: entry[:item].mutation, status: :timeout,
+                                                     details: details, seconds: seconds))
+          running.delete(pid)
         end
       end
     end
 
     def finish(entry)
-      payload = entry[:reader].read.to_s
+      seconds = now - entry[:started]
+      report_line, stats_line = entry[:payload].lines.map(&:strip).reject(&:empty?)
       entry[:reader].close
       stderr_tail = stderr_tail(entry[:stderr_file])
-      data = payload.empty? ? nil : JSON.parse(payload)
+      data = report_line && JSON.parse(report_line)
       # A self-mutation of Worker#emit can produce well-formed JSON without a
       # "status" key (or with a non-Hash root); treat any unusable payload as
       # a worker error instead of crashing the whole run.
       reported = data.is_a?(Hash) && data.key?("status")
       status = reported ? data["status"].to_sym : :error
       details = reported ? data["details"] : unreported_details(stderr_tail)
+      peak = JSON.parse(stats_line)["peak_rss_kb"] if stats_line
     rescue JSON::ParserError
-      report(Result.new(mutation: entry[:item].mutation, status: :error,
-                        details: "worker emitted unparseable payload"))
+      Result.new(mutation: entry[:item].mutation, status: :error,
+                 details: "worker emitted unparseable payload", seconds: seconds)
     else
-      report(Result.new(mutation: entry[:item].mutation, status: status, details: details))
+      Result.new(mutation: entry[:item].mutation, status: status, details: details,
+                 seconds: seconds, peak_rss_kb: peak)
+    end
+
+    def complete(pid, entry, result)
+      @events.emit(:mutant_end, seq: entry[:seq], pid: pid, status: result.status,
+                                seconds: result.seconds, peak_rss_kb: result.peak_rss_kb)
+      report(result)
     end
 
     def report(result)
@@ -149,14 +209,7 @@ module ActiveMutator
     end
 
     def kill(pid)
-      Process.kill("KILL", -pid) # negative pid = whole process group
-    rescue Errno::ESRCH, Errno::EPERM
-      # Group not established yet (setpgid race) or already gone: direct kill.
-      begin
-        Process.kill("KILL", pid)
-      rescue Errno::ESRCH
-        nil
-      end
+      signal_group(pid)
     ensure
       begin
         Process.waitpid(pid)
@@ -165,26 +218,17 @@ module ActiveMutator
       end
     end
 
-    # Returns {sig => previous_handler} so #run can restore on exit,
-    # otherwise our traps permanently replace the host's (e.g. RSpec's Ctrl-C).
-    def install_signal_handlers(running)
-      %w[INT TERM].to_h do |sig|
-        previous = trap(sig) do
-          running.each_key do |pid|
-            Process.kill("KILL", -pid)
-          rescue StandardError
-            nil
-          end
-          exit(130)
-        end
-        [sig, previous]
+    def signal_group(pid)
+      Process.kill("KILL", -pid) # negative pid = whole process group
+    rescue Errno::ESRCH, Errno::EPERM
+      # Group not established yet (setpgid race) or already gone: direct kill.
+      begin
+        Process.kill("KILL", pid)
+      rescue Errno::ESRCH
+        nil
       end
     end
 
-    def restore_traps(previous)
-      previous.each { |sig, handler| trap(sig, handler || "DEFAULT") }
-    end
-
     def calibrator_for(item)
       @calibrators && @calibrators[item.lane]
     end