evilution 0.33.0 → 0.34.0

data/lib/evilution/coverage/recorder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../coverage"
+require_relative "map"
+
+# Wraps each example with a before/after coverage diff and attributes the
+# newly-executed lines (in target files only) to that example's location.
+# coverage_source is injected for testability; in production it is
+# -> { ::Coverage.peek_result }.
+class Evilution::Coverage::Recorder
+  def initialize(target_files:, coverage_source: -> { ::Coverage.peek_result })
+    @target_files = target_files.to_a
+    @coverage_source = coverage_source
+    @index = Hash.new { |h, file| h[file] = Hash.new { |g, line| g[line] = [] } }
+    @executed = Hash.new { |h, file| h[file] = [] }
+  end
+
+  def around_example(example_location)
+    before = snapshot
+    result = yield
+    after = snapshot
+    attribute(before, after, example_location)
+    result
+  end
+
+  def to_map(built_files:)
+    Evilution::Coverage::Map.new(
+      index: materialize(@index),
+      built_files: built_files,
+      executed_lines: @executed.transform_values(&:uniq)
+    )
+  end
+
+  private
+
+  def snapshot
+    @coverage_source.call || {}
+  end
+
+  def attribute(before, after, example_location)
+    @target_files.each do |file|
+      after_counts = line_counts(after[file])
+      next unless after_counts
+
+      record_executed(file, after_counts)
+      record_increases(file, line_counts(before[file]) || [], after_counts, example_location)
+    end
+  end
+
+  # Every line with a non-zero count in the after-snapshot has run at least once
+  # by now -- including lines covered only at load (a `def` line is already > 0
+  # in the first example's after-snapshot). Recording them lets the Map tell a
+  # load-covered line from a line that never ran.
+  def record_executed(file, after_counts)
+    after_counts.each_with_index do |count, idx|
+      next if count.nil? || count.zero?
+
+      @executed[file] << (idx + 1)
+    end
+  end
+
+  # Credit example_location with every line whose execution count rose between
+  # the before/after snapshots (a newly-executed, executable line).
+  def record_increases(file, before_counts, after_counts, example_location)
+    after_counts.each_with_index do |count, idx|
+      next if count.nil? || count.zero?
+      next unless count > (before_counts[idx] || 0)
+
+      @index[file][idx + 1] << example_location
+    end
+  end
+
+  # Coverage.peek_result yields per-file line counts either as a bare array
+  # (legacy Coverage.start) or as a { lines: [...] } hash (Coverage.start with
+  # lines:/branches:/methods: modes). Normalize to the bare counts array.
+  def line_counts(entry)
+    entry.is_a?(Hash) ? entry[:lines] : entry
+  end
+
+  def materialize(index)
+    index.each_with_object({}) do |(file, lines), out|
+      out[file] = lines.each_with_object({}) { |(line, locs), inner| inner[line] = locs }
+    end
+  end
+end

data/lib/evilution/coverage.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "../evilution"
+
+# Per-example line-coverage support: build a `source file:line -> [examples]`
+# map so mutation targeting can run exactly the examples that execute a line.
+module Evilution::Coverage
+end

data/lib/evilution/coverage_example_filter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../evilution"
+require_relative "coverage/map"
+
+# Per-mutation example targeting backed by a real line-coverage Map (EV-ndjd).
+# Honours the same contract as the lexical Evilution::ExampleFilter --
+# call(mutation, spec_paths) -> Array[location] | spec_paths | nil -- so it drops
+# straight into the existing ExampleFilter seam.
+#
+# Resolution order for the mutated source file F at line L:
+#   - F not fully built in the map (digest miss / partial build) -> delegate to
+#     the lexical filter (safe fallback) with the original spec_paths.
+#   - F built and L covered by examples -> run exactly those covering examples
+#     (a SUBSET of what the resolved spec runs, so a strict speedup that cannot
+#     lose a kill full-file would catch).
+#   - F not built, or L attributed to no example -> defer to lexical/full-file.
+#
+# Accuracy-first: coverage ONLY narrows the example set when it positively knows
+# the covering examples. It never marks a mutation :unresolved on "no coverage" --
+# on real repos a line can be exercised indirectly (before(:all), load time, a
+# spec the per-example diff did not attribute), and asserting a gap there loses
+# kills (EV-7uui validation). When coverage has no answer, the proven lexical
+# path decides.
+class Evilution::CoverageExampleFilter
+  def initialize(map:, lexical:, project_root: Evilution::PROJECT_ROOT)
+    @map = map
+    @lexical = lexical
+    @project_root = project_root.to_s
+  end
+
+  def call(mutation, spec_paths)
+    file = File.expand_path(mutation.file_path, @project_root)
+    return @lexical.call(mutation, spec_paths) unless @map.built?(file)
+
+    examples = @map.examples_for(file, mutation.line)
+    return examples unless examples.empty?
+
+    @lexical.call(mutation, spec_paths)
+  end
+end

