evilution 0.28.0 → 0.30.0

data/lib/evilution/cli/commands/compare.rb

@@ -9,6 +9,7 @@ require_relative "../../compare"
 require_relative "../../compare/categorizer"
 require_relative "../../compare/detector"
 require_relative "../../compare/normalizer"
+require_relative "../../session/schema"
 
 class Evilution::CLI::Commands::Compare < Evilution::CLI::Command
   SUPPORTED_FORMATS = %i[json text].freeze
@@ -46,6 +47,7 @@ class Evilution::CLI::Commands::Compare < Evilution::CLI::Command
     raise Evilution::Error, "file not found: #{path}" unless File.exist?(path)
 
     json = JSON.parse(File.read(path))
+    validate_session_schema(json, path)
     tool = Evilution::Compare::Detector.call(json)
     normalize(json, tool)
   rescue ::JSON::ParserError => e
@@ -56,6 +58,17 @@ class Evilution::CLI::Commands::Compare < Evilution::CLI::Command
     raise Evilution::Error, e.message
   end
 
+  # Validate before detection: schema_version is an evilution-only marker. A
+  # future schema may rearrange the shape enough that Detector cannot classify
+  # it; in that case the user must still see "Upgrade the evilution gem", not
+  # "cannot detect tool".
+  def validate_session_schema(json, path)
+    return unless json.is_a?(Hash)
+    return unless json.key?("schema_version") || json.key?(:schema_version)
+
+    Evilution::Session::Schema.validate!(json, source: path)
+  end
+
   def normalize(json, tool)
     normalizer = Evilution::Compare::Normalizer.new
     case tool

data/lib/evilution/cli/commands/session_diff.rb

@@ -14,10 +14,7 @@ class Evilution::CLI::Commands::SessionDiff < Evilution::CLI::Command
   def perform
     raise Evilution::ConfigError, "two session file paths required" unless @files.length == 2
 
-    store = Evilution::Session::Store.new
-    base_data = store.load(@files[0])
-    head_data = store.load(@files[1])
-    result = Evilution::Session::Diff.new.call(base_data, head_data)
+    result = compute_diff(@files)
     Evilution::CLI::Printers::SessionDiff.new(result, format: @options[:format]).render(@stdout)
     0
   rescue ::JSON::ParserError => e
@@ -25,6 +22,11 @@ class Evilution::CLI::Commands::SessionDiff < Evilution::CLI::Command
   rescue SystemCallError => e
     raise Evilution::Error, e.message
   end
+
+  def compute_diff(files)
+    store = Evilution::Session::Store.new
+    Evilution::Session::Diff.new.call(store.load(files[0]), store.load(files[1]))
+  end
 end
 
 Evilution::CLI::Dispatcher.register(:session_diff, Evilution::CLI::Commands::SessionDiff)

data/lib/evilution/cli/commands/subjects.rb

@@ -9,6 +9,9 @@ require_relative "../../runner"
 require_relative "../../mutator"
 
 class Evilution::CLI::Commands::Subjects < Evilution::CLI::Command
+  EntriesResult = Data.define(:entries, :total)
+  private_constant :EntriesResult
+
   private
 
   def perform
@@ -23,8 +26,8 @@ class Evilution::CLI::Commands::Subjects < Evilution::CLI::Command
       return 0
     end
 
-    entries, total = collect_entries(subjects, config)
-    Evilution::CLI::Printers::Subjects.new(entries, total_mutations: total).render(@stdout)
+    result = collect_entries(subjects, config)
+    Evilution::CLI::Printers::Subjects.new(result.entries, total_mutations: result.total).render(@stdout)
     0
   end
 
@@ -43,7 +46,7 @@ class Evilution::CLI::Commands::Subjects < Evilution::CLI::Command
       subj.release_node!
     end
 
-    [entries, total]
+    EntriesResult.new(entries: entries, total: total)
   end
 end
 

data/lib/evilution/cli/commands/util_mutation.rb

@@ -11,11 +11,14 @@ require_relative "../../mutator/registry"
 require_relative "../../ast/parser"
 
 class Evilution::CLI::Commands::UtilMutation < Evilution::CLI::Command
+  SourceInput = Data.define(:source, :file_path)
+  private_constant :SourceInput
+
   private
 
   def perform
