evilution 1.0.0 → 1.2.0

data/lib/evilution/ast/local_reads.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../ast"
+
+# Answers whether a scope body ever reads a given local name — the question an
+# operator asks before changing a parameter, since a parameter nothing reads
+# makes most such mutations behaviour-preserving.
+#
+# Scope-aware in the ways that matter here. A block shares the scope it is
+# written in, so a read inside one counts — unless the block binds the same name
+# itself, as a parameter or a block-local, in which case the read is of the
+# block's own variable. A nested def opens a scope of its own, where a local of
+# the same name is unrelated. A write is not a read.
+#
+# Shadowing is settled by Prism's own answer rather than by inspecting each
+# block's parameter list: a LocalVariableReadNode carries the number of scopes
+# between the read and the variable's declaration, so a read refers to the local
+# in question exactly when that depth matches the number of block scopes
+# descended to reach it.
+class Evilution::AST::LocalReads
+  def call(node, name, depth = 0)
+    return false if node.nil?
+    return true if reads?(node, name, depth)
+
+    node.compact_child_nodes.any? do |child|
+      next false if child.is_a?(Prism::DefNode)
+
+      call(child, name, depth + (scope?(child) ? 1 : 0))
+    end
+  end
+
+  private
+
+  def reads?(node, name, depth)
+    node.is_a?(Prism::LocalVariableReadNode) && node.name.to_s == name && node.depth == depth
+  end
+
+  def scope?(node)
+    node.is_a?(Prism::BlockNode) || node.is_a?(Prism::LambdaNode)
+  end
+end

data/lib/evilution/cli/exit_guard.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Gives evilution the final word on the process exit status.
+#
+# `--preload` loads the project's own spec helper into the parent process, and
+# whatever that helper installs comes along with it. SimpleCov's at_exit hook
+# calls `exit` with its own status when coverage is below the configured
+# minimum, which replaces the status evilution computed and breaks a CI step
+# reading it (EV-g8ya / GH #1608).
+#
+# at_exit hooks run last-registered-first, so a hook installed before the
+# preload is the last one standing. It exits with `exit!`, which is immediate
+# and cannot be overridden by anything left in the queue — by then every other
+# hook, evilution's own temp-directory cleanup included, has already run.
+#
+# With no status recorded, evilution did not finish normally: an exception is on
+# its way out, and Ruby's own handling decides the status instead.
+#
+# The hook belongs to the process that installed it. Evilution forks workers,
+# and a fork inherits its parent's at_exit hooks; a worker running this one
+# would exit with the parent's status and skip its own ending. The guard
+# therefore remembers its process and stands down anywhere else.
+class Evilution::CLI::ExitGuard
+  attr_accessor :status
+
+  def initialize(register: nil, exiter: nil, pid_source: nil, streams: nil)
+    @register = register || ->(&hook) { at_exit(&hook) }
+    @exiter = exiter || ->(code) { exit!(code) }
+    @streams = streams || -> { [$stdout, $stderr] }
+    @pid_source = pid_source || -> { Process.pid }
+    @status = nil
+  end
+
+  def install
+    @pid = @pid_source.call
+    @register.call { fire }
+    self
+  end
+
+  private
+
+  def fire
+    return if @status.nil?
+    return unless @pid_source.call == @pid
+
+    flush_streams
+    @exiter.call(@status)
+  end
+
+  # `exit!` leaves buffered output where it stands, so anything written by the
+  # report, or by a hook that ran before this one, has to be pushed out first.
+  def flush_streams
+    @streams.call.each do |stream|
+      stream.flush
+    rescue IOError, Errno::EBADF
+      nil
+    end
+  end
+end

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

@@ -55,6 +55,7 @@ class Evilution::CLI::Parser::OptionsBuilder
 
   def add_spec_filter_options(opts)
     opts.on("--min-score FLOAT", Float, "Minimum mutation score to pass") { |s| @options[:min_score] = s }
+    opts.on("--output FILE", "Write the report to FILE instead of stdout") { |f| @options[:output] = f }
     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",

data/lib/evilution/cli.rb