data/lib/evilution/isolation/fork.rb

@@ -5,7 +5,7 @@ require "tmpdir"
 require_relative "../memory"
 require_relative "../temp_dir_tracker"
 require_relative "../child_output"
-require_relative "../process_cleanup"
+require_relative "../process_supervisor"
 
 require_relative "../isolation"
 
@@ -15,21 +15,25 @@ class Evilution::Isolation::Fork
 
   def initialize(hooks: nil)
     @hooks = hooks
+    # EV-3aw3 / EV-5rrh step 2: the supervisor owns this path's lifecycle --
+    # spawn + process-group isolation, the TERM/grace/KILL ladder, and reap +
+    # sandbox removal. fork.rb keeps only the marshal-pipe read protocol.
+    @supervisor = Evilution::ProcessSupervisor.new
   end
 
   def call(mutation:, test_command:, timeout:)
-    pid = nil
+    handle = nil
     sandbox_dir = Dir.mktmpdir("evilution-run")
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     parent_rss = Evilution::Memory.rss_kb
     read_io, write_io = binary_pipe
-    pid = fork_child(read_io, write_io, sandbox_dir, mutation, test_command)
+    handle = spawn_child(read_io, write_io, sandbox_dir, mutation, test_command)
     write_io.close
-    result = wait_for_result(pid, read_io, timeout)
+    result = wait_for_result(handle, read_io, timeout)
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
     build_mutation_result(mutation, result, duration, parent_rss)
   ensure
-    cleanup_resources(read_io, write_io, pid, sandbox_dir)
+    cleanup_resources(read_io, write_io, handle, sandbox_dir)
   end
 
   private
@@ -46,14 +50,18 @@ class Evilution::Isolation::Fork
     [read_io, write_io]
   end
 
-  def fork_child(read_io, write_io, sandbox_dir, mutation, test_command)
-    ::Process.fork do
-      isolate_into_own_process_group
+  # Supervisor.spawn makes the child its own process-group leader (setpgid)
+  # before this block runs, so any grandchildren test_command forks inherit the
+  # group and the TERM/KILL ladder sweeps the whole subtree on timeout (EV-2sh8
+  # / GH #1330). The block keeps the marshal-pipe protocol: write a
+  # length-prefixed payload, then exit with the pass/fail code.
+  def spawn_child(read_io, write_io, sandbox_dir, mutation, test_command)
+    @supervisor.spawn(sandbox_dir: sandbox_dir) do
       ENV["TMPDIR"] = sandbox_dir
       # Path-relativizing mutations (e.g. File.join(dir, name) -> name) would
       # otherwise write into the parent's CWD (typically the repo root) and
       # leak past the run. chdir here keeps such writes inside sandbox_dir,
-      # which the ensure block of #call removes. The in_isolated_worker! flag
+      # which the supervisor removes on reap. The in_isolated_worker! flag
       # signals the rest of evilution (SpecResolver/SpecSelector/SpecAstCache/
       # MutationApplier/SourceEvaluator/Integration) to anchor project-relative
       # paths to Evilution::PROJECT_ROOT instead of the sandbox CWD.
@@ -71,27 +79,20 @@ class Evilution::Isolation::Fork
     end
   end
 
