evilution 0.27.0 → 0.29.0

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

@@ -28,25 +28,30 @@ class Evilution::Integration::Loading::MutationApplier
     syntax_error = @syntax_validator.call(mutation.mutated_source)
     return syntax_error if syntax_error
 
+    apply(mutation)
+    nil
+  rescue SyntaxError => e
+    failure_result(e, "syntax error in mutated source: #{e.message}")
+  rescue ScriptError, StandardError => e
+    failure_result(e, "#{e.class}: #{e.message}")
+  end
+
+  private
+
+  def apply(mutation)
     @constant_pinner.call(mutation.original_source)
     @concern_state_cleaner.call(mutation.file_path)
     @redefinition_recovery.call(mutation.original_source) do
       @source_evaluator.call(mutation.mutated_source, mutation.file_path)
     end
-    nil
-  rescue SyntaxError => e
-    {
-      passed: false,
-      error: "syntax error in mutated source: #{e.message}",
-      error_class: e.class.name,
-      error_backtrace: Array(e.backtrace).first(5)
-    }
-  rescue ScriptError, StandardError => e
+  end
+
+  def failure_result(error, message)
     {
       passed: false,
-      error: "#{e.class}: #{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
 end

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

@@ -5,11 +5,15 @@ require_relative "../loading"
 # Evaluate source with __FILE__ set to the absolute original path so that
 # `require_relative` and `__dir__` resolve against the real source tree, where
 # sibling files actually exist.
+#
+# Trust boundary: `source` is never user-supplied. It is always the original
+# on-disk source from a file the user already pointed Evilution at, with
+# byte-level mutations applied by AST::SourceSurgeon. The only difference
+# between this eval path and a plain `require` of the same file is that we
+# substitute the mutated bytes — the privilege level is identical.
 class Evilution::Integration::Loading::SourceEvaluator
   def call(source, file_path)
     absolute = File.expand_path(file_path)
-    # rubocop:disable Security/Eval
     eval(source, TOPLEVEL_BINDING, absolute, 1)
-    # rubocop:enable Security/Eval
   end
 end

data/lib/evilution/integration/minitest.rb

@@ -10,22 +10,31 @@ require_relative "../integration"
 
 class Evilution::Integration::Minitest < Evilution::Integration::Base
   def self.baseline_runner
-    lambda { |test_file|
-      require "minitest"
-      require "stringio"
-      ::Minitest::Runnable.runnables.clear
-      files = File.directory?(test_file) ? Dir.glob(File.join(test_file, "**/*_test.rb")) : [test_file]
-      files.each { |f| load(File.expand_path(f)) }
-      out = StringIO.new
-      options = ::Minitest.process_args(["--seed", "0"])
-      options[:io] = out
-      reporter = ::Minitest::CompositeReporter.new
-      reporter << ::Minitest::SummaryReporter.new(out, options)
-      reporter.start
-      ::Minitest.__run(reporter, options)
-      reporter.report
-      reporter.passed?
-    }
+    ->(test_file) { run_baseline_test_file(test_file) }
+  end
+
+  def self.run_baseline_test_file(test_file)
+    require "minitest"
+    require "stringio"
+    ::Minitest::Runnable.runnables.clear
+    baseline_test_files(test_file).each { |f| load(File.expand_path(f)) }
+    run_baseline_minitest
+  end
+
+  def self.baseline_test_files(test_file)
+    File.directory?(test_file) ? Dir.glob(File.join(test_file, "**/*_test.rb")) : [test_file]
+  end
+
+  def self.run_baseline_minitest
+    out = StringIO.new
+    options = ::Minitest.process_args(["--seed", "0"])
+    options[:io] = out
+    reporter = ::Minitest::CompositeReporter.new
+    reporter << ::Minitest::SummaryReporter.new(out, options)
+    reporter.start
+    ::Minitest.__run(reporter, options)
+    reporter.report
+    reporter.passed?
   end
 
   def self.baseline_options

data/lib/evilution/integration/minitest_crash_detector.rb

@@ -34,11 +34,11 @@ class Evilution::Integration::MinitestCrashDetector
     end
   end
 
-  def has_assertion_failure? # rubocop:disable Naming/PredicatePrefix
+  def assertion_failure?
     @assertion_failures.positive?
   end
 
-  def has_crash? # rubocop:disable Naming/PredicatePrefix
+  def crashed?
     @crashes.any?
   end
 

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

@@ -9,7 +9,10 @@ class Evilution::Integration::RSpec::StateGuard::ObjectSpaceExampleGroups
     groups = Set.new
     ObjectSpace.each_object(Class) do |klass|
       groups << klass.object_id if klass < ::RSpec::Core::ExampleGroup
-    rescue TypeError # rubocop:disable Lint/SuppressedException
+    rescue TypeError
+      # ObjectSpace iteration may surface partially-initialized or anonymous
+      # classes whose `<` comparison raises. Skipping them is safe — they
+      # cannot be ExampleGroup descendants we need to track.
     end
     groups
   end
@@ -23,13 +26,18 @@ class Evilution::Integration::RSpec::StateGuard::ObjectSpaceExampleGroups
 
       klass.constants(false).each do |const|
         klass.send(:remove_const, const)
-      rescue NameError # rubocop:disable Lint/SuppressedException
+      rescue NameError
+        # Constant may have been removed concurrently (e.g. via autoload
+        # reload) between #constants(false) and #remove_const. Best-effort
+        # cleanup — nothing to do if it's already gone.
       end
 
       klass.instance_variables.each do |ivar|
         klass.remove_instance_variable(ivar)
       end
-    rescue TypeError # rubocop:disable Lint/SuppressedException
+    rescue TypeError
+      # Same defensive case as #snapshot: skip classes whose `<` raises
+      # mid-iteration.
     end
   end
 end

data/lib/evilution/integration/rspec.rb

@@ -74,6 +74,10 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     command = "rspec #{args.join(" ")}"
 
     reset_examples
+    execute_run(args, command)
+  end
+
+  def execute_run(args, command)
     detector = @crash_detector_lifecycle.current
     snapshot = @state_guard.snapshot
     begin

data/lib/evilution/isolation/fork.rb

@@ -5,6 +5,7 @@ require "tmpdir"
 require_relative "../memory"
 require_relative "../temp_dir_tracker"
 require_relative "../child_output"
+require_relative "../process_cleanup"
 
 require_relative "../isolation"
 
@@ -20,42 +21,52 @@ class Evilution::Isolation::Fork
     sandbox_dir = Dir.mktmpdir("evilution-run")
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     parent_rss = Evilution::Memory.rss_kb
+    read_io, write_io = binary_pipe
+    pid = fork_child(read_io, write_io, sandbox_dir, mutation, test_command)
+    write_io.close
+    result = wait_for_result(pid, read_io, timeout)
+    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+    build_mutation_result(mutation, result, duration, parent_rss)
+  ensure
+    cleanup_resources(read_io, write_io, pid, sandbox_dir)
+  end
+
+  private
+
+  # Marshal result payload is ASCII-8BIT; pipes default to text mode and may
+  # transcode according to their external/internal encodings (influenced by
+  # Encoding.default_external and/or Encoding.default_internal — Rails sets
+  # the latter to UTF-8), failing on bytes with no mapping. Force binmode on
+  # both ends.
+  def binary_pipe
     read_io, write_io = IO.pipe
-    # Marshal result payload is ASCII-8BIT; pipes default to text mode and may
-    # transcode according to their external/internal encodings (influenced by
-    # Encoding.default_external and/or Encoding.default_internal — Rails sets
-    # the latter to UTF-8), failing on bytes with no mapping. Force binmode on
-    # both ends.
     read_io.binmode
     write_io.binmode
+    [read_io, write_io]
+  end
 
-    pid = ::Process.fork do
+  def fork_child(read_io, write_io, sandbox_dir, mutation, test_command)
+    ::Process.fork do
       ENV["TMPDIR"] = sandbox_dir
       read_io.close
       suppress_child_output
-      @hooks.fire(:worker_process_start, mutation: mutation) if @hooks
+      @hooks.fire(:worker_process_start, mutation:) if @hooks
       result = execute_in_child(mutation, test_command)
       Marshal.dump(result, write_io)
       write_io.close
       exit!(result[:passed] ? 0 : 1)
     end
+  end
 
-    write_io.close
-    result = wait_for_result(pid, read_io, timeout)
-    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-
-    build_mutation_result(mutation, result, duration, parent_rss)
-  ensure
-    read_io&.close
-    write_io&.close
+  def cleanup_resources(read_io, write_io, pid, sandbox_dir)
+    read_io.close unless read_io.nil?
+    write_io.close unless write_io.nil?
     ensure_reaped(pid)
-    restore_original_source(mutation)
+    restore_original_source
     FileUtils.rm_rf(sandbox_dir) if sandbox_dir
   end
 
-  private
-
-  def restore_original_source(mutation) # rubocop:disable Lint/UnusedMethodArgument
+  def restore_original_source
     Evilution::TempDirTracker.cleanup_all
   end
 
@@ -88,7 +99,7 @@ class Evilution::Isolation::Fork
       if data.empty?
         { timeout: false, passed: false, error: "empty result from child" }
       else
-        { timeout: false }.merge(Marshal.load(data)) # rubocop:disable Security/MarshalLoad
+        { timeout: false }.merge(Marshal.load(data))
       end
     else
       terminate_child(pid)
@@ -113,7 +124,7 @@ class Evilution::Isolation::Fork
   end
 
   def terminate_child(pid)
-    ::Process.kill("TERM", pid) rescue nil # rubocop:disable Style/RescueModifier
+    Evilution::ProcessCleanup.safe_kill("TERM", pid)
     _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
     return if status
 
@@ -121,8 +132,8 @@ class Evilution::Isolation::Fork
     _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
     return if status
 
-    ::Process.kill("KILL", pid) rescue nil # rubocop:disable Style/RescueModifier
-    ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
+    Evilution::ProcessCleanup.safe_kill("KILL", pid)
+    Evilution::ProcessCleanup.safe_wait(pid)
   end
 
   def classify_status(result)
@@ -143,11 +154,15 @@ class Evilution::Isolation::Fork
       status: status,
       duration: duration,
       test_command: result[:test_command],
-      child_rss_kb: result[:child_rss_kb],
-      parent_rss_kb: parent_rss_kb,
-      error_message: result[:error],
-      error_class: result[:error_class],
-      error_backtrace: result[:error_backtrace]
+      memory: Evilution::Result::MemoryStats.from_fields(
+        child_rss_kb: result[:child_rss_kb],
+        parent_rss_kb: parent_rss_kb
+      ),
+      error: Evilution::Result::ErrorInfo.from_fields(
+        message: result[:error],
+        klass: result[:error_class],
+        backtrace: result[:error_backtrace]
+      )
     )
   end
 end

