evilution 1.3.0 → 1.5.0

data/lib/evilution/integration/rspec/state_guard.rb

@@ -12,8 +12,10 @@ require_relative "state_guard/world_example_groups"
 require_relative "state_guard/world_sources_by_path"
 require_relative "state_guard/world_filtered_examples"
 require_relative "state_guard/reporter_arrays"
+require_relative "state_guard/anonymous_example_group_examples"
 require_relative "state_guard/example_groups_constants"
 require_relative "state_guard/configuration_state"
+require_relative "../../diagnostic"
 
 class Evilution::Integration::RSpec::StateGuard
   DEFAULT_STRATEGIES = [
@@ -22,6 +24,7 @@ class Evilution::Integration::RSpec::StateGuard
     WorldSourcesByPath.new,
     WorldFilteredExamples.new,
     ReporterArrays.new,
+    AnonymousExampleGroupExamples.new,
     ExampleGroupsConstants.new,
     ConfigurationState.new
   ].freeze
@@ -43,6 +46,6 @@ class Evilution::Integration::RSpec::StateGuard
   def release_one(strategy, captured)
     strategy.release(captured)
   rescue StandardError => e
-    warn "[evilution] state release failed for #{strategy.class.name}: #{e.class}: #{e.message}"
+    Evilution::Diagnostic.warn("[evilution] state release failed for #{strategy.class.name}: #{e.class}: #{e.message}")
   end
 end

data/lib/evilution/integration/rspec.rb

@@ -2,6 +2,7 @@
 
 require "stringio"
 require_relative "base"
+require_relative "known_failures"
 require_relative "../spec_resolver"
 require_relative "../spec_selector"
 require_relative "../related_spec_heuristic"
@@ -24,6 +25,7 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     fallback_to_full_suite: false,
     spec_selector: nil,
     example_filter: nil,
+    known_failures: [],
     framework_loader: FrameworkLoader.new,
     test_file_resolver: nil,
     example_filter_applier: nil,
@@ -44,6 +46,7 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     @crash_detector_lifecycle = crash_detector_lifecycle
     @result_builder = result_builder
     @state_guard = state_guard
+    @known_failures = Evilution::Integration::KnownFailures.new(known_failures)
     super(hooks: hooks)
   end
 
@@ -71,7 +74,7 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     return @result_builder.unresolved_example(mutation) if targets.nil?
 
     result = run_targets(targets)
-    return result unless confirm_survivor?(result, targets, files)
+    return result unless confirm?(result, targets, files)
 
     run_targets(files)
   end
@@ -85,8 +88,12 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   # So a survivor is re-run against the whole resolved file, and that run is the
   # one reported. Only survivors pay for it, and only where the subset was
   # actually narrower than the file.
-  def confirm_survivor?(result, targets, files)
-    result[:passed] && targets != files
+  #
+  # The same goes for a subset in which nothing failed but examples that were
+  # failing before any mutation ran: that is no verdict either, and the rest of
+  # the file may hold one.
+  def confirm?(result, targets, files)
+    (result[:passed] || result[:known_failures_only]) && targets != files
   end
 
   def run_targets(targets)
@@ -142,7 +149,8 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
       claim_rspec_streams(out, err)
       detector = @crash_detector_lifecycle.register
       status = ::RSpec::Core::Runner.run(args, err, out)
-      @result_builder.from_run(status, command, detector, examples_loaded:)
+      flagged = known_failures_only?(status)
+      @result_builder.from_run(status, command, detector, examples_loaded:, known_failures_only: flagged)
     rescue StandardError => e
       { passed: false, error: e.message, test_command: command }
     ensure
@@ -188,12 +196,22 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     nil
   end
 