-    source, file_path = resolve_util_mutation_source
-    subjects = parse_source_to_subjects(source, file_path)
+    input = resolve_util_mutation_source
+    subjects = parse_source_to_subjects(input.source, input.file_path)
     config = Evilution::Config.new(**@options)
     registry = Evilution::Mutator::Registry.default
     operator_options = build_operator_options(config)
@@ -33,24 +36,26 @@ class Evilution::CLI::Commands::UtilMutation < Evilution::CLI::Command
   end
 
   def resolve_util_mutation_source
-    if @options[:eval]
-      tmpfile = Tempfile.new(["evilution_eval", ".rb"])
-      tmpfile.write(@options[:eval])
-      tmpfile.flush
-      @util_tmpfile = tmpfile
-      [@options[:eval], tmpfile.path]
-    elsif @files.first
-      path = @files.first
-      raise Evilution::Error, "file not found: #{path}" unless File.exist?(path)
+    return build_eval_source(@options[:eval]) if @options[:eval]
+    return build_file_source(@files.first) if @files.first
 
-      begin
-        [File.read(path), path]
-      rescue SystemCallError => e
-        raise Evilution::Error, e.message
-      end
-    else
-      raise Evilution::Error, "source required: use -e 'code' or provide a file path"
-    end
+    raise Evilution::Error, "source required: use -e 'code' or provide a file path"
+  end
+
+  def build_eval_source(code)
+    tmpfile = Tempfile.new(["evilution_eval", ".rb"])
+    tmpfile.write(code)
+    tmpfile.flush
+    @util_tmpfile = tmpfile
+    SourceInput.new(source: code, file_path: tmpfile.path)
+  end
+
+  def build_file_source(path)
+    raise Evilution::Error, "file not found: #{path}" unless File.exist?(path)
+
+    SourceInput.new(source: File.read(path), file_path: path)
+  rescue SystemCallError => e
+    raise Evilution::Error, e.message
   end
 
   def parse_source_to_subjects(source, file_label)

data/lib/evilution/cli/parser/command_extractor.rb

@@ -16,10 +16,19 @@ class Evilution::CLI::Parser::CommandExtractor
     "gc" => :session_gc
   }.freeze
 
+  RUN_ALIASES = %w[run mutate].freeze
+
   TESTS_SUBCOMMANDS = { "list" => :tests_list }.freeze
   ENVIRONMENT_SUBCOMMANDS = { "show" => :environment_show }.freeze
   UTIL_SUBCOMMANDS = { "mutation" => :util_mutation }.freeze
 
+  SUBCOMMAND_FAMILIES = {
+    "session" => [SESSION_SUBCOMMANDS, "session", "list, show, diff, gc"],
+    "tests" => [TESTS_SUBCOMMANDS, "tests", "list"],
+    "environment" => [ENVIRONMENT_SUBCOMMANDS, "environment", "show"],
+    "util" => [UTIL_SUBCOMMANDS, "util", "mutation"]
+  }.freeze
+
   Result = Struct.new(:command, :remaining_argv, :parse_error)
 
   def self.call(argv)
@@ -44,20 +53,11 @@ class Evilution::CLI::Parser::CommandExtractor
     if SIMPLE_COMMANDS.key?(first)
       @command = SIMPLE_COMMANDS[first]
       @argv.shift
-    elsif first == "run"
-      @argv.shift
-    elsif first == "session"
-      @argv.shift
-      extract_subcommand(SESSION_SUBCOMMANDS, "session", "list, show, diff, gc")
-    elsif first == "tests"
-      @argv.shift
-      extract_subcommand(TESTS_SUBCOMMANDS, "tests", "list")
-    elsif first == "environment"
+    elsif RUN_ALIASES.include?(first)
       @argv.shift
-      extract_subcommand(ENVIRONMENT_SUBCOMMANDS, "environment", "show")
-    elsif first == "util"
+    elsif SUBCOMMAND_FAMILIES.key?(first)
       @argv.shift
-      extract_subcommand(UTIL_SUBCOMMANDS, "util", "mutation")
+      extract_subcommand(*SUBCOMMAND_FAMILIES[first])
     end
   end
 

data/lib/evilution/cli/parser/file_args.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Evilution::CLI::Parser::FileArgs
+  ParsedPaths = Data.define(:files, :ranges)
+
   module_function
 
   def parse(raw_args)