data/lib/evilution/isolation/in_process.rb

@@ -80,12 +80,16 @@ class Evilution::Isolation::InProcess
       status: status,
       duration: duration,
       test_command: result[:test_command],
-      child_rss_kb: rss_after,
-      memory_delta_kb: memory_delta_kb,
-      parent_rss_kb: rss_before,
-      error_message: result[:error],
-      error_class: result[:error_class],
-      error_backtrace: result[:error_backtrace]
+      memory: Evilution::Result::MemoryStats.from_fields(
+        child_rss_kb: rss_after,
+        memory_delta_kb: memory_delta_kb,
+        parent_rss_kb: rss_before
+      ),
+      error: Evilution::Result::ErrorInfo.from_fields(
+        message: result[:error],
+        klass: result[:error_class],
+        backtrace: result[:error_backtrace]
+      )
     )
   end
 end

data/lib/evilution/mcp/info_tool/actions/subjects.rb

@@ -10,34 +10,43 @@ class Evilution::MCP::InfoTool::Actions::Subjects < Evilution::MCP::InfoTool::Ac
   def self.call(files: nil, line_ranges: nil, target: nil, integration: nil, skip_config: nil, **)
     return config_error("files is required") if files.nil? || files.empty?
 
-    config = Evilution::MCP::InfoTool::ConfigFactory.subjects(
-      files: files, line_ranges: line_ranges,
-      target: target, integration: integration, skip_config: skip_config
-    )
-    runner = Evilution::Runner.new(config: config)
-    subjects = runner.parse_and_filter_subjects
-
-    registry = Evilution::Mutator::Registry.default
-    filter = build_subject_filter(config)
-    operator_options = { skip_heredoc_literals: config.skip_heredoc_literals? }
-
-    entries = subjects.map do |subj|
-      count = registry.mutations_for(subj, filter: filter, operator_options: operator_options).length
-      { "name" => subj.name, "file" => subj.file_path, "line" => subj.line_number, "mutations" => count }
-    ensure
-      subj.release_node!
-    end
-
-    success(
-      "subjects" => entries,
-      "total_subjects" => entries.length,
-      "total_mutations" => entries.sum { |e| e["mutations"] }
-    )
+    config = build_config(files, line_ranges, target, integration, skip_config)
+    subjects = Evilution::Runner.new(config: config).parse_and_filter_subjects
+    entries = subject_entries(subjects, config)
+    success_response(entries)
   end
 
   class << self
     private
 