+  # Whether the run failed on nothing but examples the baseline already saw
+  # failing. Decided here, in the process that ran them: the names of every
+  # failing example need not travel back, only the answer.
+  def known_failures_only?(status)
+    return false if status.zero? || @known_failures.empty?
+
+    @known_failures.only?(ExampleIds.failed(::RSpec.world))
+  end
+
   def reset_examples
     ::RSpec.respond_to?(:clear_examples) ? ::RSpec.clear_examples : ::RSpec.reset
   end
 end
 
 require_relative "rspec/framework_loader"
+require_relative "rspec/example_ids"
 require_relative "rspec/test_file_resolver"
 require_relative "rspec/unresolved_spec_warner"
 require_relative "rspec/example_filter_applier"

data/lib/evilution/integration/test_unit/result_builder.rb

@@ -21,6 +21,12 @@ module Evilution::Integration::TestUnit::ResultBuilder
     end
   end
 
+  # Every test that failed was already failing in the baseline. Still a
+  # failed run, but flagged, so it is not taken for a kill.
+  def known_failures_only(command)
+    { passed: false, known_failures_only: true, test_command: command }
+  end
+
   def no_tests_ran(command)
     {
       passed: false,

data/lib/evilution/integration/test_unit/test_ids.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Names a Test::Unit test the same way in the baseline and in a mutation run:
+# the name the framework gives it, `test_adds(CalcTest)`.
+module Evilution::Integration::TestUnit::TestIds
+  # Only failures and errors fail a run; pendings, omissions and notifications
+  # are faults too, and are left out.
+  def self.faults(result)
+    result.failures + result.errors
+  end
+
+  # The ids of the tests that failed or raised in a finished run.
+  def self.failed(result)
+    faults(result).map(&:test_name)
+  end
+end

data/lib/evilution/integration/test_unit.rb

@@ -2,9 +2,12 @@
 
 require_relative "base"
 require_relative "test_unit_crash_detector"
+require_relative "known_failures"
 require_relative "loading/test_load_path"
+require_relative "loading/test_class_cache"
 require_relative "../spec_resolver"
 require_relative "../spec_selector"
+require_relative "../baseline"
 
 require_relative "../integration"
 
@@ -28,6 +31,12 @@ class Evilution::Integration::TestUnit < Evilution::Integration::Base
     Evilution::SpecResolver.new(test_dir: "test", test_suffix: "_test.rb", request_dir: "integration")
   end
 
+  # Shared by every instance: the canary and the mutation runs build their
+  # own, and a file loaded for one must not be loaded again for the other.
+  def self.test_classes
+    @test_classes ||= Evilution::Integration::Loading::TestClassCache.new { SubjectClassRegistry.descendants }
+  end
+
   def self.baseline_options
     {
       runner: baseline_runner,
@@ -40,25 +49,41 @@ class Evilution::Integration::TestUnit < Evilution::Integration::Base
     require_relative "test_unit/framework_loader"
     require_relative "test_unit/subject_class_registry"
     require_relative "test_unit/dispatcher"
+    require_relative "test_unit/test_ids"
     FrameworkLoader.new.call
     files = baseline_test_files(test_file)
     Evilution::Integration::Loading::TestLoadPath.add!(files)
     new_classes = SubjectClassRegistry.newly_loaded do
       files.each { |f| load(File.expand_path(f)) }
     end
-    Dispatcher.call(new_classes, name: "evilution baseline").passed?
+    baseline_report(Dispatcher.call(new_classes, name: "evilution baseline"))
+  end
+
+  def self.baseline_report(result)
+    Evilution::Baseline::Report.build(
+      passed: result.passed?, failures: baseline_failures(result), failed_ids: TestIds.failed(result)
+    )
+  end
+
+  def self.baseline_failures(result)
+    TestIds.faults(result).map do |fault|
+      { id: fault.test_name, description: "", message: fault.message }
+    end
   end
 
   def self.baseline_test_files(test_file)
     File.directory?(test_file) ? Dir.glob(File.join(test_file, "**/*_test.rb")) : [test_file]
   end
 
-  def initialize(test_files: nil, hooks: nil, fallback_to_full_suite: false, spec_selector: nil)
+  # known_failures: the ids of the tests the baseline saw failing (see TestIds).
+  def initialize(test_files: nil, hooks: nil, fallback_to_full_suite: false, spec_selector: nil, known_failures: [])
     require_relative "test_unit/framework_loader"
     require_relative "test_unit/subject_class_registry"
     require_relative "test_unit/dispatcher"
     require_relative "test_unit/test_file_resolver"
     require_relative "test_unit/result_builder"
+    require_relative "test_unit/test_ids"
+    @known_failures = Evilution::Integration::KnownFailures.new(known_failures)
     @framework_loader = FrameworkLoader.new
     @file_resolver = TestFileResolver.new(
       test_files: test_files,
@@ -97,22 +122,25 @@ class Evilution::Integration::TestUnit < Evilution::Integration::Base
 
     detector = reset_crash_detector
     result = Dispatcher.call(new_classes, name: "evilution-mutation")
+    # Before the crash check: a test that was already failing may fail by
+    # raising now, and a crash in it is no more a kill than its failure was.
+    return ResultBuilder.known_failures_only(command) if @known_failures.only?(TestIds.failed(result))
+
     result.faults.each { |fault| detector.record(fault) }
     ResultBuilder.call(passed: result.passed?, command: command, detector: detector)
   end
 
   def load_test_classes(files)
     Evilution::Integration::Loading::TestLoadPath.add!(files)
-    SubjectClassRegistry.newly_loaded do
-      files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
-    end
+    paths = files.map { |f| File.expand_path(f, Evilution.project_base_dir) }
+    self.class.test_classes.fetch(paths) { |path| load(path) }
   end
 
   # Test::Unit has no public registry-clear analogous to
-  # Minitest::Runnable.runnables.clear. SubjectClassRegistry's newly_loaded
-  # block scopes each dispatch to classes loaded in *this* round, so stale
-  # classes from prior mutations sit dormant on ObjectSpace without polluting
-  # the run. #reset_state stays as a contract no-op for parity with Minitest.
+  # Minitest::Runnable.runnables.clear. Each dispatch is handed the classes of
+  # the files resolved for this mutation, so classes of other files sit
+  # dormant on ObjectSpace without polluting the run. #reset_state stays as a
+  # contract no-op for parity with Minitest.
   def reset_state
     # no-op — see comment above
   end

data/lib/evilution/isolation/fork.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "English"
 require "fileutils"
 require "tmpdir"
 require_relative "../memory"
@@ -55,8 +56,23 @@ class Evilution::Isolation::Fork
   # 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.
+  #
+  # The at_exit hook covers a child that never gets that far. The normal path
+  # ends in `exit!`, which skips it, so it runs only when the child is dying.
+  #
+  # Both reports go through method objects taken before the test command runs.
+  # When the mutation under test is one of this file, the child evaluates the
+  # mutated source and the methods here are replaced; a method object keeps the
+  # definition the child started with, so the result is not written by the
+  # mutant it describes.
   def spawn_child(read_io, write_io, sandbox_dir, mutation, test_command)
     @supervisor.spawn(sandbox_dir: sandbox_dir) do
+      write = method(:write_result)
+      report_death = method(:report_death)
+      child_pid = Process.pid
+      # A process the tests fork inherits this hook and the pipe with it; its
+      # death is not the child's to report.
+      at_exit { report_death.call(write_io, $ERROR_INFO, write) if Process.pid == child_pid }
       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
@@ -67,18 +83,54 @@ class Evilution::Isolation::Fork
       # paths to Evilution::PROJECT_ROOT instead of the sandbox CWD.
       Dir.chdir(sandbox_dir)
       Evilution.in_isolated_worker!
+      Evilution.single_mutation_process!
       read_io.close
       suppress_child_output
       @hooks.fire(:worker_process_start, mutation:) if @hooks
       result = execute_in_child(mutation, test_command)
-      payload = Marshal.dump(result)
-      write_io.write([payload.bytesize].pack("N"))
-      write_io.write(payload)
-      write_io.close
+      write.call(write_io, result)
       exit!(result[:passed] ? 0 : 1)
     end
   end
 
+  def write_result(write_io, result)
+    payload = Marshal.dump(result)
+    write_io.write([payload.bytesize].pack("N"))
+    write_io.write(payload)
+    write_io.close
+  end
+
+  # Some exceptions reach no `rescue` in the child. `execute_in_child` leaves
+  # everything that is not a ScriptError or StandardError alone, and Ruby may
+  # run neither `rescue` nor `ensure` when the stack overflows through
+  # `const_missing`, which a mutation of a process-wide `const_missing` does.
+  # Without a result the parent sees only an exit status.
+  #
+  # A child that exits on purpose or on a signal keeps its status as the
+  # report: the first is its own decision, the second is usually the parent's.
+  def report_death(write_io, error, write)
+    return if error.nil? || write_io.closed?
+    return if error.is_a?(SystemExit) || error.is_a?(SignalException)
+
+    write.call(write_io, death_result(error))
+  end
+
+  # Dying while the tests run, after the mutated source loaded, is what a test
+  # that crashes does, and counts the same. Dying before that says nothing
+  # about the tests.
+  def death_result(error)
+    testing = Evilution.died_running_tests?(error)
+    phase = testing ? "while running the tests" : "before the tests ran"
+    result = {
+      passed: false,
+      error: "child died #{phase}: #{error.class}: #{error.message}",
+      error_class: error.class.name,
+      error_backtrace: Array(error.backtrace).first(5)
+    }
+    result[:test_crashed] = true if testing
+    result
+  end
+
   # 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
@@ -203,28 +255,48 @@ class Evilution::Isolation::Fork
     buf
   end
 
+  # What arrives is not always what the child wrote: every process the child
+  # forks inherits the write end of the pipe. A result that does not load, or
+  # loads to something other than a result, costs this mutation its verdict
+  # and nothing more.
   def decode_payload(data, handle = nil, terminated: false)
     return empty_result(handle, terminated: terminated) if data.nil? || data.empty?
 
-    { timeout: false }.merge(Marshal.load(data))
+    result = Marshal.load(data)
+    return unreadable_result(handle, "expected a Hash, got #{result.class}", terminated: terminated) unless result.is_a?(Hash)
+
+    { timeout: false }.merge(result)
+  rescue TypeError, ArgumentError => e
+    unreadable_result(handle, "#{e.class}: #{e.message.gsub(/\s+/, " ")}", terminated: terminated)
   end
 
   def empty_result(handle, terminated: false)
     { timeout: false, passed: false, error: child_death_reason(handle, terminated: terminated) }
   end
 
+  def unreadable_result(handle, detail, terminated: false)
+    ending = child_ending(handle, terminated: terminated)
+    subject = ending.nil? ? "child's result" : "#{ending}; its result"
+    { timeout: false, passed: false, error: "#{subject} was unreadable (#{detail})" }
+  end
+
   # A child that wrote no payload has usually left its stdout/stderr capture
   # empty too, so its termination status is the only evidence of what happened.
   # Reporting it separates a segfault from an OOM kill from a clean early exit,
   # all of which reach this path identically.
   def child_death_reason(handle, terminated: false)
-    return "child was terminated after the reap deadline without writing a result" if terminated
+    ending = child_ending(handle, terminated: terminated)
+    ending.nil? ? "empty result from child" : "#{ending} without writing a result"
+  end
+
+  def child_ending(handle, terminated: false)
+    return "child was terminated after the reap deadline" if terminated
 
     status = handle.nil? ? nil : handle.status
-    return "empty result from child" unless status.is_a?(Process::Status)
-    return "child exited #{status.exitstatus} without writing a result" unless status.signaled?
+    return nil unless status.is_a?(Process::Status)
+    return "child exited #{status.exitstatus}" unless status.signaled?
 
-    "child died on #{signal_name(status.termsig)} without writing a result"
+    "child died on #{signal_name(status.termsig)}"
   end
 
   def signal_name(termsig)
@@ -239,7 +311,7 @@ class Evilution::Isolation::Fork
 
   def classify_status(result)
     return :timeout if result[:timeout]
-    return :killed if result[:test_crashed]
+    return :killed if result[:test_crashed] || result[:load_crashed]
     return :unresolved if result[:unresolved]
     return :error if result[:error]
     return :survived if result[:passed]
@@ -263,7 +335,8 @@ class Evilution::Isolation::Fork
         message: result[:error],
         klass: result[:error_class],
         backtrace: result[:error_backtrace]
-      )
+      ),
+      known_failures_only: result[:known_failures_only]
     )
   end
 end