@@ -18,6 +18,7 @@ require_relative "cli/commands/session_diff"
 require_relative "cli/commands/session_gc"
 require_relative "cli/commands/compare"
 require_relative "cli/commands/run"
+require_relative "cli/exit_guard"
 
 # @api private
 class Evilution::CLI

data/lib/evilution/config.rb

@@ -17,7 +17,7 @@ class Evilution::Config
     save_session: false, line_ranges: {}, spec_files: [], ignore_patterns: [],
     show_disabled: false, baseline_session: nil, skip_heredoc_literals: false,
     related_specs_heuristic: false, fallback_to_full_suite: false, preload: nil,
-    spec_mappings: {}, spec_pattern: nil, example_targeting: true,
+    output: nil, spec_mappings: {}, spec_pattern: nil, example_targeting: true,
     example_targeting_fallback: :full_file, example_targeting_strategy: :lexical,
     example_targeting_cache: { max_files: 50, max_blocks: 10_000 },
     quiet_children: false, quiet_children_dir: "tmp/evilution_children",
@@ -25,7 +25,7 @@ class Evilution::Config
   }.freeze
 
   attr_reader :target_files, :schema_version, :timeout, :format,
-              :target, :min_score, :integration, :verbose, :quiet,
+              :target, :min_score, :integration, :verbose, :quiet, :output,
               :jobs, :fail_fast, :baseline, :isolation, :incremental, :suggest_tests,
               :progress, :save_session, :line_ranges, :spec_files, :hooks,
               :ignore_patterns, :show_disabled, :baseline_session,
@@ -243,6 +243,7 @@ class Evilution::Config
     format: :to_sym.to_proc,
     target: nil,
     min_score: :to_f.to_proc,
+    output: nil,
     verbose: nil,
     quiet: nil,
     baseline: nil,

data/lib/evilution/diagnostic.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../evilution"
+
+# Evilution's own advisory messages -- "no matching spec found", and the like.
+#
+# These deliberately bypass Kernel#warn. That routes through Warning.warn,
+# which a project is free to replace: the `warning` gem with a raising handler
+# turns every Ruby warning into an exception, and both dry-schema and
+# dry-monads configure exactly that in their spec_helper. Under such a project
+# our advisory message would be promoted to a fatal error, so a mutation we
+# meant to classify :unresolved would be reported :error instead -- 239 of
+# dry-monads' 240 mutations, in the run that found this.
+#
+# A message about how evilution is behaving must never be able to fail a
+# user's mutation. Writing straight to the stream keeps it a diagnostic.
+# EV-df7u / GH #1588.
+module Evilution::Diagnostic
+  def self.warn(message, stream: $stderr)
+    stream.puts(message)
+  end
+end

data/lib/evilution/integration/loading/concern_state_cleaner.rb

@@ -11,6 +11,22 @@ require_relative "../../load_path/subpath_resolver"
 class Evilution::Integration::Loading::ConcernStateCleaner
   IVARS = %i[@_included_block @_prepended_block].freeze
 
+  # ObjectSpace hands us every Module in the VM, including ones that answer no
+  # message honestly. ActiveSupport::Deprecation::DeprecatedConstantProxy
+  # subclasses Module and undefines all of its instance methods, so a plain
+  # `mod.singleton_class` lands in its method_missing and emits the
+  # deprecation; where the deprecator's behaviour is :raise (grape's
+  # spec_helper sets that), the sweep blows up on a module it merely walked
+  # past. Calling through UnboundMethods bypasses the object's own method
+  # table, so a proxy is never given the chance to intercept -- and this holds
+  # for any method_missing-based wrapper, not just ActiveSupport's.
+  # EV-v2rc / GH #1581.
+  SINGLETON_CLASS = Object.instance_method(:singleton_class)
+  IVAR_DEFINED = Object.instance_method(:instance_variable_defined?)
+  IVAR_GET = Object.instance_method(:instance_variable_get)
+  REMOVE_IVAR = Object.instance_method(:remove_instance_variable)
+  private_constant :SINGLETON_CLASS, :IVAR_DEFINED, :IVAR_GET, :REMOVE_IVAR
+
   def initialize(subpath_resolver: Evilution::LoadPath::SubpathResolver.new)
     @subpath_resolver = subpath_resolver
   end
