evilution 0.25.0 → 0.27.0

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../config_factory"
+require_relative "../../../runner"
+require_relative "../../../spec_resolver"
+
+class Evilution::MCP::InfoTool::Actions::Tests < Evilution::MCP::InfoTool::Actions::Base
+  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
+    )
+    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
+    )
+  end
+
+  class << self
+    private
+
+    def resolver_for(integration)
+      integration_class = Evilution::Runner::INTEGRATIONS[integration.to_sym]
+      return Evilution::SpecResolver.new unless integration_class
+
+      integration_class.baseline_options[:spec_resolver] || Evilution::SpecResolver.new
+    end
+
+    def explicit_specs_response(files, spec_files)
+      success(
+        "specs" => spec_files.map { |f| { "source" => nil, "spec" => f } },
+        "unresolved" => [],
+        "total_sources" => files.length,
+        "total_specs" => spec_files.uniq.length
+      )
+    end
+
+    def resolve_specs(files, resolver)
+      resolved = []
+      unresolved = []
+      files.each do |source|
+        found = resolver.call(source)
+        if found
+          resolved << { "source" => source, "spec" => found }
+        else
+          unresolved << source
+        end
+      end
+      [resolved, unresolved]
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "mcp"
+require_relative "../../mcp"
+
+class Evilution::MCP::InfoTool < MCP::Tool; end unless defined?(Evilution::MCP::InfoTool)
+
+module Evilution::MCP::InfoTool::Actions
+end
+
+unless defined?(Evilution::MCP::InfoTool::Actions::Base)
+  class Evilution::MCP::InfoTool::Actions::Base # rubocop:disable Lint/EmptyClass
+  end
+end
+
+require_relative "../info_tool"

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../info_tool"
+require_relative "../../config"
+
+module Evilution::MCP::InfoTool::ConfigFactory
+  module_function
+
+  def subjects(files:, line_ranges:, target:, integration:, skip_config:)
+    opts = { target_files: files, line_ranges: line_ranges || {} }
+    opts[:skip_config_file] = true if skip_config
+    opts[:target] = target if target
+    opts[:integration] = integration if integration
+    Evilution::Config.new(**opts)
+  end
+
+  def tests(files:, spec:, integration:, skip_config:)
+    opts = { target_files: files }
+    opts[:skip_config_file] = true if skip_config
+    opts[:spec_files] = spec if spec
+    opts[:integration] = integration if integration
+    Evilution::Config.new(**opts)
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../info_tool"
+
+module Evilution::MCP::InfoTool::ErrorMapper
+  module_function
+
+  def type_for(error)
+    case error
+    when Evilution::ConfigError then "config_error"
+    when Evilution::ParseError  then "parse_error"
+    else "runtime_error"
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../info_tool"
+
+module Evilution::MCP::InfoTool::RequestParser
+  module_function
+
+  def parse_files(raw_files)
+    files = []
+    ranges = {}
+
+    raw_files.each do |arg|
+      file, range_str = arg.split(":", 2)
+      files << file
+      ranges[file] = parse_line_range(range_str) if range_str
+    end
+
+    [files, ranges]
+  end
+
+  def parse_line_range(str)
+    if str.include?("-")
+      start_str, end_str = str.split("-", 2)
+      start_line = Integer(start_str)
+      end_line = end_str.empty? ? Float::INFINITY : Integer(end_str)
+      start_line..end_line
+    else
+      line = Integer(str)
+      line..line
+    end
+  rescue ArgumentError, TypeError
+    raise Evilution::ParseError, "invalid line range: #{str.inspect}"
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../info_tool"
+require_relative "error_mapper"
+
+module Evilution::MCP::InfoTool::ResponseFormatter
+  module_function
+
+  def success(payload)
+    ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }])
+  end
+
+  def error(type, message)
+    ::MCP::Tool::Response.new(
+      [{ type: "text", text: ::JSON.generate({ error: { type: type, message: message } }) }],
+      error: true
+    )
+  end
+
+  def error_for(exception)
+    error(Evilution::MCP::InfoTool::ErrorMapper.type_for(exception), exception.message)
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../info_tool"
+require_relative "../../result/mutation_result"
+
+module Evilution::MCP::InfoTool::StatusGlossary
+  ENTRIES = [
+    {
+      "status" => "killed",
+      "meaning" => "A test failed when the mutation was applied — the test suite caught the mutation. " \
+                   "This is the desired outcome.",
+      "counted_in_score" => true
+    },
+    {
+      "status" => "survived",
+      "meaning" => "No test failed when the mutation was applied — gap in coverage. " \
+                   "The test suite did not detect the behavioral change.",
+      "counted_in_score" => true
+    },
+    {
+      "status" => "timeout",
+      "meaning" => "Test run exceeded the configured per-mutation timeout. " \
+                   "Treated like survived for scoring (counted in the denominator); " \
+                   "may indicate an infinite loop introduced by the mutation.",
+      "counted_in_score" => true
+    },
+    {
+      "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.",
+      "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). " \
+                   "Not a meaningful mutation signal.",
+      "counted_in_score" => false
+    },
+    {
+      "status" => "equivalent",
+      "meaning" => "Mutation is provably identical to the original source " \
+                   "(e.g. a no-op replacement that the parser or evaluator treats as semantically equal).",
+      "counted_in_score" => false
+    },
+    {
+      "status" => "unresolved",
+      "meaning" => "No spec/test file resolved for the mutated source — coverage gap, not a failure. " \
+                   "The file has no corresponding test file the resolver could locate.",
+      "counted_in_score" => false
+    },
+    {
+      "status" => "unparseable",
+      "meaning" => "Mutated source failed to parse (e.g. dangling heredoc after method_body_replacement). " \
+                   "Short-circuited before execution; no test run was attempted.",
+      "counted_in_score" => false
+    }
+  ].each(&:freeze).freeze
+
+  module_function
+
+  def entries
+    check_drift!
+    ENTRIES
+  end
+
+  def check_drift!
+    defined_statuses = Evilution::Result::MutationResult::STATUSES.map(&:to_s).sort
+    documented = ENTRIES.map { |s| s["status"] }.sort
+    return if defined_statuses == documented
+
+    missing = (defined_statuses - documented) + (documented - defined_statuses)
+    raise Evilution::Error, "status glossary drift: #{missing.inspect}"
+  end
+end