data/lib/evilution/isolation/in_process.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "English"
 require "fileutils"
 require "timeout"
 require "tmpdir"
@@ -9,14 +10,84 @@ require_relative "../result/mutation_result"
 require_relative "../isolation"
 
 class Evilution::Isolation::InProcess
+  # Raised into the run when its time is up. A SignalException, because the
+  # timeout has to end the whole test run and a test framework rescues nearly
+  # everything a test raises, Timeout::Error included: it would record one
+  # failed test and go on to the next, which may reach the same endless loop
+  # with no timer left to stop it. Minitest, Test::Unit and RSpec all let a
+  # SignalException through.
+  #
+  # Not an Interrupt, though it is one of those: tooling that handles the
+  # user's Ctrl-C (maxitest) rescues Interrupt and skips every test from then
+  # on, for the rest of the process.
+  class Expired < SignalException
+    def initialize(_message = nil)
+      super("SIGALRM")
+    end
+  end
+
   @null_out = File.open(File::NULL, "w")
   @null_err = File.open(File::NULL, "w")
+  @died = false
 
   class << self
     attr_reader :null_out, :null_err
+
+    # The mutation this process is testing, remembered so that a process dying
+    # in the middle of it can say which one it was. Ruby runs no `ensure` on
+    # some deaths (a stack overflow through `const_missing`, under the usual
+    # stack limit), so the mutation is still on record when the at_exit hook
+    # asks. The process is recorded with it: a process the tests fork inherits
+    # both the record and the hook, and its death is not this run's.
+    #
+    # The error stream is recorded as well, as it is before the mutation is
+    # tested: `$stderr` is the null stream while it is, and on such a death
+    # nothing puts it back.
+    def watch(mutation)
+      @watched = [Process.pid, mutation, $stderr]
+      return if @death_hook_installed
+
+      @death_hook_installed = true
+      at_exit { report_death($ERROR_INFO) }
+    end
+
+    def unwatch
+      @watched = nil
+      @died = false
+    end
+
+    def watched
+      pid, mutation, = @watched
+      mutation if pid == Process.pid
+    end
+
+    def report_death(error, stream: nil)
+      mutation = watched
+      return if mutation.nil? || error.nil?
+      return if error.is_a?(SystemExit) || error.is_a?(SignalException)
+
+      stream ||= @watched.last
+      stream.puts(
+        "[evilution] the run died while testing a mutation under in-process isolation: " \
+        "#{mutation} (#{error.class}: #{error.message}). " \
+        "In-process isolation cannot contain a mutation that takes the Ruby process down; " \
+        "re-run with --isolation fork."
+      )
+      stream.flush
+      @died = true
+    end
+
+    # Whether this process is ending on a death that was reported. Such a run
+    # measured nothing, which whoever decides the process status has to know:
+    # the hook that reports the death runs before the project's own, and an
+    # exit from there would skip them.
+    def died?
+      @died
+    end
   end
 
   def call(mutation:, test_command:, timeout:)