-  # EV-2sh8 / GH #1330: make the mutation child its own process-group leader as
-  # its very first act, before it runs test_command (which may fork blocking
-  # grandchildren -- e.g. connection_pool / ractor / thread subject specs).
-  # Grandchildren then inherit this group, so terminate_child can group-kill the
-  # whole subtree on timeout. Without it, a blocking grandchild orphans to init
-  # and survives the rest of the run -- the inner path never SIGKILLs the worker,
-  # so EV-cnx8's outer process-group kill never sweeps it. Done child-side (not
-  # parent-side as in Worker) because the per-mutation timeout fires seconds
-  # later, long after this line has run, so no fork-before-setpgid race exists.
-  def isolate_into_own_process_group
-    ::Process.setpgid(0, 0)
-  rescue SystemCallError
-    nil
-  end
-
-  def cleanup_resources(read_io, write_io, pid, sandbox_dir)
+  # The parent owns read_io/write_io (write_io is closed right after spawn so
+  # read_io can see EOF), so they are closed here rather than handed to the
+  # supervisor. The supervisor reaps the child and removes the sandbox dir; on
+  # the early-failure path (binary_pipe raised before spawn) handle is nil, so
+  # the orphaned sandbox is removed directly.
+  def cleanup_resources(read_io, write_io, handle, sandbox_dir)
     read_io.close unless read_io.nil?
     write_io.close unless write_io.nil?
-    ensure_reaped(pid)
+    if handle
+      @supervisor.terminate(handle, grace: GRACE_PERIOD)
+    elsif sandbox_dir
+      FileUtils.rm_rf(sandbox_dir)
+    end
     restore_original_source
-    FileUtils.rm_rf(sandbox_dir) if sandbox_dir
   end
 
   def restore_original_source
@@ -125,21 +126,21 @@ class Evilution::Isolation::Fork
   # never sees EOF and hangs forever. The length prefix makes payload reads
   # bounded; the waitpid-WNOHANG check inside the poll loop lets us exit
   # promptly when the child died without writing anything.
-  def wait_for_result(pid, read_io, timeout)
+  def wait_for_result(handle, read_io, timeout)
     deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
     loop do
       remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      return timeout_result(pid) if remaining <= 0
+      return timeout_result(handle) if remaining <= 0
 
       if read_io.wait_readable([remaining, 0.5].min)
         payload = read_payload(read_io, deadline)
-        return reap_and_decode(pid, payload) if payload
+        return reap_and_decode(handle, payload) if payload
       end
 
-      next unless ::Process.waitpid(pid, ::Process::WNOHANG)
+      next unless @supervisor.reap_nonblock(handle)
 
       # Child exited. Drain any final payload that arrived between
-      # wait_readable timeout and waitpid (race) before declaring empty.
+      # wait_readable timeout and the reap (race) before declaring empty.
       final = read_payload(read_io, Process.clock_gettime(Process::CLOCK_MONOTONIC) + 0.1)
       return decode_payload(final) if final
 
@@ -153,13 +154,13 @@ class Evilution::Isolation::Fork
   # in execute_in_child waiting on a subject grandchild the mutation broke.
   # wait_for_result has already returned by this point, so the per-mutation
   # timeout cannot fire. Bound the wait and fall back to the TERM/KILL ladder.
-  def reap_and_decode(pid, payload)
+  def reap_and_decode(handle, payload)
     deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + REAP_DEADLINE
     loop do
-      break if ::Process.waitpid(pid, ::Process::WNOHANG)
+      break if @supervisor.reap_nonblock(handle)
 
       if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
-        terminate_child(pid)
+        @supervisor.terminate(handle, grace: GRACE_PERIOD)
         break
       end
       sleep 0.05
@@ -210,50 +211,11 @@ class Evilution::Isolation::Fork
     { timeout: false, passed: false, error: "empty result from child" }
   end
 
-  def timeout_result(pid)
-    terminate_child(pid)
+  def timeout_result(handle)
+    @supervisor.terminate(handle, grace: GRACE_PERIOD)
     { timeout: true }
   end
 
-  # Defensive reap: if normal control flow raised before wait_for_result
-  # reaped the child (e.g. Marshal.load on corrupt payload), the child becomes
-  # a zombie. Reuse terminate_child for the bounded TERM + GRACE_PERIOD + KILL
-  # ladder so this never hangs the ensure path; swallow SystemCallError so
-  # cleanup can't mask the primary failure.
-  def ensure_reaped(pid)
-    return unless pid
-
-    reaped = ::Process.waitpid(pid, ::Process::WNOHANG)
-    return if reaped
-
-    terminate_child(pid)
-  rescue SystemCallError
-    nil
-  end
-
-  def terminate_child(pid)
-    signal_tree("TERM", pid)
-    _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
-    return if status
-
-    sleep(GRACE_PERIOD)
-    _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
-    return if status
-
-    signal_tree("KILL", pid)
-    Evilution::ProcessCleanup.safe_wait(pid)
-  end
-
-  # Signal the child's whole process group (-pid) to sweep any grandchildren it
-  # forked, then the bare pid as a fallback for the case where setpgid failed
-  # (no group exists, so the group signal is a harmless Errno::ESRCH). Only the
-  # leader pid is reaped here -- group-killed grandchildren are not our direct
-  # children, so init reaps them once they die.
-  def signal_tree(sig, pid)
-    Evilution::ProcessCleanup.safe_kill(sig, -pid)
-    Evilution::ProcessCleanup.safe_kill(sig, pid)
-  end
-
   def classify_status(result)
     return :timeout if result[:timeout]
     return :killed if result[:test_crashed]