data/lib/evilution/mcp/info_tool.rb

@@ -13,25 +13,30 @@ require_relative "../version"
 require_relative "../mcp"
 
 class Evilution::MCP::InfoTool < MCP::Tool
+  VALID_ACTIONS = %w[subjects tests environment statuses feedback].freeze
+
   tool_name "evilution-info"
   description "Discover what evilution sees before running any mutations. " \
-              "One tool, four actions: " \
+              "One tool, five actions: " \
               "'subjects' lists every mutatable method in the target files 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); " \
               "'statuses' returns the mutation-result status glossary (killed/survived/neutral/error/etc.) with " \
-              "per-status meaning and scoring semantics so agents can triage results without guessing. " \
+              "per-status meaning and scoring semantics so agents can triage results without guessing; " \
+              "'feedback' returns the public discussion URL plus consent and privacy guidance for posting " \
+              "feedback on errors, usage problems, friction, or missing capabilities. " \
               "Use this instead of shelling out to 'evilution subjects', 'evilution tests list', or 'evilution environment show' — " \
               "the response is structured JSON so you can plan the next mutation run without parsing CLI text."
   input_schema(
     properties: {
       action: {
         type: "string",
-        enum: %w[subjects tests environment statuses],
+        enum: VALID_ACTIONS,
         description: "Which discovery operation to perform. " \
                      "'subjects' lists mutatable methods; 'tests' resolves specs for sources; " \
-                     "'environment' dumps effective config; 'statuses' returns the result-status glossary."
+                     "'environment' dumps effective config; 'statuses' returns the result-status glossary; " \
+                     "'feedback' returns the discussion URL and consent/privacy guidance."
       },
       files: {
         type: "array",
@@ -64,270 +69,47 @@ class Evilution::MCP::InfoTool < MCP::Tool
     required: ["action"]
   )
 
-  VALID_ACTIONS = %w[subjects tests environment statuses].freeze
-
-  STATUS_GLOSSARY = [
-    {
-      "status" => "killed",
-      "meaning" => "A test failed when the mutation was applied — the test suite caught the mutation. " \
-                   "This is the desired outcome.",
-      "counted_in_score" => true
-    },
-    {
-      "status" => "survived",
-      "meaning" => "No test failed when the mutation was applied — gap in coverage. " \
-                   "The test suite did not detect the behavioral change.",
-      "counted_in_score" => true
-    },
-    {
-      "status" => "timeout",
-      "meaning" => "Test run exceeded the configured per-mutation timeout. " \
-                   "Treated like survived for scoring (counted in the denominator); " \
-                   "may indicate an infinite loop introduced by the mutation.",
-      "counted_in_score" => true
-    },
-    {
-      "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.",
-      "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). " \
-                   "Not a meaningful mutation signal.",
-      "counted_in_score" => false
-    },
-    {
-      "status" => "equivalent",
-      "meaning" => "Mutation is provably identical to the original source " \
-                   "(e.g. a no-op replacement that the parser or evaluator treats as semantically equal).",
-      "counted_in_score" => false
-    },
-    {
-      "status" => "unresolved",
-      "meaning" => "No spec/test file resolved for the mutated source — coverage gap, not a failure. " \
-                   "The file has no corresponding test file the resolver could locate.",
-      "counted_in_score" => false
-    },
-    {
-      "status" => "unparseable",
-      "meaning" => "Mutated source failed to parse (e.g. dangling heredoc after method_body_replacement). " \
-                   "Short-circuited before execution; no test run was attempted.",
-      "counted_in_score" => false
-    }
-  ].freeze
-  private_constant :STATUS_GLOSSARY
-
   class << self
     # rubocop:disable Lint/UnusedMethodArgument
     def call(server_context:, action: nil, files: nil, target: nil, spec: nil, integration: nil, skip_config: nil)
-      return error_response("config_error", "action is required") unless action
-      return error_response("config_error", "unknown action: #{action}") unless VALID_ACTIONS.include?(action)
+      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 = parse_files(Array(files)) if files
+      parsed_files, line_ranges = RequestParser.parse_files(Array(files)) if files
 
-      case action
-      when "subjects"
-        subjects_action(files: parsed_files, line_ranges: line_ranges, target: target,
-                        integration: integration, skip_config: skip_config)
-      when "tests"
-        tests_action(files: parsed_files, spec: spec, integration: integration, skip_config: skip_config)
-      when "environment"
-        environment_action
-      when "statuses"
-        statuses_action
-      end
+      ACTIONS[action].call(
+        files: parsed_files, line_ranges: line_ranges, target: target, spec: spec,
+        integration: integration, skip_config: skip_config
+      )
     rescue Evilution::Error => e
-      error_response_for(e)
+      ResponseFormatter.error_for(e)
     end
     # rubocop:enable Lint/UnusedMethodArgument
-
-    private
-
-    def parse_files(raw_files)
-      files = []
-      ranges = {}
-
-      raw_files.each do |arg|
-        file, range_str = arg.split(":", 2)
-        files << file
-        ranges[file] = parse_line_range(range_str) if range_str
-      end
-
-      [files, ranges]
-    end
-
-    def parse_line_range(str)
-      if str.include?("-")
-        start_str, end_str = str.split("-", 2)
-        start_line = Integer(start_str)
-        end_line = end_str.empty? ? Float::INFINITY : Integer(end_str)
-        start_line..end_line
-      else
-        line = Integer(str)
-        line..line
-      end
-    rescue ArgumentError, TypeError
-      raise Evilution::ParseError, "invalid line range: #{str.inspect}"
-    end
-
-    def subjects_action(files:, line_ranges:, target:, integration:, skip_config:)
-      return error_response("config_error", "files is required") if files.nil? || files.empty?
-
-      config = build_subjects_config(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_response(
-        "subjects" => entries,
-        "total_subjects" => entries.length,
-        "total_mutations" => entries.sum { |e| e["mutations"] }
-      )
-    end
-
-    def tests_action(files:, spec:, integration:, skip_config:)
-      return error_response("config_error", "files is required") if files.nil? || files.empty?
-
-      config = build_tests_config(files: files, spec: spec, integration: integration, skip_config: skip_config)
-      return explicit_specs_response(files, config.spec_files) if config.spec_files.any?
-
-      resolver = resolver_for_integration(config.integration)
-      resolved, unresolved = resolve_specs(files, resolver)
-      success_response(
-        "specs" => resolved,
-        "unresolved" => unresolved,
-        "total_sources" => files.length,
-        "total_specs" => resolved.map { |r| r["spec"] }.uniq.length
-      )
-    end
-
-    def build_subjects_config(files:, line_ranges:, target:, integration:, skip_config:)
-      opts = { target_files: files, line_ranges: line_ranges || {} }
-      opts[:skip_config_file] = true if skip_config
-      opts[:target] = target if target
-      opts[:integration] = integration if integration
-      Evilution::Config.new(**opts)
-    end
-
-    def build_tests_config(files:, spec:, integration:, skip_config:)
-      opts = { target_files: files }
-      opts[:skip_config_file] = true if skip_config
-      opts[:spec_files] = spec if spec
-      opts[:integration] = integration if integration
-      Evilution::Config.new(**opts)
-    end
-
-    def resolver_for_integration(integration)
-      integration_class = Evilution::Runner::INTEGRATIONS[integration.to_sym]
-      return Evilution::SpecResolver.new unless integration_class
-
-      integration_class.baseline_options[:spec_resolver] || Evilution::SpecResolver.new
-    end
-
-    def explicit_specs_response(files, spec_files)
-      success_response(
-        "specs" => spec_files.map { |f| { "source" => nil, "spec" => f } },
-        "unresolved" => [],
-        "total_sources" => files.length,
-        "total_specs" => spec_files.length
-      )
-    end
-
-    def resolve_specs(files, resolver)
-      resolved = []
-      unresolved = []
-      files.each do |source|
-        found = resolver.call(source)
-        if found
-          resolved << { "source" => source, "spec" => found }
-        else
-          unresolved << source
-        end
-      end
-      [resolved, unresolved]
-    end
-
-    def environment_action
-      config = Evilution::Config.new(skip_config_file: false)
-      config_file = Evilution::Config::CONFIG_FILES.find { |path| File.exist?(path) }
-
-      success_response(
-        "version" => Evilution::VERSION,
-        "ruby" => RUBY_VERSION,
-        "config_file" => config_file,
-        "settings" => environment_settings(config)
-      )
-    end
-
-    def statuses_action
-      # Guard against drift: every STATUSES symbol must have a glossary entry.
-      defined = Evilution::Result::MutationResult::STATUSES.map(&:to_s).sort
-      documented = STATUS_GLOSSARY.map { |s| s["status"] }.sort
-      if defined != documented
-        missing = (defined - documented) + (documented - defined)
-        raise Evilution::Error, "status glossary drift: #{missing.inspect}"
-      end
-
-      success_response("statuses" => STATUS_GLOSSARY)
-    end
-
-    def error_response_for(error)
-      type = case error
-             when Evilution::ConfigError then "config_error"
-             when Evilution::ParseError then "parse_error"
-             else "runtime_error"
-             end
-      error_response(type, error.message)
-    end
-
-    def environment_settings(config)
-      {
-        "timeout" => config.timeout,
-        "format" => config.format,
-        "integration" => config.integration,
-        "jobs" => config.jobs,
-        "isolation" => config.isolation,
-        "baseline" => config.baseline,
-        "incremental" => config.incremental,
-        "fail_fast" => config.fail_fast,
-        "min_score" => config.min_score,
-        "suggest_tests" => config.suggest_tests,
-        "save_session" => config.save_session,
-        "target" => config.target,
-        "skip_heredoc_literals" => config.skip_heredoc_literals,
-        "ignore_patterns" => config.ignore_patterns
-      }
-    end
-
-    def build_subject_filter(config)
-      return nil if config.ignore_patterns.empty?
-
-      Evilution::AST::Pattern::Filter.new(config.ignore_patterns)
-    end
-
-    def success_response(payload)
-      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }])
-    end
-
-    def error_response(type, message)
-      ::MCP::Tool::Response.new(
-        [{ type: "text", text: ::JSON.generate({ error: { type: type, message: message } }) }],
-        error: true
-      )
-    end
   end
 end