+    self.class.watch(mutation)
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     rss_before = Evilution::Memory.rss_kb
     sandbox_dir = Dir.mktmpdir("evilution-run")
@@ -27,13 +98,14 @@ class Evilution::Isolation::InProcess
 
     build_mutation_result(mutation, result, duration, rss_before, rss_after, delta)
   ensure
+    self.class.unwatch
     FileUtils.rm_rf(sandbox_dir) if sandbox_dir
   end
 
   private
 
   # The Dir.chdir block is inside the Timeout.timeout block so that a
-  # Timeout::Error raised mid-call still unwinds through Dir.chdir's ensure
+  # timeout raised mid-call still unwinds through Dir.chdir's ensure
   # and restores the parent CWD before the rescue clause runs. The sandbox
   # contains any relative-path writes from path-relativizing mutations
   # (EV-wqxu / GH #1278). Evilution.with_isolated_worker signals the rest of
@@ -41,7 +113,7 @@ class Evilution::Isolation::InProcess
   # SourceEvaluator/Integration) to anchor project-relative paths to
   # PROJECT_ROOT for the duration of the call.
   def execute_with_timeout(mutation, test_command, timeout, sandbox_dir)
-    result = Timeout.timeout(timeout) do
+    result = Timeout.timeout(timeout, Expired) do
       Evilution.with_isolated_worker do
         Dir.chdir(sandbox_dir) do
           suppress_output { test_command.call(mutation) }