@@ -22,7 +38,7 @@ class Evilution::Integration::Loading::ConcernStateCleaner
     subpath = @subpath_resolver.call(file_path)
 
     ObjectSpace.each_object(Module) do |mod|
-      next unless mod.singleton_class.ancestors.include?(ActiveSupport::Concern)
+      next unless SINGLETON_CLASS.bind_call(mod).ancestors.include?(ActiveSupport::Concern)
 
       clear_concern_ivars(mod, absolute, subpath)
     end
@@ -32,14 +48,14 @@ class Evilution::Integration::Loading::ConcernStateCleaner
 
   def clear_concern_ivars(mod, absolute, subpath)
     IVARS.each do |ivar|
-      next unless mod.instance_variable_defined?(ivar)
+      next unless IVAR_DEFINED.bind_call(mod, ivar)
 
-      block = mod.instance_variable_get(ivar)
+      block = IVAR_GET.bind_call(mod, ivar)
       block_file = block.source_location&.first
       next unless block_file
 
       expanded = File.expand_path(block_file)
-      mod.remove_instance_variable(ivar) if source_matches?(expanded, absolute, subpath)
+      REMOVE_IVAR.bind_call(mod, ivar) if source_matches?(expanded, absolute, subpath)
     end
   end
 

data/lib/evilution/integration/loading/redefinition_recovery.rb

@@ -65,7 +65,7 @@ class Evilution::Integration::Loading::RedefinitionRecovery
     msg = error.message
     # `msg` is a String and patterns are substrings, so `include?` is a
     # substring test — `intersect?` would compare array elements, not text.
-    IDEMPOTENCY_PATTERNS.any? { |pat| msg.include?(pat) } # rubocop:disable Style/ArrayIntersect
+    IDEMPOTENCY_PATTERNS.any? { msg.include?(_1) }
   end
 
   def superclass_mismatch?(error)

data/lib/evilution/integration/loading/reeval_warning_filter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Suppresses exactly the Ruby warnings that re-evaluating a file is guaranteed
+# to produce, and nothing else.
+#
+# Applying a mutation re-evaluates the file, which redefines its methods and
+# reassigns its constants. Ruby reports that in verbose mode, and a project
+# that also promotes warnings to exceptions -- dry-schema's `.rspec` carries
+# `--warnings` while its spec_helper installs `Warning.process { |w| raise w }`
+# -- fails every mutation on a message describing evilution's mechanism rather
+# than the code under test.
+#
+# The blunt fix, `$VERBOSE = nil` around the eval, costs too much: the
+# evaluated file then sees a different $VERBOSE than a normal load would (code
+# branching on it takes the other path), and genuine warnings introduced BY a
+# mutation are swallowed along with ours -- losing a kill that a raising
+# handler would otherwise hand us. So the filter matches the specific
+# mechanism messages instead and delegates everything else to whatever handler
+# the project installed.
+#
+# EV-df7u / GH #1588.
+class Evilution::Integration::Loading::ReevalWarningFilter
+  MECHANISM_WARNINGS = Regexp.union(
+    /method redefined; discarding old /,
+    /already initialized constant /,
+    /previous definition of .+ was here/
+  ).freeze
+
+  ACTIVE_KEY = :__evilution_reeval_warning_filter_active
+
+  # Prepended to Warning's singleton, so it sits AHEAD of any handler the
+  # project extended in (the `warning` gem extends Warning::Processor), and
+  # `super` still reaches that handler for everything it does not drop.
+  module Filter
+    def warn(message, *args, **kwargs)
+      filter = Evilution::Integration::Loading::ReevalWarningFilter
+      return if filter.active? && filter.mechanism_warning?(message)
+
+      super
+    end
+  end
+
+  class << self
+    def suppress
+      install
+      previous = Thread.current[ACTIVE_KEY]
+      Thread.current[ACTIVE_KEY] = true
+      yield
+    ensure
+      Thread.current[ACTIVE_KEY] = previous
+    end
+
+    def active?
+      Thread.current[ACTIVE_KEY] ? true : false
+    end
+
+    def mechanism_warning?(message)
+      MECHANISM_WARNINGS.match?(message)
+    end
+
+    # Idempotent: prepending twice would run the filter twice per warning.
+    # `target` exists so a test can install into a throwaway module -- once
+    # Warning's singleton has the filter there is no way to take it back off.
+    def install(target = Warning.singleton_class)
+      return if target.ancestors.include?(Filter)
+
+      target.prepend(Filter)
+    end
+  end
+end

