evilution 0.29.0 → 0.30.0

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

@@ -5,11 +5,25 @@ require_relative "../mutate_tool"
 require_relative "../../feedback"
 require_relative "../../feedback/detector"
 require_relative "../../feedback/messages"
+require_relative "../../feedback/setup_warning"
 
 module Evilution::MCP::MutateTool::ReportTrimmer
   MINIMAL_KEYS = %w[summary survived].freeze
   FULL_DIFF_STRIP_KEYS = %w[killed neutral equivalent unresolved unparseable].freeze
   SUMMARY_DROP_KEYS = %w[killed neutral equivalent unparseable].freeze
+  # EV-187j / GH #1169: at summary verbosity, non-survived entries that remain
+  # (timed_out, errors, unresolved) shed `diff` and `error_backtrace` payload —
+  # those two fields dominate response size at scale and aren't actionable for
+  # a scanning agent. Survived stays full-detail.
+  SUMMARY_HEAVY_FIELDS = %w[diff error_backtrace].freeze
+  SUMMARY_TRIM_KEYS = %w[timed_out errors unresolved].freeze
+
+  # EV-t7kh / GH #1170: at minimal verbosity we surface a small sample of any
+  # errored mutations so agents are not stuck in a diagnose-vs-token-cap
+  # deadlock when a run is partly-broken. Bounded to keep the payload tiny.
+  ERROR_SAMPLE_LIMIT = 3
+  ERROR_BACKTRACE_HEAD_LINES = 5
+  ERROR_SAMPLE_KEYS = %w[operator file line error_message error_class].freeze
 
   def self.call(json_string, verbosity:, survived_results:, config:, enricher:, summary: nil)
     data = ::JSON.parse(json_string)
@@ -18,14 +32,38 @@ module Evilution::MCP::MutateTool::ReportTrimmer
       FULL_DIFF_STRIP_KEYS.each { |key| strip_diffs(data, key) }
     when "summary"
       SUMMARY_DROP_KEYS.each { |key| data.delete(key) }
+      SUMMARY_TRIM_KEYS.each { |key| strip_heavy_fields(data, key) }
     when "minimal"
-      data.keep_if { |key, _| MINIMAL_KEYS.include?(key) }
+      apply_minimal(data)
     end
     enricher.call(data, survived_results, config)
     embed_feedback(data, summary) unless verbosity == "minimal"
+    embed_setup_warning(data, summary)
     ::JSON.generate(data)
   end
 
+  def self.apply_minimal(data)
+    sample = error_sample(data["errors"])
+    data.keep_if { |key, _| MINIMAL_KEYS.include?(key) }
+    data["errors"] = sample if sample
+  end
+  private_class_method :apply_minimal
+
+  def self.error_sample(entries)
+    return nil unless entries.is_a?(Array) && !entries.empty?
+
+    entries.first(ERROR_SAMPLE_LIMIT).map { |entry| trim_error_entry(entry) }
+  end
+  private_class_method :error_sample
+
+  def self.trim_error_entry(entry)
+    trimmed = entry.slice(*ERROR_SAMPLE_KEYS)
+    backtrace = entry["error_backtrace"]
+    trimmed["error_backtrace"] = backtrace.first(ERROR_BACKTRACE_HEAD_LINES) if backtrace.is_a?(Array)
+    trimmed
+  end
+  private_class_method :trim_error_entry
+
   def self.strip_diffs(data, key)
     return unless data[key]
 
@@ -33,6 +71,15 @@ module Evilution::MCP::MutateTool::ReportTrimmer
   end
   private_class_method :strip_diffs
 
+  def self.strip_heavy_fields(data, key)
+    return unless data[key].is_a?(Array)
+
+    data[key].each do |entry|
+      SUMMARY_HEAVY_FIELDS.each { |field| entry.delete(field) }
+    end
+  end
+  private_class_method :strip_heavy_fields
+
   def self.embed_feedback(data, summary)
     return unless Evilution::Feedback::Detector.friction?(summary)
 