data/lib/evilution/parallel/work_queue/dispatcher/deadline_tracker.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../dispatcher"
+
+# Owns the per-worker item-timeout deadline clock for the Dispatcher: arming a
+# worker's deadline when it goes busy, re-arming it on each result, surfacing the
+# workers whose deadline has passed, and computing how long IO.select may block.
+# Each worker carries its own deadline so a single stuck worker is reaped in
+# isolation rather than aborting the whole pool (EV-gl1e). Pulling this cohesive
+# timeout concern out of the Dispatcher keeps the dispatcher focused on the
+# collect/recycle orchestration (EV-9mij).
+#
+# `workers` is the Dispatcher's live array (mutated in place as workers recycle),
+# so the tracker always reads the current pool. `clock` is injectable for tests.
+class Evilution::Parallel::WorkQueue::Dispatcher::DeadlineTracker
+  def initialize(item_timeout:, workers:, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+    @item_timeout = item_timeout
+    @workers = workers
+    @clock = clock
+  end
+
+  def enabled?
+    !@item_timeout.nil?
+  end
+
+  # Seconds IO.select may block: until the nearest worker deadline (never
+  # negative), or the raw timeout when no worker is currently on the clock.
+  def select_timeout
+    return @item_timeout unless enabled?
+
+    deadlines = @workers.filter_map(&:deadline)
+    return @item_timeout if deadlines.empty?
+
+    [deadlines.min - now, 0].max
+  end
+
+  # Workers whose deadline has passed while still holding in-flight work.
+  def overdue
+    return [] unless enabled?
+
+    moment = now
+    @workers.select { |worker| worker.deadline && worker.deadline <= moment && worker.pending.positive? }
+  end
+
+  # Arm a worker's clock when it first goes busy; idempotent for the in-flight
+  # item so a refresh does not extend an already-running deadline.
+  def start(worker)
+    return unless enabled?
+
+    worker.deadline ||= now + @item_timeout
+  end
+
+  # After a result: re-arm while work remains, otherwise stop the clock.
+  def refresh(worker)
+    worker.deadline = (now + @item_timeout if enabled? && worker.pending.positive?)
+  end
+
+  private
+
+  def now
+    @clock.call
+  end
+end

data/lib/evilution/parallel/work_queue/dispatcher.rb

@@ -12,11 +12,11 @@ class Evilution::Parallel::WorkQueue::Dispatcher
     @workers = workers
     @items = items
     @prefetch = prefetch
-    @item_timeout = item_timeout
     @worker_max_items = worker_max_items
     @recycle_factory = recycle_factory
     @state = Evilution::Parallel::WorkQueue.send(:const_get, :CollectionState).new(items.length)
     @retired = []
+    @deadlines = DeadlineTracker.new(item_timeout:, workers: @workers)
   end
 
   def run
@@ -48,7 +48,7 @@ class Evilution::Parallel::WorkQueue::Dispatcher
     result_ios = io_to_worker.keys
 
     while @state.in_flight.positive?
-      readable, = IO.select(result_ios, nil, nil, select_timeout)
+      readable, = IO.select(result_ios, nil, nil, @deadlines.select_timeout)
       reap_timed_out(io_to_worker, result_ios)
       next if readable.nil?
 
@@ -58,21 +58,8 @@ class Evilution::Parallel::WorkQueue::Dispatcher
     end
   end
 
-  def select_timeout
-    return @item_timeout unless @item_timeout
-
-    deadlines = @workers.filter_map(&:deadline)
-    return @item_timeout if deadlines.empty?
-
-    [deadlines.min - monotonic, 0].max
-  end
-
   def reap_timed_out(io_to_worker, result_ios)
-    return unless @item_timeout
-
-    now = monotonic
-    stuck = @workers.select { |w| w.deadline && w.deadline <= now && w.pending.positive? }
-    stuck.each { |w| time_out_worker(w, io_to_worker, result_ios) }
+    @deadlines.overdue.each { |worker| time_out_worker(worker, io_to_worker, result_ios) }
   end
 
   def time_out_worker(worker, io_to_worker, result_ios)
@@ -106,7 +93,7 @@ class Evilution::Parallel::WorkQueue::Dispatcher
     worker.pending -= 1
     worker.items_completed += 1
     worker.in_flight_indices.delete(index)
-    worker.deadline = next_deadline(worker)
+    @deadlines.refresh(worker)
   end
 
   # A worker that exited without replying loses only its in-flight item(s)
@@ -187,26 +174,12 @@ class Evilution::Parallel::WorkQueue::Dispatcher
     worker.send_item(@state.next_index, @items[@state.next_index])
     @state.next_index += 1
     @state.in_flight += 1
-    start_deadline(worker)
-  end
-
-  def start_deadline(worker)
-    return unless @item_timeout
-
-    worker.deadline ||= monotonic + @item_timeout
-  end
-
-  def next_deadline(worker)
-    return nil unless @item_timeout && worker.pending.positive?
-
-    monotonic + @item_timeout
+    @deadlines.start(worker)
   end
 
   def more_to_send?
     @state.next_index < @items.length
   end
-
-  def monotonic
-    Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  end
 end
+
+require_relative "dispatcher/deadline_tracker"

data/lib/evilution/parallel/work_queue/worker.rb

@@ -2,9 +2,10 @@
 
 require_relative "../work_queue"
 require_relative "../../child_output"
+require_relative "../../process_supervisor"
+require_relative "../../temp_dir_tracker"
 require_relative "channel"
 require_relative "channel/frame"
-require_relative "worker_registry"
 
 class Evilution::Parallel::WorkQueue::Worker
   Timing = Data.define(:busy, :wall)
@@ -12,14 +13,23 @@ class Evilution::Parallel::WorkQueue::Worker
   attr_reader :pid, :worker_index, :in_flight_indices
   attr_accessor :items_completed, :pending, :busy_time, :wall_time, :deadline
 
-  def self.spawn(worker_index:, hooks:, &block)
+  # EV-dg69 / EV-5rrh step 3: the supervisor owns the worker's process-group
+  # isolation, signal-safe registry, group-kill and reap. spawn passes
+  # isolate_in_child: false so the worker becomes its own group leader only
+  # parent-side, AFTER the supervisor has registered it -- preserving the
+  # EV-jwao register-before-isolate ordering (the trap can never see a leader
+  # missing from the registry). EV-cnx8 group-leadership (so #kill sweeps the
+  # whole subtree) is still established, now by the supervisor's parent-side
+  # setpgid.
+  def self.spawn(worker_index:, hooks:, supervisor: Evilution::ProcessSupervisor.new, &block)
     cmd_read, cmd_write = IO.pipe
     res_read, res_write = IO.pipe
     [cmd_read, cmd_write, res_read, res_write].each(&:binmode)
 
-    pid = Process.fork do
+    handle = supervisor.spawn(isolate_in_child: false) do
       cmd_write.close
       res_read.close
+      install_child_signal_handlers
       ENV["TEST_ENV_NUMBER"] = test_env_number_for(worker_index)
       Evilution::ChildOutput.redirect!
       Loop.run(cmd_read, res_write, hooks: hooks, &block)
@@ -27,36 +37,25 @@ class Evilution::Parallel::WorkQueue::Worker
 
     cmd_read.close
     res_write.close
-    # Register BEFORE isolating so the trap can never observe a worker that is
-    # already its own group leader yet missing from the registry (EV-jwao race,
-    # GH #1333 review): the spawn runs on the same main thread the trap
-    # interrupts, so a signal arriving between setpgid and register would
-    # otherwise leak a leader the trap cannot reach. Ordering register first
-    # leaves only safe windows -- pre-setpgid the child still shares the parent
-    # group and receives the terminal signal directly; once it is its own
-    # leader the registry already lists it. Registering unconditionally is safe
-    # because signal_all's kill(-pid) is a no-op (Errno::ESRCH) for a pid that
-    # never became a group leader (setpgid failed).
-    Evilution::Parallel::WorkQueue::WorkerRegistry.register(pid)
-    isolate_process_group(pid)
-    new(pid:, cmd_write:, res_read:, worker_index:)
+    new(handle:, supervisor:, cmd_write:, res_read:, worker_index:)
   end
 
-  # EV-cnx8 / GH #1324: make the worker its own process-group leader so #kill
-  # can signal the whole subtree. A mutation's spec may fork a grandchild that
-  # blocks (e.g. ConditionVariable#wait); when the dispatcher SIGKILLs a stuck
-  # worker, that grandchild must die with it rather than orphan to init holding
-  # memory/fds/connections. Done parent-side (before the child forks anything)
-  # so a failure is visible here instead of being swallowed in the child.
-  def self.isolate_process_group(pid)
-    Process.setpgid(pid, pid)
-  rescue Errno::EACCES, Errno::ESRCH
-    # EACCES: child already exec'd/changed group; ESRCH: child already exited.
-    # Both are benign -- reaping handles the child either way.
-    nil
-  rescue SystemCallError => e
-    warn "evilution: could not isolate worker #{pid} into its own process " \
-         "group (#{e.class}: #{e.message}); grandchildren may survive a kill."
+  # EV-7a91: a worker is the parent of the inner per-mutation Fork children it
+  # spawns, and those children are their own process-group leaders (EV-2sh8), so
+  # the Runner's group-kill of the worker never reaches them. On a terminal
+  # INT/TERM the worker must therefore tear down AND reap the inner children it
+  # owns before it dies, or they survive as zombies (their parent gone) until an
+  # ancestor exits. cleanup_all clears any per-mutation sandbox dirs the inner
+  # children registered in this worker's TempDirTracker.
+  def self.install_child_signal_handlers
+    %w[INT TERM].each do |sig|
+      Signal.trap(sig) do
+        Evilution::TempDirTracker.cleanup_all
+        Evilution::ProcessSupervisor.kill_and_reap_all
+        Signal.trap(sig, "DEFAULT")
+        Process.kill(sig, Process.pid)
+      end
+    end
   end
 
   # EV-kdns / GH #817: translate 0-based worker slot to parallel_tests'
@@ -67,8 +66,10 @@ class Evilution::Parallel::WorkQueue::Worker
     worker_index.zero? ? "" : (worker_index + 1).to_s
   end
 
-  def initialize(pid:, cmd_write:, res_read:, worker_index:)
-    @pid = pid
+  def initialize(handle:, supervisor:, cmd_write:, res_read:, worker_index:)
+    @handle = handle
+    @supervisor = supervisor
+    @pid = handle.pid
     @cmd_write = cmd_write
     @res_read = res_read
     @worker_index = worker_index
@@ -101,18 +102,10 @@ class Evilution::Parallel::WorkQueue::Worker
   end
 
   # SIGKILL the worker's whole process group (negative pid), reaping any
-  # grandchildren it forked. Falls back to the single pid if the group is gone
-  # -- already reaped, or setpgid did not take in the child.
+  # grandchildren it forked, with the bare pid as a fallback for the case where
+  # the group is gone (already reaped, or setpgid did not take).
   def kill
-    Process.kill("KILL", -@pid)
-  rescue Errno::ESRCH
-    kill_pid
-  end
-
-  def kill_pid
-    Process.kill("KILL", @pid)
-  rescue Errno::ESRCH
-    nil
+    @supervisor.signal_group("KILL", @handle)
   end
 
   def close_pipes
@@ -120,14 +113,11 @@ class Evilution::Parallel::WorkQueue::Worker
     @res_read.close unless @res_read.closed?
   end
 
+  # Reap the leader and drop it from the registry so the trap never signals a
+  # group whose pid the OS may have recycled. ECHILD-tolerant; unregister is a
+  # no-op if it was never registered.
   def reap
-    Process.wait(@pid)
-  rescue Errno::ECHILD
-    nil
-  ensure
-    # Drop the pgid once the leader is reaped so the trap never signals a group
-    # whose pid the OS may have recycled. No-op if it was never registered.
-    Evilution::Parallel::WorkQueue::WorkerRegistry.unregister(@pid)
+    @supervisor.reap(@handle)
   end
 
   def retire