data/lib/evilution/integration/loading/source_evaluator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../loading"
+require_relative "reeval_warning_filter"
 
 # Evaluate source with __FILE__ set to the absolute original path so that
 # `require_relative` and `__dir__` resolve against the real source tree, where
@@ -17,6 +18,8 @@ class Evilution::Integration::Loading::SourceEvaluator
     # GH #1278), anchor the eval __FILE__ against PROJECT_ROOT so siblings
     # `require_relative` can find each other from the real source tree.
     absolute = File.expand_path(file_path, Evilution.project_base_dir)
-    eval(source, TOPLEVEL_BINDING, absolute, 1)
+    Evilution::Integration::Loading::ReevalWarningFilter.suppress do
+      eval(source, TOPLEVEL_BINDING, absolute, 1)
+    end
   end
 end

data/lib/evilution/integration/minitest.rb

@@ -2,6 +2,7 @@
 
 require "stringio"
 require_relative "base"
+require_relative "../diagnostic"
 require_relative "minitest_crash_detector"
 require_relative "loading/test_load_path"
 require_relative "../spec_resolver"
@@ -276,7 +277,7 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     return if @warned_files.include?(file_path)
 
     @warned_files << file_path
-    warn unresolved_test_message(file_path)
+    Evilution::Diagnostic.warn(unresolved_test_message(file_path))
   end
 
   # Name both recovery paths when skipping :unresolved; when already falling

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

@@ -10,8 +10,16 @@ class Evilution::Integration::RSpec::CrashDetectorLifecycle
       @detector.reset
     else
       @detector = Evilution::Integration::CrashDetector.new(StringIO.new)
-      ::RSpec.configuration.add_formatter(@detector)
     end
     @detector
   end
+
+  # The run rebuilds RSpec's formatter loader so its formatters are bound to the
+  # run's own streams (EV-m6xc / GH #1627), which drops any formatter registered
+  # before it — the detector included. It is registered per run instead.
+  def register
+    detector = current
+    ::RSpec.configuration.add_formatter(detector)
+    detector
+  end
 end

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

@@ -18,7 +18,10 @@ require_relative "internals"
 # writing the ivars directly: configuration#output_stream= is guarded (it warns
 # and no-ops once a reporter exists), so the public setter cannot put it back.
 class Evilution::Integration::RSpec::StateGuard::ConfigurationStreams
-  IVARS = %i[@color_mode @output_stream @error_stream].freeze
+  #   - @reporter and @formatter_loader -- both hold the stream they were built
+  #                     with, so the run drops them to rebuild against its own
+  #                     (EV-m6xc / GH #1627); the host's are restored here.
+  IVARS = %i[@color_mode @output_stream @error_stream @reporter @formatter_loader].freeze
 
   def snapshot
     config = ::RSpec.configuration

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../rspec"
+require_relative "../../diagnostic"
 
 class Evilution::Integration::RSpec::UnresolvedSpecWarner
   def initialize
@@ -11,7 +12,7 @@ class Evilution::Integration::RSpec::UnresolvedSpecWarner
     return if @warned.include?(file_path)
 
     @warned << file_path
-    warn message(file_path, fallback_to_full_suite)
+    Evilution::Diagnostic.warn(message(file_path, fallback_to_full_suite))
   end
 
   private

data/lib/evilution/integration/rspec.rb

@@ -70,6 +70,26 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     targets = @example_filter_applier.call(mutation, files)
     return @result_builder.unresolved_example(mutation) if targets.nil?
 