@@ -49,15 +121,34 @@ class Evilution::Isolation::InProcess
       end
     end
     { timeout: false }.merge(result)
-  rescue Timeout::Error
+  rescue Expired
     { timeout: true }
   rescue ScriptError, StandardError => e
+    failure_result(e, e.message)
+  rescue SignalException, SystemExit
+    raise
+  rescue Exception => e # rubocop:disable Lint/RescueException -- turned into this mutation's result
+    crash_result(e)
+  end
+
+  # An exception outside StandardError that no test framework held back: a
+  # stack overflow that unwound, most likely. Left alone it would end the run.
+  # Leaving the test run that way, after the mutated source loaded, is what a
+  # test that crashes does, and counts the same.
+  def crash_result(error)
+    message = "#{error.class}: #{error.message}"
+    return failure_result(error, message) unless Evilution.died_running_tests?(error)
+
+    failure_result(error, "test run ended by #{message}").merge(test_crashed: true)
+  end
+
+  def failure_result(error, message)
     {
       timeout: false,
       passed: false,
-      error: e.message,
-      error_class: e.class.name,
-      error_backtrace: Array(e.backtrace).first(5)
+      error: message,
+      error_class: error.class.name,
+      error_backtrace: Array(error.backtrace).first(5)
     }
   end
 