@@ -40,4 +87,14 @@ module Evilution::MCP::MutateTool::ReportTrimmer
     data["feedback_hint"] = Evilution::Feedback::Messages.mcp_hint
   end
   private_class_method :embed_feedback
+
+  # Surface a clear pointer at the most common silent-failure: every mutation
+  # errored because the worker couldn't load the project (typically Rails
+  # autoload + MCP's preload-disabled-by-default). When detected, attach a
+  # `setup_warning` field so the agent doesn't trust a 0.0 score blindly.
+  def self.embed_setup_warning(data, summary)
+    warning = Evilution::Feedback::SetupWarning.call(summary)
+    data["setup_warning"] = warning if warning
+  end
+  private_class_method :embed_setup_warning
 end

data/lib/evilution/mcp/mutate_tool.rb

@@ -27,8 +27,11 @@ class Evilution::MCP::MutateTool < MCP::Tool
               "so the agent can jump straight to writing the missing test. " \
               "Prefer this over shelling out to 'evilution' — the response is machine-readable " \
               "and already trimmed for survived-mutant triage. " \
+              "CLI equivalent: `evilution run [files...]` (or `evilution mutate [files...]` as an alias). " \
               "Hitting errors, friction, or missing capabilities? See evilution-info action=feedback for the " \
-              "public feedback channel — ask the user before posting anything."
+              "public feedback channel — ask the user before posting anything. " \
+              "Contract: input schema and output payload are stable for the 1.x line; " \
+              "see README \"MCP Server\" section for the full deprecation policy."
   input_schema(
     properties: {
       files: {
@@ -86,6 +89,20 @@ class Evilution::MCP::MutateTool < MCP::Tool
         type: "boolean",
         description: "Save session results to .evilution/results/ for later inspection via evilution-session"
       },
+      preload: {
+        oneOf: [
+          { type: "string" },
+          { type: "boolean", enum: [false] }
+        ],
+        description: "Preload a file (e.g. 'spec/rails_helper.rb') into the MCP server process before " \
+                     "forking workers. Default: false. Pass an explicit path (string) for Rails / Zeitwerk " \
+                     "projects where workers need autoloaded constants resolved before the mutation runs — " \
+                     "without this, autoload-dependent code fails with NameError on every mutation, producing " \
+                     "all-errored / score 0.0 results. Pass `false` to explicitly disable preload (e.g. to " \
+                     "override a `.evilution.yml` setting). `true` is not accepted — pass an explicit path. " \
+                     "Trade-off: opt-in pollutes the long-lived MCP server process for the lifetime of the " \
+                     "session; restart the server when switching projects."
+      },
       skip_config: {
         type: "boolean",
         description: "When true, ignore .evilution.yml / config/evilution.yml. " \
@@ -97,8 +114,10 @@ class Evilution::MCP::MutateTool < MCP::Tool
         type: "string",
         enum: %w[full summary minimal],
         description: "Response verbosity: full (all entries, diffs stripped from killed/neutral/equivalent), " \
-                     "summary (omits killed/neutral/equivalent arrays; default), " \
-                     "minimal (only summary + survived)"
+                     "summary (omits killed/neutral/equivalent arrays; remaining timed_out/errors/unresolved " \
+                     "entries shed `diff` and `error_backtrace` to bound payload size; default), " \
+                     "minimal (summary + survived; also includes a trimmed sample of up to 3 errored " \
+                     "entries with error_message and a 5-line backtrace head when errors > 0)"
       }
     }
   )

data/lib/evilution/mcp/session_tool.rb

@@ -15,7 +15,9 @@ class Evilution::MCP::SessionTool < MCP::Tool
               "'show' returns the full report for a session (summary, survived mutations with diffs, git context), " \
               "'diff' compares two sessions and surfaces new regressions, fixed mutations, persistent survivors, and score delta. " \
               "Prefer this over the CLI when auditing mutation score trends, triaging survivors, " \