+
+require_relative "info_tool/request_parser"
+require_relative "info_tool/error_mapper"
+require_relative "info_tool/response_formatter"
+require_relative "info_tool/status_glossary"
+require_relative "info_tool/config_factory"
+require_relative "info_tool/actions"
+require_relative "info_tool/actions/base"
+require_relative "info_tool/actions/subjects"
+require_relative "info_tool/actions/tests"
+require_relative "info_tool/actions/environment"
+require_relative "info_tool/actions/statuses"
+require_relative "info_tool/actions/feedback"
+
+Evilution::MCP::InfoTool.const_set(:ACTIONS, {
+  "subjects" => Evilution::MCP::InfoTool::Actions::Subjects,
+  "tests" => Evilution::MCP::InfoTool::Actions::Tests,
+  "environment" => Evilution::MCP::InfoTool::Actions::Environment,
+  "statuses" => Evilution::MCP::InfoTool::Actions::Statuses,
+  "feedback" => Evilution::MCP::InfoTool::Actions::Feedback
+}.freeze)
+Evilution::MCP::InfoTool.send(:private_constant, :ACTIONS)
+
+unless Evilution::MCP::InfoTool.send(:const_get, :ACTIONS).keys == Evilution::MCP::InfoTool::VALID_ACTIONS
+  raise "InfoTool action drift: ACTIONS keys do not match VALID_ACTIONS"
+end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "../mutate_tool"
+require_relative "../../feedback"
+require_relative "../../feedback/messages"
 
 module Evilution::MCP::MutateTool::ErrorPayload
   def self.build(error)