+    result = run_targets(targets)
+    return result unless confirm_survivor?(result, targets, files)
+
+    run_targets(files)
+  end
+
+  # Targeting runs a subset of the examples in a spec file, chosen by name. A
+  # mutation that subset does not catch looks like a survivor whether or not the
+  # rest of the file would have caught it, and a survivor nobody can reproduce
+  # is worse than a missed kill: it sends the reader to write a test that is
+  # already there (EV-f8h3 / GH #1624).
+  #
+  # 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
+  end
+
+  def run_targets(targets)
     args = ["--format", "progress", "--no-color", "--order", "defined", *resolve_targets(targets)]
     command = "rspec #{args.join(" ")}"
 
@@ -115,10 +135,13 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   end
 
   def execute_run(args, command)
-    detector = @crash_detector_lifecycle.current
     snapshot = @state_guard.snapshot
     begin
-      status = ::RSpec::Core::Runner.run(args, StringIO.new, StringIO.new)
+      out = StringIO.new
+      err = StringIO.new
+      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:)
     rescue StandardError => e
       { passed: false, error: e.message, test_command: command }
@@ -127,6 +150,29 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     end
   end
 
+  # RSpec redirects its own output to the streams it is handed only when the
+  # stream its configuration already holds is the current `$stdout`. In-process
+  # isolation swaps `$stdout` for a null IO around every mutation, and a
+  # configuration built before that swap — which is what `--preload` produces,
+  # since the project's spec_helper calls RSpec.configure — still holds the real
+  # stdout. The two no longer match, RSpec keeps its own stream, and the run's
+  # output lands on the real stdout ahead of the report (EV-m6xc / GH #1627).
+  #
+  # So the streams are claimed outright rather than offered. The ivars are
+  # written directly because `output_stream=` is guarded once a reporter exists.
+  # The reporter and its formatters are dropped along with them: both hold the
+  # stream they were built with, so leaving them in place would keep writing
+  # wherever the host pointed. StateGuard snapshots all four ivars and puts the
+  # host's back afterwards.
+  def claim_rspec_streams(out, err)
+    config = ::RSpec.configuration
+    config.instance_variable_set(:@output_stream, out)
+    config.instance_variable_set(:@error_stream, err)
+    %i[@reporter @formatter_loader].each do |ivar|
+      config.remove_instance_variable(ivar) if config.instance_variable_defined?(ivar)
+    end
+  end
+
   # Count of examples loaded into RSpec.world by this run. Used to distinguish
   # "test failed → mutation killed" (positive count, nonzero status) from
   # "spec file failed to load / RSpec returned nonzero with nothing observed"

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../test_unit"
+require_relative "../../diagnostic"
 
 # Resolves the list of test files to load for a given mutation. Encapsulates
 # the explicit-override path, spec-selector lookup, fallback glob, and the
@@ -41,7 +42,7 @@ class Evilution::Integration::TestUnit::TestFileResolver
     return if @warned_files.include?(file_path)
 
     @warned_files << file_path
-    warn unresolved_message(file_path)
+    Evilution::Diagnostic.warn(unresolved_message(file_path))
   end
 
   # Name both recovery paths when skipping :unresolved; when already falling

data/lib/evilution/isolation/fork.rb

@@ -142,9 +142,9 @@ class Evilution::Isolation::Fork
       # Child exited. Drain any final payload that arrived between
       # 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
+      return decode_payload(final, handle) if final
 
-      return empty_result
+      return empty_result(handle)
     end
   end
 
@@ -161,11 +161,13 @@ class Evilution::Isolation::Fork
 
       if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
         @supervisor.terminate(handle, grace: GRACE_PERIOD)
-        break
+        # The status now records OUR signal, so it cannot be reported as the
+        # child's own cause of death.
+        return decode_payload(payload, handle, terminated: true)
       end
       sleep 0.05
     end
-    decode_payload(payload)
+    decode_payload(payload, handle)
   end
 
   def read_payload(read_io, deadline)
@@ -201,14 +203,33 @@ class Evilution::Isolation::Fork
     buf
   end
 
-  def decode_payload(data)
-    return empty_result if data.nil? || data.empty?
+  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))
   end
 
-  def empty_result
-    { timeout: false, passed: false, error: "empty result from child" }
+  def empty_result(handle, terminated: false)
+    { timeout: false, passed: false, error: child_death_reason(handle, terminated: terminated) }
+  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
+
+    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?
+
+    "child died on #{signal_name(status.termsig)} without writing a result"
+  end
+
+  def signal_name(termsig)
+    name = Signal.signame(termsig)
+    name.nil? ? "signal #{termsig}" : "SIG#{name}"
   end
 
   def timeout_result(handle)