+    def build_config(files, line_ranges, target, integration, skip_config)
+      Evilution::MCP::InfoTool::ConfigFactory.subjects(
+        files: files, line_ranges: line_ranges,
+        target: target, integration: integration, skip_config: skip_config
+      )
+    end
+
+    def subject_entries(subjects, config)
+      registry = Evilution::Mutator::Registry.default
+      filter = build_subject_filter(config)
+      operator_options = { skip_heredoc_literals: config.skip_heredoc_literals? }
+
+      subjects.map do |subj|
+        count = registry.mutations_for(subj, filter: filter, operator_options: operator_options).length
+        { "name" => subj.name, "file" => subj.file_path, "line" => subj.line_number, "mutations" => count }
+      ensure
+        subj.release_node!
+      end
+    end
+
+    def success_response(entries)
+      success(
+        "subjects" => entries,
+        "total_subjects" => entries.length,
+        "total_mutations" => entries.sum { |e| e["mutations"] }
+      )
+    end
+
     def build_subject_filter(config)
       return nil if config.ignore_patterns.empty?
 

data/lib/evilution/mcp/info_tool/actions/tests.rb

@@ -6,27 +6,37 @@ require_relative "../../../runner"
 require_relative "../../../spec_resolver"
 
 class Evilution::MCP::InfoTool::Actions::Tests < Evilution::MCP::InfoTool::Actions::Base