@@ -15,7 +17,7 @@ module Evilution::CLI::Parser::FileArgs
       ranges[file] = parse_line_range(range_str)
     end
 
-    [files, ranges]
+    ParsedPaths.new(files: files, ranges: ranges)
   end
 
   def expand_spec_dir(dir)

data/lib/evilution/cli/parser/options_builder.rb

@@ -21,6 +21,8 @@ class Evilution::CLI::Parser::OptionsBuilder
       add_core_options(opts)
       add_filter_options(opts)
       add_flag_options(opts)
+      add_runner_mode_options(opts)
+      add_output_options(opts)
       add_profile_options(opts)
       add_extra_flag_options(opts)
       add_session_options(opts)
@@ -34,8 +36,8 @@ class Evilution::CLI::Parser::OptionsBuilder
     opts.separator ""
     opts.separator "Line-range targeting: lib/foo.rb:15-30, lib/foo.rb:15, lib/foo.rb:15-"
     opts.separator ""
-    opts.separator "Commands: run (default), init, session {list,show,diff,gc}, subjects, tests {list},"
-    opts.separator "         util {mutation}, environment {show}, compare, mcp, version"
+    opts.separator "Commands: run (default; alias: mutate), init, session {list,show,diff,gc}, subjects,"
+    opts.separator "         tests {list}, util {mutation}, environment {show}, compare, mcp, version"
     opts.separator ""
     opts.separator "Options:"
   end
@@ -47,11 +49,19 @@ class Evilution::CLI::Parser::OptionsBuilder
   end
 
   def add_filter_options(opts)
+    add_spec_filter_options(opts)
+    add_targeting_options(opts)
+  end
+
+  def add_spec_filter_options(opts)
     opts.on("--min-score FLOAT", Float, "Minimum mutation score to pass") { |s| @options[:min_score] = s }
     opts.on("--spec FILES", Array, "Spec files to run (comma-separated)") { |f| @options[:spec_files] = f }
     opts.on("--spec-dir DIR", "Include all specs in DIR") { |d| expand_spec_dir(d) }
     opts.on("--spec-pattern GLOB",
             "Restrict resolved spec candidates to files matching GLOB") { |p| @options[:spec_pattern] = p }
+  end
+
+  def add_targeting_options(opts)
     opts.on("--no-example-targeting",
             "Disable per-mutation example targeting (run all examples in resolved spec files)") do
       @options[:example_targeting] = false
@@ -76,13 +86,19 @@ class Evilution::CLI::Parser::OptionsBuilder
             "Use --no-incremental to override `incremental: true` from the config file for one run.") do |v|
       @options[:incremental] = v
     end
+    opts.on("--stdin", "Read target file paths from stdin (one per line)") { @options[:stdin] = true }
+  end
+
+  def add_runner_mode_options(opts)
     opts.on("--integration NAME", "Test integration: rspec, minitest (default: rspec)") { |i| @options[:integration] = i }
     opts.on("--isolation STRATEGY", "Isolation: auto, fork, in_process (default: auto)") { |s| @options[:isolation] = s }
     opts.on("--preload FILE", "Preload FILE in the parent process before forking " \
                               "(default: auto-detect spec/rails_helper.rb -> spec/spec_helper.rb -> " \
                               "test/test_helper.rb for Rails projects)") { |f| @options[:preload] = f }
     opts.on("--no-preload", "Disable parent-process preload even for Rails projects") { @options[:preload] = false }