data/lib/evilution/mcp/complete_result_server.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+require_relative "../mcp"
+
+# MCP protocol revision 2026-07-28 (SEP-2322) makes `resultType` mandatory on list results: a
+# client may only treat a missing field as "complete" for servers that negotiated an earlier
+# revision. The mcp gem echoes back any client-offered revision it supports — 2026-07-28
+# included — yet its list handlers still omit the field, so strict clients reject the whole
+# list and the server appears to expose no tools at all.
+#
+# Every list result this server produces is final (there is no `input_required` round trip in
+# the evilution tool surface), so the field is always `"complete"`. The value is written as a
+# literal rather than `MCP::ResultType::COMPLETE` because the gem dependency allows versions
+# that predate that constant. Older revisions ignore the extra key.
+class Evilution::MCP::CompleteResultServer < MCP::Server
+  RESULT_TYPE_COMPLETE = "complete"
+
+  private
+
+  def list_tools(request)
+    mark_complete(super)
+  end
+
+  def list_prompts(request)
+    mark_complete(super)
+  end
+
+  def list_resources(request)
+    mark_complete(super)
+  end
+
+  def list_resource_templates(request)
+    mark_complete(super)
+  end
+
+  def mark_complete(result)
+    result.merge(resultType: RESULT_TYPE_COMPLETE)
+  end
+end

data/lib/evilution/mcp/server.rb

@@ -2,6 +2,7 @@
 
 require "mcp"
 require_relative "../version"
+require_relative "complete_result_server"
 require_relative "mutate_tool"
 require_relative "session_tool"
 require_relative "info_tool"
@@ -10,7 +11,7 @@ require_relative "../mcp"
 
 class Evilution::MCP::Server
   def self.build
-    ::MCP::Server.new(
+    Evilution::MCP::CompleteResultServer.new(
       name: "evilution",
       version: Evilution::VERSION,
       tools: [Evilution::MCP::MutateTool, Evilution::MCP::SessionTool, Evilution::MCP::InfoTool]

data/lib/evilution/mutator/base.rb

@@ -3,10 +3,13 @@
 require "prism"
 
 require_relative "../mutator"
+require_relative "primitives"
 require_relative "../integration/loading/body_call_neutralizer"
 require_relative "../ast/heredoc_span"
 
 class Evilution::Mutator::Base < Prism::Visitor
+  include Evilution::Mutator::Primitives
+
   AffectedSlices = Data.define(:original, :mutated)
   private_constant :AffectedSlices
 
@@ -41,7 +44,12 @@ class Evilution::Mutator::Base < Prism::Visitor
 
   private
 
-  def add_mutation(offset:, length:, replacement:, node:)
+  # `skip_unparseable` makes the mutation vanish rather than be recorded when
+  # the surgery does not parse. Off by default: the point operators rely on
+  # unparseable bytes reaching the reporter as their own bucket. The shared
+  # primitives opt in, since a nil-ification or promotion that does not parse
+  # carries no signal.
+  def add_mutation(offset:, length:, replacement:, node:, skip_unparseable: false)
     return if @filter && @filter.skip?(node)
 
     # When the byte range opens a heredoc but stops at its inline anchor,
@@ -67,6 +75,8 @@ class Evilution::Mutator::Base < Prism::Visitor
     surgery = Evilution::AST::SourceSurgeon.apply(
       @file_source, offset: offset, length: length, replacement: replacement
     )
+    return if skip_unparseable && surgery.unparseable?
+
     slices = slice_affected_lines(
       mutated_source: surgery.source,
       offset: offset,
@@ -74,7 +84,9 @@ class Evilution::Mutator::Base < Prism::Visitor
       replacement_bytesize: replacement.bytesize
     )
 
-    @mutations << build_mutation_record(node, surgery, slices)
+    mutation = build_mutation_record(node, surgery, slices)
+    @mutations << mutation
+    mutation
   end
 
   def build_mutation_record(node, surgery, slices)