+  ResolveResult = Data.define(:resolved, :unresolved)
+  private_constant :ResolveResult
+
   def self.call(files: nil, spec: nil, integration: nil, skip_config: nil, **)
     return config_error("files is required") if files.nil? || files.empty?
 
-    config = Evilution::MCP::InfoTool::ConfigFactory.tests(
-      files: files, spec: spec, integration: integration, skip_config: skip_config
-    )
+    config = build_config(files, spec, integration, skip_config)
     return explicit_specs_response(files, config.spec_files) if config.spec_files.any?
 
-    resolver = resolver_for(config.integration)
-    resolved, unresolved = resolve_specs(files, resolver)
-    success(
-      "specs" => resolved,
-      "unresolved" => unresolved,
-      "total_sources" => files.length,
-      "total_specs" => resolved.map { |r| r["spec"] }.uniq.length
-    )
+    resolved_specs_response(files, resolver_for(config.integration))
   end
 
   class << self
     private
 
+    def build_config(files, spec, integration, skip_config)
+      Evilution::MCP::InfoTool::ConfigFactory.tests(
+        files: files, spec: spec, integration: integration, skip_config: skip_config
+      )
+    end
+
+    def resolved_specs_response(files, resolver)
+      result = resolve_specs(files, resolver)
+      success(
+        "specs" => result.resolved,
+        "unresolved" => result.unresolved,
+        "total_sources" => files.length,
+        "total_specs" => result.resolved.map { |r| r["spec"] }.uniq.length
+      )
+    end
+
     def resolver_for(integration)
       integration_class = Evilution::Runner::INTEGRATIONS[integration.to_sym]
       return Evilution::SpecResolver.new unless integration_class