@@ -81,7 +172,7 @@ class Evilution::Isolation::InProcess
 
   def classify_status(result)
     return :timeout if result[:timeout]
-    return :killed if result[:test_crashed]
+    return :killed if result[:test_crashed] || result[:load_crashed]
     return :unresolved if result[:unresolved]
     return :error if result[:error]
     return :survived if result[:passed]
@@ -106,7 +197,8 @@ class Evilution::Isolation::InProcess
         message: result[:error],
         klass: result[:error_class],
         backtrace: result[:error_backtrace]
-      )
+      ),
+      known_failures_only: result[:known_failures_only]
     )
   end
 end

data/lib/evilution/mcp/info_tool/status_glossary.rb

@@ -8,7 +8,11 @@ module Evilution::MCP::InfoTool::StatusGlossary
     {
       "status" => "killed",
       "meaning" => "A test failed when the mutation was applied — the test suite caught the mutation. " \
-                   "This is the desired outcome.",
+                   "This is the desired outcome. Also a mutation that made its own file raise while loading, " \
+                   "before any test ran, when the original file still loads (error_message starts with " \
+                   "'load failed:'), and one whose test process died on an exception no handler saw while " \
+                   "the tests ran, as a crashing test would (error_message starts with 'child died' under " \
+                   "fork isolation, 'test run ended by' under in-process isolation).",
       "counted_in_score" => true
     },
     {
@@ -27,13 +31,20 @@ module Evilution::MCP::InfoTool::StatusGlossary
     {
       "status" => "error",
       "meaning" => "Mutation execution raised an unexpected error (syntax error at load time, " \
-                   "boot failure, test-infrastructure crash). The mutation could not be evaluated.",
+                   "boot failure, test-infrastructure crash). The mutation could not be evaluated. " \
+                   "Includes a test process that died on an unhandled exception before the tests ran " \
+                   "('child died ... before the tests ran'; error_class is the exception's own class), and " \
+                   "results that are no verdict on the mutation at all: a fork child's result that " \
+                   "was unreadable, a worker's result that could not be read (the worker was replaced), " \
+                   "a child that died on a signal without writing a result (SIGABRT: the Ruby VM aborted; " \
+                   "SIGSEGV; SIGKILL, e.g. out of memory). Re-run that one mutation; if a VM abort repeats, " \
+                   "the mutant crashes the interpreter.",
       "counted_in_score" => false
     },
     {
       "status" => "neutral",
-      "meaning" => "Baseline tests already failed before the mutation was applied — pre-existing " \
-                   "test-suite problem (flaky spec, infra collision, fixture setup failure). " \
+      "meaning" => "No verdict: the tests failed only on examples that were already failing before " \
+                   "the mutation was applied, or the test process crashed on infrastructure. " \
                    "Not a meaningful mutation signal.",
       "counted_in_score" => false
     },

data/lib/evilution/mcp/info_tool.rb

@@ -18,7 +18,8 @@ class Evilution::MCP::InfoTool < MCP::Tool
   tool_name "evilution-info"
   description "Discover what evilution sees before running any mutations. " \
               "One tool, five actions: " \
-              "'subjects' lists every mutatable method in the target files with its file, line, and mutation count; " \
+              "'subjects' lists every mutation subject in the target files (methods, and code outside them: " \
+              "constant assignments, scopes, AASM and callback declarations) with its file, line, and mutation count; " \
               "'tests' resolves which spec/test files cover the given sources (so you pick the right --spec before mutating); " \
               "'environment' dumps the effective config (version, ruby, config file, timeout, " \
               "integration, isolation, and every other setting); " \
@@ -36,7 +37,7 @@ class Evilution::MCP::InfoTool < MCP::Tool
         type: "string",
         enum: VALID_ACTIONS,
         description: "Which discovery operation to perform. " \
-                     "'subjects' lists mutatable methods; 'tests' resolves specs for sources; " \
+                     "'subjects' lists mutation subjects; 'tests' resolves specs for sources; " \
                      "'environment' dumps effective config; 'statuses' returns the result-status glossary; " \
                      "'feedback' returns the discussion URL and consent/privacy guidance."
       },

data/lib/evilution/mcp/mutate_tool/progress_streamer.rb

@@ -3,6 +3,7 @@
 require "json"
 require_relative "../mutate_tool"
 require_relative "../../reporter/suggestion"
+require_relative "../../diagnostic"
 
 module Evilution::MCP::MutateTool::ProgressStreamer
   def self.build(server_context:, suggest_tests:, integration:)
@@ -21,7 +22,7 @@ module Evilution::MCP::MutateTool::ProgressStreamer
         detail = build_suggestion_detail(result.mutation, suggestion)
         server_context.report_progress(survivor_index, message: ::JSON.generate(detail))
       rescue StandardError => e
-        warn "[evilution] progress stream disabled after error: #{e.class}: #{e.message}"
+        Evilution::Diagnostic.warn("[evilution] progress stream disabled after error: #{e.class}: #{e.message}")
         disabled = true
       end
     end