-    opts.on("--stdin", "Read target file paths from stdin (one per line)") { @options[:stdin] = true }
+  end
+
+  def add_output_options(opts)
     opts.on("--suggest-tests", "Generate concrete test code in suggestions (RSpec or Minitest)") { @options[:suggest_tests] = true }
     opts.on("--no-progress", "Disable progress bar") { @options[:progress] = false }
     opts.on("--quiet-children",
@@ -103,6 +119,12 @@ class Evilution::CLI::Parser::OptionsBuilder
   end
 
   def add_extra_flag_options(opts)
+    add_mutation_behavior_options(opts)
+    add_session_persistence_options(opts)
+    add_misc_extra_options(opts)
+  end
+
+  def add_mutation_behavior_options(opts)
     opts.on("--skip-heredoc-literals", "Skip all string literal mutations inside heredocs") { @options[:skip_heredoc_literals] = true }
     opts.on("--related-specs-heuristic", "Append related request/integration/feature/system specs for includes() mutations") do
       @options[:related_specs_heuristic] = true
@@ -112,8 +134,14 @@ class Evilution::CLI::Parser::OptionsBuilder
       @options[:fallback_to_full_suite] = true
     end
     opts.on("--show-disabled", "Report mutations skipped by # evilution:disable") { @options[:show_disabled] = true }
+  end
+
+  def add_session_persistence_options(opts)
     opts.on("--baseline-session PATH", "Compare against a baseline session in HTML report") { |p| @options[:baseline_session] = p }
     opts.on("--save-session", "Save session results to .evilution/results/") { @options[:save_session] = true }
+  end
+
+  def add_misc_extra_options(opts)
     opts.on("-e", "--eval CODE", "Evaluate code snippet (for util mutation)") { |c| @options[:eval] = c }
     opts.on("-v", "--verbose", "Verbose output") { @options[:verbose] = true }
     opts.on("-q", "--quiet", "Suppress output") { @options[:quiet] = true }

data/lib/evilution/cli/parser/stdin_reader.rb

@@ -22,7 +22,7 @@ class Evilution::CLI::Parser::StdinReader
       line = line.strip
       lines << line unless line.empty?
     end
-    files, ranges = Evilution::CLI::Parser::FileArgs.parse(lines)
-    Result.new(files, ranges, nil)
+    parsed_paths = Evilution::CLI::Parser::FileArgs.parse(lines)
+    Result.new(parsed_paths.files, parsed_paths.ranges, nil)
   end
 end

data/lib/evilution/cli/parser.rb

@@ -20,7 +20,9 @@ class Evilution::CLI::Parser
 
     preprocess_flags
     remaining = OptionsBuilder.build(@options).parse!(@argv)
-    @files, @line_ranges = FileArgs.parse(remaining)
+    parsed_paths = FileArgs.parse(remaining)
+    @files = parsed_paths.files
+    @line_ranges = parsed_paths.ranges
     read_stdin_files if @options.delete(:stdin) && %i[run subjects].include?(@command)
     build_parsed_args
   end
@@ -37,27 +39,23 @@ class Evilution::CLI::Parser
   def preprocess_flags
     result = []
     i = 0
-    while i < @argv.length
-      arg = @argv[i]
-      if arg == "--fail-fast"
-        next_arg = @argv[i + 1]
+    i = consume_token(i, result) while i < @argv.length
+    @argv = result
+  end
 
-        if next_arg && next_arg.match?(/\A-?\d+\z/)
-          @options[:fail_fast] = next_arg
-          i += 2
-        else
-          result << arg
-          i += 1
-        end
-      elsif arg.start_with?("--fail-fast=")
-        @options[:fail_fast] = arg.delete_prefix("--fail-fast=")
-        i += 1
-      else
-        result << arg
-        i += 1
-      end
+  def consume_token(i, result)
+    arg = @argv[i]
+    next_arg = @argv[i + 1]
+    if arg == "--fail-fast" && !next_arg.nil? && next_arg.match?(/\A-?\d+\z/)
+      @options[:fail_fast] = next_arg
+      return i + 2
     end
-    @argv = result
+    if arg.start_with?("--fail-fast=")
+      @options[:fail_fast] = arg.delete_prefix("--fail-fast=")
+      return i + 1
+    end
+    result << arg
+    i + 1
   end
 
   def read_stdin_files

data/lib/evilution/cli/printers/environment.rb

@@ -3,6 +3,12 @@
 require_relative "../printers"
 
 class Evilution::CLI::Printers::Environment
+  PLAIN_SETTINGS = %i[
+    timeout format integration jobs isolation baseline incremental
+    verbose quiet progress min_score suggest_tests save_session
+    skip_heredoc_literals
+  ].freeze
+
   def initialize(config, config_file:)
     @config = config
     @config_file = config_file
@@ -30,24 +36,18 @@ class Evilution::CLI::Printers::Environment
   end
 
   def settings_lines
-    [
-      "  timeout: #{@config.timeout}",
-      "  format: #{@config.format}",
-      "  integration: #{@config.integration}",
-      "  jobs: #{@config.jobs}",
-      "  isolation: #{@config.isolation}",
-      "  baseline: #{@config.baseline}",
-      "  incremental: #{@config.incremental}",
-      "  verbose: #{@config.verbose}",
-      "  quiet: #{@config.quiet}",
-      "  progress: #{@config.progress}",
-      "  fail_fast: #{@config.fail_fast || "(disabled)"}",
-      "  min_score: #{@config.min_score}",
-      "  suggest_tests: #{@config.suggest_tests}",
-      "  save_session: #{@config.save_session}",
-      "  target: #{@config.target || "(all files)"}",
-      "  skip_heredoc_literals: #{@config.skip_heredoc_literals}",
-      "  ignore_patterns: #{@config.ignore_patterns.empty? ? "(none)" : @config.ignore_patterns.inspect}"
-    ]
+    plain_lines = PLAIN_SETTINGS.map { |k| setting_line(k, @config.public_send(k)) }
+    plain_lines.insert(10, setting_line(:fail_fast, @config.fail_fast || "(disabled)"))
+    plain_lines.insert(14, setting_line(:target, @config.target || "(all files)"))
+    plain_lines << setting_line(:ignore_patterns, format_ignore_patterns(@config.ignore_patterns))
+    plain_lines
+  end
+
+  def setting_line(key, value)
+    "  #{key}: #{value}"
+  end
+
+  def format_ignore_patterns(patterns)
+    patterns.empty? ? "(none)" : patterns.inspect
   end
 end

data/lib/evilution/cli/printers/session_diff.rb

@@ -32,16 +32,16 @@ class Evilution::CLI::Printers::SessionDiff
   end
 
   def print_summary(io, summary)
-    delta_str = format("%+.2f%%", summary.score_delta * 100)
     io.puts("Session Diff")
     io.puts("=" * 40)
-    io.puts(format("Base score:  %<score>6.2f%%  (%<killed>d/%<total>d killed)",
-                   score: summary.base_score * 100, killed: summary.base_killed,
-                   total: summary.base_total))
-    io.puts(format("Head score:  %<score>6.2f%%  (%<killed>d/%<total>d killed)",
-                   score: summary.head_score * 100, killed: summary.head_killed,
-                   total: summary.head_total))
-    io.puts("Delta:       #{delta_str}")
+    io.puts(score_line("Base", summary.base_score, summary.base_killed, summary.base_total))
+    io.puts(score_line("Head", summary.head_score, summary.head_killed, summary.head_total))
+    io.puts("Delta:       #{format("%+.2f%%", summary.score_delta * 100)}")
+  end
+
+  def score_line(label, score, killed, total)
+    format("%<label>s score:  %<score>6.2f%%  (%<killed>d/%<total>d killed)",
+           label: label, score: score * 100, killed: killed, total: total)
   end
 
   def print_section(io, title, mutations, color)

data/lib/evilution/compare/normalizer.rb

@@ -57,11 +57,7 @@ class Evilution::Compare::Normalizer
   private
 
   def build_evilution_record(entry, index:)
-    file_path = entry["file"] or raise Evilution::Compare::InvalidInput.new("missing 'file' in record", index: index)
-    line = entry["line"] or raise Evilution::Compare::InvalidInput.new("missing 'line' in record", index: index)
-    diff = entry["diff"].to_s
-    status = EVILUTION_STATUS_MAP[entry["status"]] ||
-             raise(Evilution::Compare::InvalidInput.new("unknown status #{entry["status"].inspect}", index: index))
+    file_path, line, diff, status = extract_evilution_fields(entry, index)
     Evilution::Compare::Record.new(
       source: :evilution,
       file_path: file_path,
@@ -74,6 +70,15 @@ class Evilution::Compare::Normalizer
     )
   end
 
+  def extract_evilution_fields(entry, index)
+    file_path = entry["file"] or raise Evilution::Compare::InvalidInput.new("missing 'file' in record", index: index)
+    line = entry["line"] or raise Evilution::Compare::InvalidInput.new("missing 'line' in record", index: index)
+    diff = entry["diff"].to_s
+    status = EVILUTION_STATUS_MAP[entry["status"]] ||
+             raise(Evilution::Compare::InvalidInput.new("unknown status #{entry["status"].inspect}", index: index))
+    [file_path, line, diff, status]
+  end
+
   def build_mutant_record(cov, source_path:, index:)
     mr = cov["mutation_result"] or raise Evilution::Compare::InvalidInput.new("missing mutation_result", index: index)
     cr = cov["criteria_result"] or raise Evilution::Compare::InvalidInput.new("missing criteria_result", index: index)

data/lib/evilution/config/file_loader.rb

@@ -5,12 +5,19 @@ require "yaml"
 module Evilution::Config::FileLoader
   module_function
 
+  # Keys recognised in YAML config files. `target_files` is intentionally excluded
+  # because it is CLI-positional (the file paths after `evilution run`).
+  KNOWN_KEYS = (Evilution::Config::DEFAULTS.keys + %i[hooks]).uniq.freeze
+
   def load
     Evilution::Config::CONFIG_FILES.each do |path|
       next unless File.exist?(path)
 
       data = YAML.safe_load_file(path, symbolize_names: true)
-      return data.is_a?(Hash) ? data : {}
+      return {} unless data.is_a?(Hash)
+
+      validate_schema!(data, path: path) if data.key?(:schema_version)
+      return data
     rescue Psych::SyntaxError, Psych::DisallowedClass => e
       raise Evilution::ConfigError.new("failed to parse config file #{path}: #{e.message}", file: path)
     rescue SystemCallError => e
@@ -19,4 +26,36 @@ module Evilution::Config::FileLoader
 
     {}
   end
+
+  def validate_schema!(data, path:)
+    validate_schema_version_value!(data[:schema_version], path: path)
+    validate_known_keys!(data.keys, path: path)
+  end
+
+  def validate_schema_version_value!(version, path:)
+    unless version.is_a?(Integer) && version.positive?
+      raise Evilution::ConfigError.new(
+        "invalid schema_version #{version.inspect} in #{path}: must be a positive Integer",
+        file: path
+      )
+    end
+
+    return if version <= Evilution::Config::CURRENT_SCHEMA_VERSION
+
+    raise Evilution::ConfigError.new(
+      "schema_version #{version} in #{path} is newer than this evilution gem supports " \
+      "(current: #{Evilution::Config::CURRENT_SCHEMA_VERSION}). Upgrade the gem.",
+      file: path
+    )
+  end
+
+  def validate_known_keys!(keys, path:)
+    unknown = keys - KNOWN_KEYS
+    return if unknown.empty?
+
+    raise Evilution::ConfigError.new(
+      "unknown key(s) #{unknown.inspect} in #{path}. Known keys: #{KNOWN_KEYS.sort.inspect}",
+      file: path
+    )
+  end
 end

data/lib/evilution/config.rb

@@ -6,8 +6,10 @@ require_relative "spec_selector"
 
 class Evilution::Config
   CONFIG_FILES = %w[.evilution.yml config/evilution.yml].freeze
+  CURRENT_SCHEMA_VERSION = 1
 
   DEFAULTS = {
+    schema_version: CURRENT_SCHEMA_VERSION,
     timeout: 30, format: :text, target: nil, min_score: 0.0, integration: :rspec,
     verbose: false, quiet: false, jobs: 1, fail_fast: nil, baseline: true,
     isolation: :auto, incremental: false, suggest_tests: false, progress: true,
@@ -21,7 +23,7 @@ class Evilution::Config
     profile: :default
   }.freeze
 
-  attr_reader :target_files, :timeout, :format,
+  attr_reader :target_files, :schema_version, :timeout, :format,
               :target, :min_score, :integration, :verbose, :quiet,
               :jobs, :fail_fast, :baseline, :isolation, :incremental, :suggest_tests,
               :progress, :save_session, :line_ranges, :spec_files, :hooks,
@@ -112,6 +114,13 @@ class Evilution::Config
       # Evilution configuration
       # See: https://github.com/marinazzio/evilution
 
+      # Schema version for this config file (current: #{CURRENT_SCHEMA_VERSION}).
+      # Declaring schema_version opts the file into strict validation:
+      # unknown keys raise ConfigError, and a future schema_version is
+      # rejected so an old gem cannot silently misread a newer config.
+      # Omit to keep the legacy lenient behavior (unknown keys ignored).
+      schema_version: #{CURRENT_SCHEMA_VERSION}
+
       # Per-mutation timeout in seconds (default: 30)
       # timeout: 30
 
@@ -208,6 +217,7 @@ class Evilution::Config
 
   SIMPLE_ATTR_TRANSFORMS = {
     target_files: ->(v) { Array(v) },
+    schema_version: nil,
     timeout: nil,
     format: :to_sym.to_proc,
     target: nil,
@@ -239,17 +249,17 @@ class Evilution::Config
     end
   end
 
+  VALIDATED_ATTRS = %i[
+    integration jobs fail_fast isolation ignore_patterns
+    hooks preload spec_mappings spec_pattern profile
+  ].freeze
+  private_constant :VALIDATED_ATTRS
+
   def assign_validated_attributes(merged)
-    @integration     = Validators::Integration.call(merged[:integration])
-    @jobs            = Validators::Jobs.call(merged[:jobs])
-    @fail_fast       = Validators::FailFast.call(merged[:fail_fast])
-    @isolation       = Validators::Isolation.call(merged[:isolation])
-    @ignore_patterns = Validators::IgnorePatterns.call(merged[:ignore_patterns])
-    @hooks           = Validators::Hooks.call(merged[:hooks])
-    @preload         = Validators::Preload.call(merged[:preload])
-    @spec_mappings   = Validators::SpecMappings.call(merged[:spec_mappings])
-    @spec_pattern    = Validators::SpecPattern.call(merged[:spec_pattern])
-    @profile         = Validators::Profile.call(merged[:profile])
+    VALIDATED_ATTRS.each do |key|
+      validator = Validators.const_get(key.to_s.split("_").map(&:capitalize).join)
+      instance_variable_set(:"@#{key}", validator.call(merged[key]))
+    end
   end
 
   def assign_example_targeting(merged)

data/lib/evilution/disable_comment.rb

@@ -20,21 +20,30 @@ class Evilution::DisableComment
   private
 
   def classify_comments(parse_result, source)
-    parse_result.comments.filter_map do |comment|
-      loc = comment.location
-      text = source.byteslice(loc.start_offset, loc.end_offset - loc.start_offset)
-                   .force_encoding(source.encoding)
-
-      if text.match?(DISABLE_MARKER)
-        line = source.lines[loc.start_line - 1]
-        standalone = line.strip == text.strip
-        { type: :disable, line: loc.start_line, standalone: standalone }
-      elsif text.match?(ENABLE_MARKER)
-        { type: :enable, line: loc.start_line }
-      end
+    parse_result.comments.filter_map { |comment| classify_comment(comment, source) }
+  end
+
+  def classify_comment(comment, source)
+    loc = comment.location
+    text = comment_text(loc, source)
+
+    if text.match?(DISABLE_MARKER)
+      disable_entry(loc, text, source)
+    elsif text.match?(ENABLE_MARKER)
+      { type: :enable, line: loc.start_line }
     end
   end
 
+  def comment_text(loc, source)
+    source.byteslice(loc.start_offset, loc.end_offset - loc.start_offset)
+          .force_encoding(source.encoding)
+  end
+
+  def disable_entry(loc, text, source)
+    standalone = source.lines[loc.start_line - 1].strip == text.strip
+    { type: :disable, line: loc.start_line, standalone: standalone }
+  end
+
   def scan_comments(comments, method_ranges, total_lines)
     disabled = []
     range_start = nil

data/lib/evilution/equivalent/heuristic/dead_code.rb

@@ -3,8 +3,15 @@
 require_relative "../heuristic"
 
 class Evilution::Equivalent::Heuristic::DeadCode
+  # Both operators produce statement-deletion-shaped edits. MutationPlanner
+  # dedupes by (file_path, mutated_source); whichever operator is registered
+  # first surfaces its name on the surviving mutation. Classify equivalence
+  # by edit shape, not by operator label, so dead-code classification holds
+  # regardless of registry order (EV-74e3 PR #1236 review).
+  STATEMENT_DELETION_OPERATORS = %w[statement_deletion last_expression_removal].to_set.freeze
+
   def match?(mutation)
-    return false unless mutation.operator_name == "statement_deletion"
+    return false unless STATEMENT_DELETION_OPERATORS.include?(mutation.operator_name)
 
     node = mutation.subject.node
     return false unless node