@@ -54,7 +64,7 @@ class Evilution::MCP::InfoTool::Actions::Tests < Evilution::MCP::InfoTool::Actio
           unresolved << source
         end
       end
-      [resolved, unresolved]
+      ResolveResult.new(resolved: resolved, unresolved: unresolved)
     end
   end
 end

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

@@ -3,6 +3,8 @@
 require_relative "../info_tool"
 
 module Evilution::MCP::InfoTool::RequestParser
+  ParsedPaths = Data.define(:files, :ranges)
+
   module_function
 
   def parse_files(raw_files)
@@ -15,7 +17,7 @@ module Evilution::MCP::InfoTool::RequestParser
       ranges[file] = parse_line_range(range_str) if range_str
     end
 
-    [files, ranges]
+    ParsedPaths.new(files: files, ranges: ranges)
   end
 
   def parse_line_range(str)

data/lib/evilution/mcp/info_tool.rb

@@ -70,12 +70,17 @@ class Evilution::MCP::InfoTool < MCP::Tool
   )
 
   class << self
-    # rubocop:disable Lint/UnusedMethodArgument
     def call(server_context:, action: nil, files: nil, target: nil, spec: nil, integration: nil, skip_config: nil)
       return ResponseFormatter.error("config_error", "action is required") unless action
       return ResponseFormatter.error("config_error", "unknown action: #{action}") unless ACTIONS.key?(action)
 
-      parsed_files, line_ranges = RequestParser.parse_files(Array(files)) if files
+      parsed_files = nil
+      line_ranges = nil
+      if files
+        parsed = RequestParser.parse_files(Array(files))
+        parsed_files = parsed.files
+        line_ranges = parsed.ranges
+      end
 
       ACTIONS[action].call(
         files: parsed_files, line_ranges: line_ranges, target: target, spec: spec,
@@ -84,7 +89,6 @@ class Evilution::MCP::InfoTool < MCP::Tool
     rescue Evilution::Error => e
       ResponseFormatter.error_for(e)
     end
-    # rubocop:enable Lint/UnusedMethodArgument
   end
 end
 

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

@@ -8,6 +8,8 @@ module Evilution::MCP::MutateTool::OptionParser
                         isolation baseline save_session].freeze
   ALLOWED_OPT_KEYS = (PASSTHROUGH_KEYS + %i[spec skip_config]).freeze
 
+  ParsedPaths = Data.define(:files, :ranges)
+
   def self.parse_files(raw_files)
     files = []
     ranges = {}
@@ -20,7 +22,7 @@ module Evilution::MCP::MutateTool::OptionParser
       ranges[file] = parse_line_range(range_str)
     end
 
-    [files, ranges]
+    ParsedPaths.new(files: files, ranges: ranges)
   end
 
   def self.parse_line_range(str)

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

@@ -10,15 +10,19 @@ module Evilution::MCP::MutateTool::ProgressStreamer
 
     suggestion = Evilution::Reporter::Suggestion.new(suggest_tests: true, integration: integration)
     survivor_index = 0
+    disabled = false
 
     proc do |result|
       next unless result.survived?
+      next if disabled
 
       begin
         survivor_index += 1
         detail = build_suggestion_detail(result.mutation, suggestion)
         server_context.report_progress(survivor_index, message: ::JSON.generate(detail))
-      rescue StandardError # rubocop:disable Lint/SuppressedException
+      rescue StandardError => e
+        warn "[evilution] progress stream disabled after error: #{e.class}: #{e.message}"
+        disabled = true
       end
     end
   end

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

@@ -9,23 +9,33 @@ module Evilution::MCP::MutateTool::SurvivedEnricher
     entries = data["survived"]
     return unless entries.is_a?(Array)
 
-    explicit_spec = explicit_spec_override(config)
-    resolver = explicit_spec ? nil : resolver_for_integration(config.integration)
+    explicit_spec, resolver = build_resolver(config)
     cache = {}
 
     entries.each_with_index do |entry, index|
       result = survived_results[index]
       next unless result
 