@@ -12,6 +14,11 @@ module Evilution::MCP::MutateTool::ErrorPayload
 
     payload = { type: type, message: error.message }
     payload[:file] = error.file if error.file
-    { error: payload }
+
+    {
+      error: payload,
+      feedback_url: Evilution::Feedback::DISCUSSION_URL,
+      feedback_hint: Evilution::Feedback::Messages.mcp_hint
+    }
   end
 end

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

@@ -2,13 +2,16 @@
 
 require "json"
 require_relative "../mutate_tool"
+require_relative "../../feedback"
+require_relative "../../feedback/detector"
+require_relative "../../feedback/messages"
 
 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
 
-  def self.call(json_string, verbosity:, survived_results:, config:, enricher:)
+  def self.call(json_string, verbosity:, survived_results:, config:, enricher:, summary: nil)
     data = ::JSON.parse(json_string)
     case verbosity
     when "full"
@@ -19,6 +22,7 @@ module Evilution::MCP::MutateTool::ReportTrimmer
       data.keep_if { |key, _| MINIMAL_KEYS.include?(key) }
     end
     enricher.call(data, survived_results, config)
+    embed_feedback(data, summary) unless verbosity == "minimal"
     ::JSON.generate(data)
   end
 
@@ -28,4 +32,12 @@ module Evilution::MCP::MutateTool::ReportTrimmer
     data[key].each { |entry| entry.delete("diff") }
   end
   private_class_method :strip_diffs