-              "or verifying that a fix killed the right mutant."
+              "or verifying that a fix killed the right mutant. " \
+              "Contract: input schema, action enum, and output payloads are stable for the 1.x line; " \
+              "see README \"MCP Server\" section for the full deprecation policy."
   input_schema(
     properties: {
       action: {
@@ -77,8 +79,8 @@ class Evilution::MCP::SessionTool < MCP::Tool
       entries = store.list
       entries = entries.first(result.limit) unless result.limit.nil?
 
-      payload = entries.map { |e| e.transform_keys(&:to_s) }
-      success_response(payload)
+      sessions = entries.map { |e| e.transform_keys(&:to_s) }
+      success_response("schema_version" => Evilution::MCP::CONTRACT_VERSION, "sessions" => sessions)
     end
 
     def normalize_limit(limit)
@@ -115,7 +117,8 @@ class Evilution::MCP::SessionTool < MCP::Tool
       return validation if validation
 
       result = load_and_diff(base, head, dir)
-      success_response(result.to_h)
+      payload = { "schema_version" => Evilution::MCP::CONTRACT_VERSION }.merge(result.to_h)
+      success_response(payload)
     rescue Evilution::Error => e
       error_response("not_found", e.message)
     rescue ::JSON::ParserError => e

data/lib/evilution/mcp.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
 
 module Evilution::MCP
+  # Public contract version for the evilution MCP tool surface (input schemas,
+  # output payload shapes, error envelope, action enumerations). Bumped only
+  # at MAJOR releases per docs/versioning.md. Independent of session JSON
+  # schema versioning (Evilution::Session::Schema) so the two surfaces can
+  # rev separately.
+  CONTRACT_VERSION = 1
 end

data/lib/evilution/mutation.rb

@@ -10,13 +10,15 @@ class Evilution::Mutation
 
   attr_reader :subject, :operator_name, :parse_status, :location
 
-  def initialize(subject:, operator_name:, sources:, location:, slice: nil, parse_status: :ok)
+  def initialize(subject:, operator_name:, sources:, location:,
+                 slice: nil, parse_status: :ok, eval_source: nil)
     @subject = subject
     @operator_name = operator_name
     @sources = sources
     @location = location
     @slice = slice
     @parse_status = parse_status
+    @eval_source = eval_source
     @diff = nil
   end
 
@@ -28,6 +30,16 @@ class Evilution::Mutation
     @sources&.mutated
   end
 
+  # Source to feed to the load-time evaluator. Defaults to mutated_source
+  # when no pre-eval transform was applied at generation time. Mutator::Base
+  # populates this with the neutralized version (top-level idempotency-
+  # violating calls replaced with `nil`) so the worker eval doesn't re-run
+  # them. The neutralization Prism parse happens once at generation time,
+  # not per worker iteration.
+  def eval_source
+    @eval_source || mutated_source
+  end
+
   def original_slice
     @slice&.original
   end

data/lib/evilution/mutator/base.rb

@@ -3,17 +3,31 @@
 require "prism"
 
 require_relative "../mutator"
+require_relative "../integration/loading/body_call_neutralizer"
+require_relative "../ast/heredoc_span"
 
 class Evilution::Mutator::Base < Prism::Visitor
   AffectedSlices = Data.define(:original, :mutated)
   private_constant :AffectedSlices
 
+  # Match a heredoc anchor `<<MARKER` / `<<-MARKER` / `<<~MARKER` (optionally
+  # quoted) when the identifier sits directly against the `<<` (or its
+  # `-`/`~`/quote prefix). The space-separated forms `arr << x`, `1 << 2`,
+  # `class << self` deliberately do NOT match — `<<` alone is also Ruby's
+  # shift / append / singleton-class operator, and skipping mutations that
+  # only contain those would lose useful coverage. False positive on the
+  # unusual no-space shift `obj<<value` is accepted (over-skip is safer than
+  # emitting an unparseable mutation).
+  HEREDOC_ANCHOR_PATTERN = /<<[-~]?["'`]?[A-Za-z_]/
+  private_constant :HEREDOC_ANCHOR_PATTERN
+
   attr_reader :mutations
 
   def initialize(**_options)
     @mutations = []
     @subject = nil
     @file_source = nil
+    @body_call_neutralizer = Evilution::Integration::Loading::BodyCallNeutralizer.new
   end
 
   def call(subject, filter: nil)
@@ -30,6 +44,26 @@ class Evilution::Mutator::Base < Prism::Visitor
   def add_mutation(offset:, length:, replacement:, node:)
     return if @filter && @filter.skip?(node)
 
+    # When the byte range opens a heredoc but stops at its inline anchor,
+    # extend it to cover the body+terminator. Without this every operator
+    # whose edit straddles a `<<~MARKER` anchor (argument_removal,
+    # argument_nil_substitution, method_call_removal, statement_deletion,
+    # method_body_replacement, block_removal, conditional_branch,
+    # string_interpolation, ...) emits an orphan-heredoc unparseable.
+    extended_length = Evilution::AST::HeredocSpan.extend_length(
+      node: node, offset: offset, length: length
+    )
+
+    # If the replacement re-references a heredoc anchor (e.g. argument_removal
+    # rebuilding the args list with a kept `<<~MSG` arg), we cannot safely
+    # extend the range — doing so would strip the kept heredoc's body without
+    # putting it back. Skip the mutation rather than emit unparseable bytes.
+    # When the replacement is heredoc-free (nil, "", a literal, or a non-
+    # heredoc kept arg), extension cleanly sweeps the orphaned body+terminator.
+    return if extended_length > length && replacement.match?(HEREDOC_ANCHOR_PATTERN)
+
+    length = extended_length
+
     surgery = Evilution::AST::SourceSurgeon.apply(
       @file_source, offset: offset, length: length, replacement: replacement
     )
@@ -54,10 +88,24 @@ class Evilution::Mutator::Base < Prism::Visitor
         line: node.location.start_line,
         column: node.location.start_column
       ),
-      parse_status: surgery.status
+      parse_status: surgery.status,
+      eval_source: build_eval_source(surgery)
     )
   end
 
+  # Pre-compute the worker's eval target so per-iter Prism re-parse cost
+  # stays out of the hot path. For parseable mutations we strip class/module
+  # body calls that are known to be non-idempotent (registries etc.); for
+  # unparseable bytes we fall through so the syntax validator can reject
+  # them at apply time. Passing the subject's file path lets the neutralizer
+  # skip files the parent never preloaded — those are lazy plugin files whose
+  # DSL calls are still needed for the child fork's first-time load.
+  def build_eval_source(surgery)
+    return surgery.source unless surgery.ok?
+
+    @body_call_neutralizer.call(surgery.source, file_path: @subject.file_path)
+  end
+
   NEWLINE_BYTE = 10
   private_constant :NEWLINE_BYTE
 

data/lib/evilution/mutator/operator/argument_method_call_replacement.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Replaces a method-call argument with its receiver: `fn(x.attr)` -> `fn(x)`.
+# High-signal for log payloads, structured-data construction, and API
+# request bodies where a method call on a local variable / param appears in
+# argument position. Covered byte-wise by `MethodCallRemoval` already; this
+# operator surfaces the same byte change under a more specific name so the
+# argument-substitution pattern is legible in mutation output.
+#
+# Fires for:
+# - positional / keyword arguments of any CallNode
+# - hash values inside HashNode / KeywordHashNode (incl. inside call args)
+# - array elements inside ArrayNode
+class Evilution::Mutator::Operator::ArgumentMethodCallReplacement < Evilution::Mutator::Base
+  def visit_call_node(node)
+    node.arguments.arguments.each { |arg| try_replace(arg) } if node.arguments
+
+    super
+  end
+
+  def visit_array_node(node)
+    node.elements.each { |element| try_replace(element) }
+    super
+  end
+
+  def visit_hash_node(node)
+    process_assocs(node.elements)
+    super
+  end
+
+  def visit_keyword_hash_node(node)
+    process_assocs(node.elements)
+    super
+  end
+
+  private
+
+  def process_assocs(elements)
+    elements.each do |assoc|
+      next unless assoc.is_a?(Prism::AssocNode)
+
+      try_replace(assoc.value)
+    end
+  end
+
+  def try_replace(value)
+    return unless value.is_a?(Prism::CallNode)
+    return unless value.receiver
+
+    add_mutation(
+      offset: value.location.start_offset,
+      length: value.location.length,
+      replacement: value.receiver.slice,
+      node: value
+    )
+  end
+end

data/lib/evilution/mutator/operator/block_param_removal.rb

@@ -6,6 +6,7 @@ class Evilution::Mutator::Operator::BlockParamRemoval < Evilution::Mutator::Base
   def visit_def_node(node)
     return super unless node.parameters
     return super unless node.parameters.block
+    return super if anonymous_block_forwarded?(node)
 
     if only_block_param?(node.parameters)
       remove_entire_params(node)
@@ -26,6 +27,37 @@ class Evilution::Mutator::Operator::BlockParamRemoval < Evilution::Mutator::Base
       params.keyword_rest.nil?
   end
 
+  # Skip the mutation when the def declares an anonymous `&` block parameter
+  # AND the body uses `&` to forward it. Ruby parses `def f(&) = g(&)` only
+  # because the signature declares the anonymous block; stripping `&` from the
+  # signature leaves the body's `&` orphaned and produces a parse error.
+  # Named block params (`&block`) are not affected here — removing those leaves
+  # body references like `block.call` as NameError at runtime, still parseable
+  # and still a useful (kill-able) mutation.
+  def anonymous_block_forwarded?(node)
+    return false unless node.parameters.block.name.nil?
+    return false if node.body.nil?
+
+    body_contains_anonymous_forward?(node.body)
+  end
+
+  def body_contains_anonymous_forward?(body)
+    queue = [body]
+    until queue.empty?
+      current = queue.shift
+      return true if current.is_a?(Prism::BlockArgumentNode) && current.expression.nil?
+
+      # A nested def introduces a fresh method scope, so any `&` inside it
+      # forwards the inner method's own block parameter, not ours. Stop
+      # descent. Blocks and lambdas inherit the enclosing method scope, so
+      # we keep walking through them.
+      next if current.is_a?(Prism::DefNode)
+
+      queue.concat(current.compact_child_nodes)
+    end
+    false
+  end
+
   def remove_entire_params(node)
     start_offset = node.lparen_loc.start_offset
     end_offset = node.rparen_loc.start_offset + node.rparen_loc.length

data/lib/evilution/mutator/operator/explicit_super_mutation.rb

@@ -30,15 +30,33 @@ class Evilution::Mutator::Operator::ExplicitSuperMutation < Evilution::Mutator::
   end
 
   # super(a, b) -> super()
+  #
+  # The argument list's byte range covers only the args themselves; the
+  # separator (`,` + whitespace) between the last arg and a following
+  # `&block` (or the closing `)` after a trailing comma) is owned by the
+  # SuperNode itself. Replacing only `arguments.location` with `""` leaves
+  # `super(, &block)` or `super(,)`. Extend the removal range to the start
+  # of the block argument when present, otherwise to the closing paren — so
+  # the separator goes along with the args.
   def emit_remove_all_args(node)
+    start_offset = node.arguments.location.start_offset
+    end_offset = trailing_args_boundary(node)
+
     add_mutation(
-      offset: node.arguments.location.start_offset,
-      length: node.arguments.location.length,
+      offset: start_offset,
+      length: end_offset - start_offset,
       replacement: "",
       node: node
     )
   end
 
+  def trailing_args_boundary(node)
+    return node.block.location.start_offset if node.block
+    return node.rparen_loc.start_offset if node.rparen_loc
+
+    node.arguments.location.end_offset
+  end
+
   def emit_remove_arg_at(node, args, i)
     remaining = args.each_with_index.filter_map { |a, j| a.slice if j != i }
     add_mutation(

data/lib/evilution/mutator/operator/index_to_at.rb

@@ -22,10 +22,22 @@ class Evilution::Mutator::Operator::IndexToAt < Evilution::Mutator::Base
     @file_source.byteslice(loc.start_offset, loc.length)
   end
 
+  # EV-pn5y / GH #1173: Hash has no #at method, so the symbol/string keys that
+  # almost always indicate a Hash receiver are skipped here — otherwise the
+  # mutated source crashes with NoMethodError instead of yielding a measurable
+  # mutation. Integer literals and variable/expression keys are still mutated;
+  # if the receiver in those cases turns out to be a Hash the mutation will
+  # still raise NoMethodError at runtime, but those shapes are far rarer in
+  # practice and the AST gives no reliable receiver-type signal to filter on.
   def indexable?(node)
     node.name == :[] &&
       node.receiver &&
       node.arguments &&
-      node.arguments.arguments.length == 1
+      node.arguments.arguments.length == 1 &&
+      !hash_key_shape?(node.arguments.arguments.first)
+  end
+
+  def hash_key_shape?(arg)
+    arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
   end
 end

data/lib/evilution/mutator/operator/last_expression_removal.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+# Removes a trailing literal expression (true/false/nil/integer/symbol) from
+# a method body. Targets the idiomatic Ruby pattern `def foo?; side_effect;
+# true; end` where the explicit literal return value is the high-signal
+# behavior under test — dropping it makes the method return whatever the
+# preceding statement evaluates to. Strong against predicates and
+# command-query split methods.
+class Evilution::Mutator::Operator::LastExpressionRemoval < Evilution::Mutator::Base
+  LITERAL_NODE_TYPES = [
+    Prism::TrueNode,
+    Prism::FalseNode,
+    Prism::NilNode,
+    Prism::IntegerNode,
+    Prism::SymbolNode
+  ].freeze
+
+  def visit_def_node(node)
+    last_literal = trailing_literal(node)
+    if last_literal
+      add_mutation(
+        offset: last_literal.location.start_offset,
+        length: last_literal.location.length,
+        replacement: "",
+        node: last_literal
+      )
+    end
+
+    super
+  end
+
+  private
+
+  def trailing_literal(node)
+    body = node.body
+    return nil unless body.is_a?(Prism::StatementsNode)
+    return nil if body.body.empty?
+
+    last = body.body.last
+    return nil unless LITERAL_NODE_TYPES.any? { |t| last.is_a?(t) }
+
+    last
+  end
+end

data/lib/evilution/mutator/operator/receiver_replacement.rb

@@ -3,8 +3,20 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::ReceiverReplacement < Evilution::Mutator::Base
+  # Ruby reserved words. A call like `self.class` — when stripped of its
+  # `self.` receiver — becomes the bare token `class`, which the parser reads
+  # as the class-definition keyword rather than a method call. Producing this
+  # mutation guarantees an unparseable result. Skip when the call's method
+  # name collides with any reserved keyword.
+  RUBY_RESERVED_KEYWORDS = %i[
+    BEGIN END __ENCODING__ __FILE__ __LINE__
+    alias and begin break case class def defined? do else elsif end
+    ensure false for if in module next nil not or redo rescue retry
+    return self super then true undef unless until when while yield
+  ].to_set.freeze
+
   def visit_call_node(node)
-    if node.receiver.is_a?(Prism::SelfNode)
+    if eligible_self_call?(node)
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,
@@ -18,6 +30,22 @@ class Evilution::Mutator::Operator::ReceiverReplacement < Evilution::Mutator::Ba
 
   private
 
+  def eligible_self_call?(node)
+    return false unless node.receiver.is_a?(Prism::SelfNode)
+    return false if reserved_keyword_method?(node.name)
+
+    true
+  end
+
+  # `self.class = value` is a writer call whose Prism `name` is `:class=` —
+  # not `:class` — so a literal lookup in RUBY_RESERVED_KEYWORDS misses it,
+  # and stripping the receiver leaves `class = value` (parse error). Normalize
+  # the trailing `=` from writer forms before comparing.
+  def reserved_keyword_method?(name)
+    base = name.to_s.chomp("=").to_sym
+    RUBY_RESERVED_KEYWORDS.include?(base)
+  end
+
   def call_without_self_text(node)
     message_start = node.message_loc.start_offset
     call_end = node.location.start_offset + node.location.length

data/lib/evilution/mutator/operator/rescue_removal.rb

@@ -3,27 +3,76 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::RescueRemoval < Evilution::Mutator::Base
-  def visit_rescue_node(node)
-    remove_start = line_start_before(node.keyword_loc.start_offset)
-    remove_end = rescue_end_offset(node)
+  # Visit BeginNode (not RescueNode directly) so we have access to sibling
+  # clauses — `else_clause`, `ensure_clause`, `end_keyword_loc` — which we
+  # need to compute the rescue clause's boundary and to drop a soon-to-be-
+  # orphaned `else` along with the rescue.
+  def visit_begin_node(node)
+    walk_rescue_chain(node) { |rescue_node| emit_removal(node, rescue_node) }
+
+    super
+  end
+
+  private
+
+  def walk_rescue_chain(begin_node)
+    current = begin_node.rescue_clause
+    while current
+      yield current
+      current = current.subsequent
+    end
+  end
+
+  def emit_removal(begin_node, rescue_node)
+    remove_start = line_start_before(rescue_node.keyword_loc.start_offset)
+    remove_end = rescue_clause_end(begin_node, rescue_node)
+    remove_end = else_end(begin_node) if removing_sole_rescue_orphans_else?(begin_node, rescue_node)
 
     add_mutation(
       offset: remove_start,
       length: remove_end - remove_start,
       replacement: "",
-      node: node
+      node: rescue_node
     )
+  end
 
-    super
+  # The rescue clause's bytes run from its `rescue` keyword up to the start
+  # of the next sibling clause: another `rescue`, then `else`, `ensure`, or
+  # the begin's `end`. Using these structural boundaries instead of the
+  # statements body fixes the underflow when the body is comment-only or
+  # otherwise empty — the old code stopped at the `rescue` keyword and left
+  # the exception class name orphaned in the source.
+  def rescue_clause_end(begin_node, rescue_node)
+    boundary = next_clause_start(begin_node, rescue_node)
+    line_start_before(boundary)
   end
 
-  private
+  def next_clause_start(begin_node, rescue_node)
+    return rescue_node.subsequent.keyword_loc.start_offset if rescue_node.subsequent
+    return begin_node.else_clause.else_keyword_loc.start_offset if begin_node.else_clause
+    return begin_node.ensure_clause.ensure_keyword_loc.start_offset if begin_node.ensure_clause
 
-  def rescue_end_offset(node)
-    return line_start_before(node.subsequent.keyword_loc.start_offset) if node.subsequent
+    begin_node.end_keyword_loc.start_offset
+  end
+
+  # An `else` clause is grammatically tied to a `rescue` chain. Stripping
+  # the last remaining rescue without also dropping `else` leaves
+  # `begin ... else ... end` which Ruby rejects. Detect: the chain has one
+  # rescue, and an else exists.
+  def removing_sole_rescue_orphans_else?(begin_node, rescue_node)
+    return false unless begin_node.else_clause
+    return false unless rescue_node == begin_node.rescue_clause
+    return false if rescue_node.subsequent
+
+    true
+  end
 
-    loc = node.statements ? node.statements.location : node.keyword_loc
-    loc.start_offset + loc.length
+  def else_end(begin_node)
+    if begin_node.ensure_clause
+      line_start_before(begin_node.ensure_clause.ensure_keyword_loc.start_offset)
+    else
+      line_start_before(begin_node.end_keyword_loc.start_offset)
+    end
   end
 
   def line_start_before(offset)