evilution 0.33.0 → 0.35.0

data/lib/evilution/spec_resolver.rb

@@ -28,6 +28,22 @@ class Evilution::SpecResolver
     Array(source_paths).filter_map { |path| call(path) }.uniq
   end
 
+  # Like #call, but returns an ARRAY of test files and additionally covers the
+  # dir-grouped layout (a source file's tests live in a directory named after
+  # the source basename, e.g. lib/x/branch.rb -> test/unit/branch/*_test.rb,
+  # rather than a single mirror file). The deterministic file mirror from #call
+  # always wins; only when no mirror file exists is the first matching grouped
+  # directory expanded into its test files (EV-bi41). Returns nil when nothing
+  # resolves.
+  def resolve_specs(source_path, spec_pattern: nil)
+    return nil if source_path.nil? || source_path.empty?
+
+    file = call(source_path, spec_pattern: spec_pattern)
+    return [file] if file
+
+    resolve_grouped_dir(source_path, spec_pattern: spec_pattern)
+  end
+
   # Best-guess candidate for an unresolved source, found by basename glob
   # rather than the deterministic path mirroring used by #call. Used only to
   # enrich the "no matching test" hint (EV-z7f5 / GH #1325) — never to pick a
@@ -75,6 +91,56 @@ class Evilution::SpecResolver
     candidates.select { |path| File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
   end
 
+  # Dir-grouped resolution: find the first candidate directory that exists and
+  # expand it into its test files. Ranked below #call's file mirrors (callers
+  # try #call first), so a 1:1 spec always wins when present.
+  def resolve_grouped_dir(source_path, spec_pattern: nil)
+    dir = directory_candidates(normalize_path(source_path)).find { |c| project_relative_dir?(c) }
+    return nil unless dir
+
+    files = test_files_in(dir)
+    files = filter_by_pattern(files, spec_pattern) if spec_pattern
+    files.empty? ? nil : files
+  end
+
+  # The grouped-directory analogue of #mirror_candidates: cross every
+  # conventional root with each layout variant, using the source basename
+  # (suffix dropped) as a DIRECTORY name rather than a test FILE name.
+  def directory_candidates(source_path)
+    stripped = strip_source_prefix(source_path)
+    mirror_variants(stripped).flat_map { |variant| grouped_dir_candidates(variant) }.uniq
+  end
+
+  def grouped_dir_candidates(variant)
+    dir, _, file = variant.rpartition("/")
+    name = file.delete_suffix(@test_suffix)
+    return [] if name.empty?
+
+    relative = dir.empty? ? name : "#{dir}/#{name}"
+    roots.map { |root| "#{root}/#{relative}" }
+  end
+
+  def strip_source_prefix(source_path)
+    base = source_path.sub(/\.rb\z/, @test_suffix)
+    prefix = STRIPPABLE_PREFIXES.find { |p| source_path.start_with?(p) }
+    prefix ? base.delete_prefix(prefix) : base
+  end
+
+  # Every test file under a grouped directory: the mirrored suffix plus, for
+  # minitest/test-unit, the `test_` prefix convention. Sorted for determinism.
+  def test_files_in(dir)
+    globs = ["#{dir}/**/*#{@test_suffix}", ("#{dir}/**/test_*.rb" if @test_suffix == MINITEST_SUFFIX)]
+    globs.compact.flat_map { |glob| glob_relative(glob) }.uniq.sort
+  end
+
+  # Directory analogue of #project_relative_exists?.
+  def project_relative_dir?(path)
+    return true if File.directory?(path)
+    return false unless Evilution.in_isolated_worker?
+
+    File.directory?(File.expand_path(path, Evilution::PROJECT_ROOT))
+  end
+
   def normalize_path(path)
     path = path.delete_prefix("./")
     if path.start_with?("/")
@@ -95,7 +161,14 @@ class Evilution::SpecResolver
 
     fallbacks = primary.flat_map { |c| parent_fallback_candidates(c) }
 
-    (primary + fallbacks + prefix_convention_candidates(stripped)).uniq
+    (primary + fallbacks + convention_candidates(stripped)).uniq
+  end
+
+  # Non-mirrored Test::Unit/minitest filename conventions: the `test_<name>.rb`
+  # prefix and the flat namespace-prefixed form. Both rank below the mirrored
+  # layouts assembled in #candidate_test_paths.
+  def convention_candidates(stripped)
+    prefix_convention_candidates(stripped) + flat_prefixed_candidates(stripped)
   end
 
   # Conventional roots that may hold tests: the mirrored root plus the common
@@ -138,6 +211,25 @@ class Evilution::SpecResolver
     end
   end
 
+  # Test::Unit / minitest gems sometimes flatten a nested source's path into a
+  # single `test_`-prefixed file at the test root: lib/connection_pool/timed_stack.rb
+  # -> test/test_connection_pool_timed_stack.rb (no test/connection_pool/ subdir).
+  # Built from the FULL lib-relative path only (every segment joined with `_`),
+  # NOT from namespace-dropped variants — dropping segments would yield bare
+  # basename forms (test_timed_stack.rb) that collide across namespaces and are
+  # already covered by #prefix_convention_candidates. Top-level sources have no
+  # namespace to flatten, so they produce nothing here. Ranked below the mirrored
+  # layouts (appended last) so a 1:1 file always wins. Minitest suffix only.
+  def flat_prefixed_candidates(stripped)
+    return [] unless @test_suffix == MINITEST_SUFFIX
+    return [] unless stripped.include?("/")
+
+    name = stripped.delete_suffix(@test_suffix).tr("/", "_")
+    return [] if name.empty?
+
+    roots.map { |root| "#{root}/test_#{name}.rb" }
+  end
+
   def controller_to_request_test(stripped_path)
     return nil unless stripped_path.start_with?(CONTROLLER_PREFIX)
 

data/lib/evilution/spec_selector.rb

@@ -19,12 +19,23 @@ class Evilution::SpecSelector
       return existing unless existing.empty?
     end
 
-    resolved = @spec_resolver.call(source_path, spec_pattern: @spec_pattern)
-    resolved ? [resolved] : nil
+    resolved = resolve_via_resolver(source_path)
+    resolved && !resolved.empty? ? resolved : nil
   end
 
   private
 
+  # Prefer the array-returning #resolve_specs, but fall back to the older single-file #call contract so a custom
+  # resolver that only implements #call keeps working.
+  def resolve_via_resolver(source_path)
+    if @spec_resolver.respond_to?(:resolve_specs)
+      @spec_resolver.resolve_specs(source_path, spec_pattern: @spec_pattern)
+    else
+      file = @spec_resolver.call(source_path, spec_pattern: @spec_pattern)
+      file ? [file] : nil
+    end
+  end
+
   def mapping_for(source_path)
     @spec_mappings[normalize(source_path)]
   end
@@ -40,8 +51,7 @@ class Evilution::SpecSelector
     normalized.delete_prefix("./")
   end
 
-  # Same semantics as Evilution::SpecResolver#project_relative_exists? — see
-  # that method for the EV-wqxu / GH #1278 rationale.
+  # Same semantics as Evilution::SpecResolver#project_relative_exists?
   def project_relative_exists?(path)
     return true if File.exist?(path)
     return false unless Evilution.in_isolated_worker?

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "0.33.0"
+  VERSION = "0.35.0"
 end

data/lib/evilution.rb

@@ -100,6 +100,7 @@ require_relative "evilution/mutator/registry"
 require_relative "evilution/equivalent"
 require_relative "evilution/equivalent/heuristic"
 require_relative "evilution/equivalent/detector"
+require_relative "evilution/process_supervisor"
 require_relative "evilution/isolation"
 require_relative "evilution/isolation/fork"
 require_relative "evilution/isolation/in_process"

data/scripts/canary_manifest.yml

@@ -0,0 +1,47 @@
+# Canary manifest for the EV-7ydn validation run of scripts/compare_targeting.
+#
+#   scripts/compare_targeting scripts/canary_manifest.yml --out .artifacts/targeting_validation.md
+#
+# Each repo is run through evilution three times (full_file / lexical / coverage)
+# over the SAME mutation set; the gate is total lost_kills == 0 (coverage must
+# never lose a kill full-file caught) before the default flips to coverage.
+#
+# `dir:` assumes the EV-rxob canary checkout layout (/tmp/ev-canaries/<repo>,
+# already `bundle install`ed). Adjust to your checkout. Per-repo `args` mirror
+# the EV-rxob R2 findings: repos whose specs are NOT lib-mirrored need an
+# explicit --spec (EV-z7f5 / GH #1325), or auto spec-resolution yields 0.0 and
+# the comparison is meaningless.
+#
+# Start with the R2 infra=none tier that ran clean; extend with the DB-tier
+# repos once their services are up.
+
+repos:
+  # --- R2 PASS, lib-mirrored specs (auto-resolution works) ---
+  - name: thoughtbot/factory_bot
+    dir: /tmp/ev-canaries/factory_bot
+    args: ["lib", "--jobs", "4"]
+
+  - name: jnunemaker/httparty
+    dir: /tmp/ev-canaries/httparty
+    args: ["lib", "--jobs", "4"]
+
+  - name: rubocop/rubocop
+    dir: /tmp/ev-canaries/rubocop
+    args: ["lib", "--jobs", "4"]
+
+  - name: rack/rack
+    dir: /tmp/ev-canaries/rack
+    args: ["lib", "--jobs", "4"]
+
+  # --- Non-lib-mirrored specs: explicit --spec required (EV-z7f5 / GH #1325) ---
+  - name: bblimke/webmock
+    dir: /tmp/ev-canaries/webmock
+    args: ["lib", "--spec", "spec/unit", "--jobs", "4"]
+
+  - name: doorkeeper-gem/doorkeeper
+    dir: /tmp/ev-canaries/doorkeeper
+    args: ["lib", "--spec", "spec", "--jobs", "4"]
+
+  - name: ruby-concurrency/concurrent-ruby
+    dir: /tmp/ev-canaries/concurrent-ruby
+    args: ["lib", "--spec", "spec", "--jobs", "4"]

data/scripts/compare_targeting

@@ -0,0 +1,277 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Targeting-mode comparison harness.
+#
+# For each repo in a manifest, runs evilution over the SAME mutation set under
+# three example-targeting modes -- full_file (baseline), lexical (current), and
+# coverage (new) -- joins the per-mutation results, and emits a per-repo table:
+#   score_full / score_lexical / score_coverage,
+#   lost_kills  (mutations full_file KILLED but coverage did NOT -> the gate),
+#   wall_ratio_lexical / wall_ratio_coverage (vs the full_file baseline).
+#
+# The accuracy gate is lost_kills == 0: coverage targeting must never lose a kill
+# the full-file run would catch. Speed is reported, not gated.
+#
+# Usage:
+#   scripts/compare_targeting MANIFEST.yml [--out report.md]
+#
+# MANIFEST.yml:
+#   repos:
+#     - name: acme/foo
+#       dir:  /checkouts/foo        # already bundled
+#       args: ["lib/foo.rb", "--jobs", "4"]
+#
+# The actual canary execution (checkout + bundle over the EV-rxob manifest) is
+# the validation run, EV-7ydn; this harness is the reusable comparison engine.
+
+require "json"
+require "yaml"
+require "open3"
+require "optparse"
+require "digest"
+
+module CompareTargeting
+  MODES = %w[full_file lexical coverage].freeze
+  KEY_FIELDS = %w[file line operator].freeze
+
+  class ConfigError < StandardError; end
+
+  module_function
+
+  # Stable per-mutation identity across modes: only TARGETING differs between
+  # runs, so the same mutation has the same file/line/operator (+ diff to
+  # separate distinct mutations sharing a line+operator).
+  def key_for(detail)
+    base = KEY_FIELDS.map { |field| detail[field] }.join(":")
+    digest = detail["diff"].to_s
+    digest.empty? ? base : "#{base}##{Digest::SHA256.hexdigest(digest)[0, 8]}"
+  end
+
+  # The label shown in lost-kill output: file:line:operator (no diff hash).
+  def label_for(detail)
+    KEY_FIELDS.map { |field| detail[field] }.join(":")
+  end
+
+  # One mode's run, indexed by mutation key.
+  class ModeResult
+    CATEGORIES = %w[killed survived neutral equivalent unresolved unparseable timed_out errors].freeze
+
+    def self.from_json(data)
+      by_key = {}
+      CATEGORIES.each do |category|
+        Array(data[category]).each do |detail|
+          key = CompareTargeting.key_for(detail)
+          by_key[key] ||= {
+            status: detail["status"],
+            duration: (detail["duration"] || 0.0).to_f,
+            label: CompareTargeting.label_for(detail)
+          }
+        end
+      end
+      new(by_key)
+    end
+
+    def initialize(by_key)
+      @by_key = by_key
+    end
+
+    def keys
+      @by_key.keys
+    end
+
+    def status(key)
+      @by_key.dig(key, :status)
+    end
+
+    def label(key)
+      @by_key.dig(key, :label)
+    end
+
+    def killed_count
+      @by_key.count { |_, value| value[:status] == "killed" }
+    end
+
+    # Measurable = the run actually observed a verdict: killed or survived.
+    # unresolved/equivalent/errors/unparseable are excluded from the score.
+    def measurable_count
+      @by_key.count { |_, value| %w[killed survived].include?(value[:status]) }
+    end
+
+    def total_duration
+      @by_key.values.sum { |value| value[:duration] }
+    end
+  end
+
+  # Joins the three modes for one repo and derives the comparison metrics.
+  class Comparison
+    def initialize(full_file:, lexical:, coverage:)
+      @modes = { "full_file" => full_file, "lexical" => lexical, "coverage" => coverage }
+    end
+
+    def score(mode)
+      result = @modes.fetch(mode)
+      return 0.0 if result.measurable_count.zero?
+
+      result.killed_count.to_f / result.measurable_count
+    end
+
+    def wall_ratio(mode)
+      baseline = @modes.fetch("full_file").total_duration
+      return 0.0 if baseline.zero?
+
+      @modes.fetch(mode).total_duration / baseline
+    end
+
+    # Mutation labels that full_file KILLED but `mode` failed to kill -- the
+    # lost kills that must be zero before coverage can become the default.
+    def lost_kills(mode = "coverage")
+      full = @modes.fetch("full_file")
+      other = @modes.fetch(mode)
+      full.keys.select { |key| full.status(key) == "killed" && other.status(key) != "killed" }
+               .map { |key| full.label(key) }
+    end
+
+    def to_row(repo)
+      {
+        repo: repo,
+        score_full: score("full_file"),
+        score_lexical: score("lexical"),
+        score_coverage: score("coverage"),
+        lost_kills: lost_kills("coverage").size,
+        wall_ratio_lexical: wall_ratio("lexical"),
+        wall_ratio_coverage: wall_ratio("coverage")
+      }
+    end
+  end
+
+  # Renders the per-repo rows as a markdown table with a PASS/FAIL gate line.
+  class TableReporter
+    COLUMNS = %w[repo score_full score_lexical score_coverage lost_kills
+                 wall_ratio_lexical wall_ratio_coverage].freeze
+
+    def initialize(rows)
+      @rows = rows
+    end
+
+    def to_markdown
+      (table_lines + ["", gate_line]).join("\n")
+    end
+
+    private
+
+    def table_lines
+      [header_row, separator_row, *@rows.map { |row| data_row(row) }]
+    end
+
+    def header_row
+      "| #{COLUMNS.join(" | ")} |"
+    end
+
+    def separator_row
+      "| #{COLUMNS.map { "---" }.join(" | ")} |"
+    end
+
+    def data_row(row)
+      "| #{COLUMNS.map { |col| format_cell(row[col.to_sym]) }.join(" | ")} |"
+    end
+
+    def gate_line
+      total_lost = @rows.sum { |row| row[:lost_kills] }
+      gate = total_lost.zero? ? "PASS" : "FAIL"
+      "GATE (total lost_kills == 0): #{gate} (#{total_lost} lost kills across #{@rows.size} repos)"
+    end
+
+    def format_cell(value)
+      value.is_a?(Float) ? format("%.3f", value) : value.to_s
+    end
+  end
+
+  # Runs evilution for one (repo, mode) and parses the JSON into a ModeResult.
+  # command_runner is injected so the pure pipeline is testable without a real
+  # mutation run.
+  class ModeRunner
+    # Run the inner `bundle exec evilution` in the TARGET repo's bundler context.
+    # If this harness is itself launched under `bundle exec`, Bundler exports
+    # BUNDLE_GEMFILE/RUBYOPT into the child, which would make the inner bundle
+    # resolve against evilution's Gemfile instead of the target repo's. Strip
+    # that inherited bundler env first.
+    DEFAULT_RUNNER = lambda do |cmd, dir|
+      stdout, stderr, status =
+        if defined?(Bundler)
+          Bundler.with_unbundled_env { Open3.capture3(*cmd, chdir: dir) }
+        else
+          Open3.capture3(*cmd, chdir: dir)
+        end
+      raise ConfigError, "evilution failed in #{dir}: #{stderr}" unless status.success?
+
+      stdout
+    end
+
+    def initialize(command_runner: DEFAULT_RUNNER)
+      @command_runner = command_runner
+    end
+
+    def run(repo_dir:, evilution_args:, mode:)
+      cmd = ["bundle", "exec", "evilution", *evilution_args,
+             "--example-targeting", mode, "--format", "json"]
+      json = @command_runner.call(cmd, repo_dir)
+      ModeResult.from_json(JSON.parse(json))
+    end
+  end
+
+  # Drives the manifest: every repo through every mode, then the table.
+  class Harness
+    def initialize(mode_runner: ModeRunner.new)
+      @mode_runner = mode_runner
+    end
+
+    def call(repos)
+      rows = repos.map { |repo| compare_repo(repo) }
+      TableReporter.new(rows).to_markdown
+    end
+
+    def compare_repo(repo)
+      results = MODES.to_h do |mode|
+        [mode, @mode_runner.run(repo_dir: repo.fetch(:dir), evilution_args: repo.fetch(:args), mode: mode)]
+      end
+      Comparison.new(**results.transform_keys(&:to_sym)).to_row(repo.fetch(:name))
+    end
+  end
+
+  def load_manifest(path)
+    data = YAML.safe_load_file(path, symbolize_names: true)
+    raise ConfigError, "manifest must list repos:" unless data.is_a?(Hash) && data[:repos].is_a?(Array)
+
+    data[:repos]
+  rescue Errno::ENOENT
+    raise ConfigError, "manifest not found: #{path}"
+  rescue Psych::SyntaxError => e
+    raise ConfigError, "manifest is not valid YAML: #{e.message}"
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  out_path = nil
+  parser = OptionParser.new do |opts|
+    opts.banner = "Usage: scripts/compare_targeting MANIFEST.yml [--out report.md]"
+    opts.on("--out PATH", "Write the markdown report to PATH (default: stdout)") { |p| out_path = p }
+  end
+  parser.parse!
+
+  manifest_path = ARGV.first
+  unless manifest_path
+    warn parser.banner
+    exit 2
+  end
+
+  begin
+    repos = CompareTargeting.load_manifest(manifest_path)
+    report = CompareTargeting::Harness.new.call(repos)
+    out_path ? File.write(out_path, report) : puts(report)
+    exit 0
+  rescue CompareTargeting::ConfigError => e
+    warn "Error: #{e.message}"
+    exit 2
+  end
+end

data/scripts/compare_targeting.example.yml

@@ -0,0 +1,24 @@
+# Example manifest for scripts/compare_targeting (EV-51d4).
+#
+# Each repo is run through evilution three times -- once per example-targeting
+# mode (full_file, lexical, coverage) -- over the SAME mutation set, and the
+# harness emits a per-repo table with the lost_kills gate and wall-time ratios.
+#
+# Repos must already be checked out and `bundle install`ed; the harness only
+# runs evilution inside them. The real EV-rxob canary list is wired up in the
+# validation run (EV-7ydn).
+#
+#   scripts/compare_targeting scripts/compare_targeting.example.yml --out report.md
+
+repos:
+  - name: thoughtbot/factory_bot
+    dir: /tmp/ev-canaries/factory_bot
+    args: ["lib", "--jobs", "4"]
+
+  - name: bblimke/webmock
+    dir: /tmp/ev-canaries/webmock
+    args: ["lib", "--jobs", "4"]
+
+  - name: rack/rack
+    dir: /tmp/ev-canaries/rack
+    args: ["lib", "--jobs", "4"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 0.33.0
+  version: 0.35.0
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-07 00:00:00.000000000 Z
+date: 2026-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -99,6 +99,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- assets/logo/evilution-mark-1024.png
+- assets/logo/evilution-mark-64.png
+- assets/logo/evilution-mark-transparent-1024.png
+- assets/logo/evilution-mark-transparent.svg
+- assets/logo/evilution-mark.svg
 - claude-swarm.yml
 - comparison_results/baseline_2026-04-09.md
 - comparison_results/operator_classification.md
@@ -106,6 +111,7 @@ files:
 - docs/ast_pattern_syntax.md
 - docs/integrations.md
 - docs/isolation.md
+- docs/migration-from-mutant.md
 - docs/mutation_density_benchmark.md
 - docs/versioning.md
 - exe/evil
@@ -180,6 +186,7 @@ files:
 - lib/evilution/config/validators/base.rb
 - lib/evilution/config/validators/example_targeting_cache.rb
 - lib/evilution/config/validators/example_targeting_fallback.rb
+- lib/evilution/config/validators/example_targeting_strategy.rb
 - lib/evilution/config/validators/fail_fast.rb
 - lib/evilution/config/validators/hooks.rb
 - lib/evilution/config/validators/ignore_patterns.rb
@@ -190,6 +197,13 @@ files:
 - lib/evilution/config/validators/profile.rb
 - lib/evilution/config/validators/spec_mappings.rb
 - lib/evilution/config/validators/spec_pattern.rb
+- lib/evilution/coverage.rb
+- lib/evilution/coverage/digest.rb
+- lib/evilution/coverage/map.rb
+- lib/evilution/coverage/map_builder.rb
+- lib/evilution/coverage/map_store.rb
+- lib/evilution/coverage/recorder.rb
+- lib/evilution/coverage_example_filter.rb
 - lib/evilution/disable_comment.rb
 - lib/evilution/equivalent.rb
 - lib/evilution/equivalent/detector.rb
@@ -368,16 +382,17 @@ files:
 - lib/evilution/parallel/work_queue/channel/frame.rb
 - lib/evilution/parallel/work_queue/collection_state.rb
 - lib/evilution/parallel/work_queue/dispatcher.rb
+- lib/evilution/parallel/work_queue/dispatcher/deadline_tracker.rb
 - lib/evilution/parallel/work_queue/validators.rb
 - lib/evilution/parallel/work_queue/validators/optional_positive_int.rb
 - lib/evilution/parallel/work_queue/validators/optional_positive_number.rb
 - lib/evilution/parallel/work_queue/validators/positive_int.rb
 - lib/evilution/parallel/work_queue/worker.rb
 - lib/evilution/parallel/work_queue/worker/loop.rb
-- lib/evilution/parallel/work_queue/worker_registry.rb
 - lib/evilution/parallel/work_queue/worker_stat.rb
 - lib/evilution/parallel_db_warning.rb
 - lib/evilution/process_cleanup.rb
+- lib/evilution/process_supervisor.rb
 - lib/evilution/rails_detector.rb
 - lib/evilution/related_spec_heuristic.rb
 - lib/evilution/reporter.rb
@@ -497,8 +512,11 @@ files:
 - script/run_self_validation
 - scripts/benchmark_density
 - scripts/benchmark_density.yml
+- scripts/canary_manifest.yml
 - scripts/compare_mutations
 - scripts/compare_mutations.yml
+- scripts/compare_targeting
+- scripts/compare_targeting.example.yml
 - scripts/mutant_json_adapter
 - sig/evilution.rbs
 homepage: https://github.com/marinazzio/evilution

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../work_queue"
-
-# Process-global registry of live worker process-group ids (pgids).
-#
-# EV-jwao / GH #1332: EV-cnx8 made each Worker its own process-group leader so a
-# stuck worker's whole subtree can be group-killed. Side effect: a terminal
-# Ctrl-C delivers SIGINT only to the parent's foreground group, so workers (now
-# in their own groups) no longer receive it -- and the parent's fatal-signal
-# death skips work_queue#map's `ensure cleanup_workers`, leaking any worker that
-# was actively running a (possibly blocking) mutation at interrupt time.
-#
-# Runner#install_signal_handler reads this registry from inside the trap and
-# forwards INT/TERM to each worker group before re-raising to DEFAULT.
-#
-# Signal-safety: under MRI a trap handler runs on the main thread between VM
-# instructions, so it must not acquire a Mutex (the main thread may hold it ->
-# deadlock). register/unregister therefore swap @pgids for a freshly built
-# frozen array via a single atomic reference assignment (copy-on-write). The
-# trap reads the current reference once and iterates that complete, immutable
-# snapshot -- no torn reads, no lock.
-module Evilution::Parallel::WorkQueue::WorkerRegistry
-  @pgids = [].freeze
-
-  class << self
-    # Frozen snapshot. Safe to read from a signal handler.
-    attr_reader :pgids
-
-    def register(pgid)
-      @pgids = (@pgids + [pgid]).freeze
-    end
-
-    def unregister(pgid)
-      @pgids = @pgids.reject { |existing| existing == pgid }.freeze
-    end
-
-    def signal_all(sig)
-      @pgids.each do |pgid|
-        Process.kill(sig, -pgid)
-      rescue Errno::ESRCH
-        # Group already gone (worker + subtree reaped) -- nothing to signal.
-        nil
-      end
-    end
-  end
-end