+
+  def self.embed_feedback(data, summary)
+    return unless Evilution::Feedback::Detector.friction?(summary)
+
+    data["feedback_url"]  = Evilution::Feedback::DISCUSSION_URL
+    data["feedback_hint"] = Evilution::Feedback::Messages.mcp_hint
+  end
+  private_class_method :embed_feedback
 end

data/lib/evilution/mcp/mutate_tool.rb

@@ -26,7 +26,9 @@ class Evilution::MCP::MutateTool < MCP::Tool
               "'subject' (Class#method), resolved 'spec_file', and a concrete 'next_step' hint — " \
               "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."
+              "and already trimmed for survived-mutant triage. " \
+              "Hitting errors, friction, or missing capabilities? See evilution-info action=feedback for the " \
+              "public feedback channel — ask the user before posting anything."
   input_schema(
     properties: {
       files: {
@@ -126,7 +128,8 @@ class Evilution::MCP::MutateTool < MCP::Tool
         verbosity: normalized_verbosity,
         survived_results: summary.survived_results,
         config: config,
-        enricher: Evilution::MCP::MutateTool::SurvivedEnricher
+        enricher: Evilution::MCP::MutateTool::SurvivedEnricher,
+        summary: summary
       )
 
       ::MCP::Tool::Response.new([{ type: "text", text: compact }])