-      mutation = result.mutation
-      entry["subject"] = mutation.subject.name
-      spec_file = explicit_spec || cache.fetch(mutation.file_path) do
-        cache[mutation.file_path] = resolver.call(mutation.file_path)
-      end
-      entry["spec_file"] = spec_file if spec_file
-      entry["next_step"] = build_next_step(mutation, spec_file)
+      enrich_entry(entry, result.mutation, explicit_spec, resolver, cache)
+    end
+  end
+
+  def self.build_resolver(config)
+    explicit_spec = explicit_spec_override(config)
+    resolver = explicit_spec ? nil : resolver_for_integration(config.integration)
+    [explicit_spec, resolver]
+  end
+  private_class_method :build_resolver
+
+  def self.enrich_entry(entry, mutation, explicit_spec, resolver, cache)
+    entry["subject"] = mutation.subject.name
+    spec_file = explicit_spec || cache.fetch(mutation.file_path) do
+      cache[mutation.file_path] = resolver.call(mutation.file_path)
     end
+    entry["spec_file"] = spec_file if spec_file
+    entry["next_step"] = build_next_step(mutation, spec_file)
   end
+  private_class_method :enrich_entry
 
   def self.explicit_spec_override(config)
     return nil unless config.respond_to?(:spec_files)

data/lib/evilution/mcp/mutate_tool.rb

@@ -105,37 +105,50 @@ class Evilution::MCP::MutateTool < MCP::Tool
 
   class << self
     def call(server_context:, files: [], verbosity: nil, **opts)
+      config = build_config(files, opts)
+      on_result = build_progress_streamer(server_context, opts, config)
+      summary = Evilution::Runner.new(config: config, on_result: on_result).call
+      compact = build_compact_report(summary, verbosity, opts, config)
+
+      ::MCP::Tool::Response.new([{ type: "text", text: compact }])
+    rescue Evilution::Error => e
+      payload = Evilution::MCP::MutateTool::ErrorPayload.build(e)
+      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }], error: true)
+    end
+
+    private
+
+    def build_config(files, opts)
       Evilution::MCP::MutateTool::OptionParser.validate!(opts)
-      parsed_files, line_ranges = Evilution::MCP::MutateTool::OptionParser.parse_files(Array(files))
-      config = Evilution::MCP::MutateTool::ConfigBuilder.build(
-        files: parsed_files,
-        line_ranges: line_ranges,
+      parsed = Evilution::MCP::MutateTool::OptionParser.parse_files(Array(files))
+      Evilution::MCP::MutateTool::ConfigBuilder.build(
+        files: parsed.files,
+        line_ranges: parsed.ranges,
         params: opts
       )
-      on_result = Evilution::MCP::MutateTool::ProgressStreamer.build(
+    end
+
+    def build_progress_streamer(server_context, opts, config)
+      Evilution::MCP::MutateTool::ProgressStreamer.build(
         server_context: server_context,
         suggest_tests: opts[:suggest_tests],
         integration: config.integration
       )
-      summary = Evilution::Runner.new(config: config, on_result: on_result).call
+    end
+
+    def build_compact_report(summary, verbosity, opts, config)
       report = Evilution::Reporter::JSON.new(
         suggest_tests: opts[:suggest_tests] == true,
         integration: config.integration
       ).call(summary)
-      normalized_verbosity = Evilution::MCP::MutateTool::OptionParser.normalize_verbosity(verbosity)
-      compact = Evilution::MCP::MutateTool::ReportTrimmer.call(
+      Evilution::MCP::MutateTool::ReportTrimmer.call(
         report,
-        verbosity: normalized_verbosity,
+        verbosity: Evilution::MCP::MutateTool::OptionParser.normalize_verbosity(verbosity),
         survived_results: summary.survived_results,
         config: config,
         enricher: Evilution::MCP::MutateTool::SurvivedEnricher,
         summary: summary
       )
-
-      ::MCP::Tool::Response.new([{ type: "text", text: compact }])
-    rescue Evilution::Error => e
-      payload = Evilution::MCP::MutateTool::ErrorPayload.build(e)
-      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }], error: true)
     end
   end
 end