evilution 0.25.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41c28afbfc162902708394c367eb87150663ac64ab7b2228ee72ab7bb3b0549b
-  data.tar.gz: 269ec61ea7f4d9f083247b022ba7e331bfce85ebc62d75151cf0b14d6769a8f9
+  metadata.gz: 3b561b61697995a22463ea15828357375b1ce9868ad6ee87f3f331336d26b890
+  data.tar.gz: 4a0cb24bfe2e9e9478ab5d752f05ea4ea69582e324e736241f1fe6b1e5e581cd
 SHA512:
-  metadata.gz: 11f61c28eca30a943b6632066b8992860e2bf67fb1a617e8cf0ac6ccfcbbce33d48baec4452a57127aacaeacf2f834f6d01350be091a5d2bbd279df226e5cbc0
-  data.tar.gz: 6d3c6f07b8ddda520966ef2bc9616752fa693499fff18e0542e3059a1f1ff16ae9a56f9b68fe96eea6b90cb41981e5f87bc540238a2fd2e29f166f629cf1259f
+  metadata.gz: 416aaea92d50fc3a969c350fd36d47e5b8b625ba4b1c64b66f208731cfaf1250714b8bc8e494bbc1586922357886dd96026f31e9f96b7e2cd849e43f402de3e3
+  data.tar.gz: e81fc9c5edfa9e25b4a7077f2776c2256bf5211bc5d88b53cc604ef735d64366ee3b3a294a480f49d3107c7634ff98459f6f46e0a8ede3248cec2b72007f940e

data/.beads/interactions.jsonl

@@ -230,3 +230,8 @@
 {"id":"int-94972aae","kind":"field_change","created_at":"2026-04-20T16:13:12.727090894Z","actor":"Denis Kiselev","issue_id":"EV-0fgx","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Merged via PR #813 (commit 262b9ae). Integration spec spec/evilution/compare/integration_spec.rb + e2e fixtures landed. 15/15 examples pass."}}
 {"id":"int-4d639e4e","kind":"field_change","created_at":"2026-04-20T16:57:42.95949164Z","actor":"Denis Kiselev","issue_id":"EV-ynlo","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Merged via PR #816. SourceAstCache content-keyed LRU + ExampleFilter integration + BaselineRunner wiring."}}
 {"id":"int-c15ed3e8","kind":"field_change","created_at":"2026-04-20T17:49:38.782150309Z","actor":"Denis Kiselev","issue_id":"EV-toid","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-842a1d3a","kind":"field_change","created_at":"2026-04-21T05:01:55.401885343Z","actor":"Denis Kiselev","issue_id":"EV-h8pw","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-c92539a9","kind":"field_change","created_at":"2026-04-21T05:04:50.605824487Z","actor":"Denis Kiselev","issue_id":"EV-vkq9","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-2abceed3","kind":"field_change","created_at":"2026-04-24T05:18:13.096916772Z","actor":"Denis Kiselev","issue_id":"EV-kjac","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-03bc2f7f","kind":"field_change","created_at":"2026-04-24T05:40:10.83959826Z","actor":"Denis Kiselev","issue_id":"EV-hklf","extra":{"field":"status","new_value":"closed","old_value":"in_progress","reason":"Closed"}}
+{"id":"int-2781044c","kind":"field_change","created_at":"2026-04-24T05:40:11.975030418Z","actor":"Denis Kiselev","issue_id":"EV-cpku","extra":{"field":"status","new_value":"closed","old_value":"open","reason":"Folded into EV-hklf — error rename 'no method found' → 'no subject matched' shipped in PR #872."}}

data/.claude/prompts/architect.md

@@ -66,17 +66,30 @@ Evilution
   ::AST::SourceSurgeon     # Text-level mutation at byte offsets
   ::Mutator::Base          # Abstract operator base (Prism::Visitor)
   ::Mutator::Registry      # Node type → operator mapping
-  ::Mutator::Operator::*   # 18 concrete mutation operators
+  ::Mutator::Operator::*   # 72 concrete mutation operators
   ::Isolation::Fork        # Fork + pipe per mutation
+  ::Integration::Base      # Template-method orchestrator; delegates mutation apply to Loading::MutationApplier
   ::Integration::RSpec     # RSpec programmatic test runner
+  ::Integration::Minitest  # Minitest programmatic test runner
+  ::Integration::Loading::MutationApplier      # Composes the mutation-apply pipeline
+  ::Integration::Loading::SyntaxValidator      # Prism parse check
+  ::Integration::Loading::SourceEvaluator      # eval w/ TOPLEVEL_BINDING + absolute path
+  ::Integration::Loading::ConstantPinner       # const_get top-level constants to defeat Zeitwerk re-autoload
+  ::Integration::Loading::RedefinitionRecovery # Strip constants + retry on "already defined"
+  ::Integration::Loading::ConcernStateCleaner  # Clear AS::Concern @_included_block / @_prepended_block
+  ::AST::ConstantNames     # Prism walk → fully-qualified class/module names
+  ::LoadPath::SubpathResolver # Shortest $LOAD_PATH-relative path for a file
   ::Coverage::Collector    # Ruby Coverage module wrapper
   ::Coverage::TestMap      # Source line → test file mapping
+  ::Compare::Categorizer   # Fixed / new / persistent / flaky / reintroduced bucketing
+  ::Compare::Normalizer    # Canonicalize mutation records for cross-run compare
   ::Diff::Parser           # Git diff output parser
   ::Diff::FileFilter       # Filter subjects to changed code
   ::Result::MutationResult # Single mutation outcome
   ::Result::Summary        # Aggregated results
   ::Reporter::JSON         # Structured output for AI agents
   ::Reporter::CLI          # Human-readable terminal output
+  ::Reporter::HTML         # Section-based HTML report
   ::Reporter::Suggestion   # Actionable fix hint generator
 ```
 

data/.claude/skills/create-issue/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: create-issue
+description: Create a beads issue and a matching GitHub issue, cross-linked via external-ref and description
+argument-hint: "--title <title> --description <desc> --type <type> --priority <0-4>"
+user-invocable: true
+disable-model-invocation: true
+---
+
+# Create Cross-Linked Issue (Beads + GitHub)
+
+Create a beads issue and a matching GitHub issue in Port-Royal/vanilla-mafia, with each linking to the other.
+
+## Arguments
+
+All arguments are passed as `$ARGUMENTS`. Parse them as bd-style flags:
+
+- `--title` (required): Issue title
+- `--description` (required): Why this issue exists and what needs to be done
+- `--type` (required): `bug`, `feature`, or `task`
+- `--priority` (required): 0-4 (0=critical, 4=backlog)
+- `--parent` (optional): Parent beads issue ID for sub-tasks
+
+Example:
+```
+/create-issue --title "Fix login redirect" --description "After login, users are redirected to /dashboard instead of the page they came from" --type bug --priority 1
+```
+
+## Steps
+
+1. **Create the GitHub issue first** (to get the GH number):
+   ```
+   gh issue create --repo Port-Royal/vanilla-mafia --title "<title>" --body "<description>"
+   ```
+   Extract the issue number from the output.
+
+2. **Create the beads issue** with `--external-ref gh-<number>`:
+   ```
+   bd create --title "<title>" --description "<description>\n\nGH: #<gh-number>" --type <type> --priority <priority> --external-ref gh-<number>
+   ```
+   Extract the beads issue ID from the output.
+
+3. **Update the GitHub issue body** to include the beads ID:
+   ```
+   gh api repos/Port-Royal/vanilla-mafia/issues/<number> --method PATCH -f body="<description>
+
+   Beads: <beads-id>"
+   ```
+   Use `gh api` (not `gh issue edit`) to avoid the Projects Classic GraphQL error.
+
+4. **If `--parent` was provided**, set the parent on the beads issue:
+   ```
+   bd update <beads-id> --parent <parent-id>
+   ```
+
+5. **Display the result**: show both IDs in format `<beads-id> (GH #<number>)`.

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.26.0] - 2026-04-24
+
+### Removed
+
+- **Deprecated MCP session tools removed** — `evilution-session-list`, `evilution-session-show`, `evilution-session-diff` shims (deprecated since #637 after consolidation into `evilution-session`) deleted (#686, PR #851)
+
+### Fixed
+
+- **`preload` silently ignored under `:in_process` isolation** — `Runner::IsolationResolver#perform_preload` gated the preload on `resolve_isolation == :fork`, so non-Rails projects (auto-resolving to `:in_process`) silently skipped `preload:` from `.evilution.yml` or `--preload`. Preload now runs for `:in_process` too (#868, PR #871)
+- **`--target ClassName` silently narrowed to git-changed files** — when only a class/method target was given with no file scope, `Runner::SubjectPipeline#target_files` fell back to `Git::ChangedFiles`, producing a misleading `no method found matching 'X'` error when the class file was not in the working-tree diff. Target files now resolve from the configured source when a method/class target is given without explicit file scope (#869, PR #872)
+
+### Changed
+
+- **Internal `Evilution::Compare` refactor** — `lib/evilution/compare.rb` split into one class per file under `lib/evilution/compare/` (`Categorizer`, `Detector`, `Fingerprint`, `InvalidInput`, `Normalizer`, `Record`); `rubocop:disable Style/OneClassPerFile` removed (#825, PR #852)
+- **Internal `Evilution::Integration::Base` refactor** — decomposed into focused collaborators under `Evilution::Integration::Loading::*` (`SyntaxValidator`, `SourceEvaluator`, `ConstantPinner`, `RedefinitionRecovery`, `ConcernStateCleaner`, `MutationApplier`) plus shared helpers `Evilution::AST::ConstantNames` and `Evilution::LoadPath::SubpathResolver`. `Integration::Base` now delegates mutation application to an injectable `MutationApplier`; no user-visible behavior change (#845, PR #873)
+
 ## [0.25.0] - 2026-04-21
 
 ### Added

data/lib/evilution/ast/constant_names.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../ast"
+
+# Walks a Prism AST and returns every class/module constant declared, nested
+# names rendered fully-qualified (e.g. "Foo::Bar"). Order is source order:
+# outer declarations precede their nested children.
+class Evilution::AST::ConstantNames
+  def call(source)
+    result = Prism.parse(source)
+    return [] if result.failure?
+
+    collect(result.value)
+  end
+
+  private
+
+  def collect(node, nesting = [])
+    names = []
+    case node
+    when Prism::ModuleNode, Prism::ClassNode
+      const = node.constant_path.full_name
+      qualified = nesting.any? && !const.include?("::") ? "#{nesting.join("::")}::#{const}" : const
+      names << qualified
+      names.concat(collect(node.body, nesting + [const])) if node.body
+    when Prism::ProgramNode
+      names.concat(collect(node.statements, nesting)) if node.statements
+    when Prism::StatementsNode
+      node.body.each { |child| names.concat(collect(child, nesting)) }
+    end
+    names
+  end
+end

data/lib/evilution/compare/invalid_input.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "../compare"
+
+class Evilution::Compare::InvalidInput < StandardError
+  attr_reader :index
+
+  def initialize(message, index: nil)
+    super(message)
+    @index = index
+  end
+end

data/lib/evilution/compare.rb

@@ -1,15 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/OneClassPerFile
 module Evilution::Compare
 end
 
-class Evilution::Compare::InvalidInput < StandardError
-  attr_reader :index
-
-  def initialize(message, index: nil)
-    super(message)
-    @index = index
-  end
-end
-# rubocop:enable Style/OneClassPerFile
+require_relative "compare/invalid_input"

data/lib/evilution/integration/base.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "prism"
 require_relative "../integration"
+require_relative "loading/mutation_applier"
 
 class Evilution::Integration::Base
   def self.baseline_runner
@@ -12,14 +12,15 @@ class Evilution::Integration::Base
     raise NotImplementedError, "#{name}.baseline_options must be implemented"
   end
 
-  def initialize(hooks: nil)
+  def initialize(hooks: nil, mutation_applier: Evilution::Integration::Loading::MutationApplier.new)
     @hooks = hooks
+    @mutation_applier = mutation_applier
   end
 
   def call(mutation)
     ensure_framework_loaded
     fire_hook(:mutation_insert_pre, mutation: mutation, file_path: mutation.file_path)
-    load_error = apply_mutation(mutation)
+    load_error = @mutation_applier.call(mutation)
     return load_error if load_error
 
     fire_hook(:mutation_insert_post, mutation: mutation, file_path: mutation.file_path)
@@ -47,156 +48,4 @@ class Evilution::Integration::Base
   def fire_hook(event, **payload)
     @hooks.fire(event, **payload) if @hooks
   end
-
-  def apply_mutation(mutation)
-    prism_error = validate_mutated_syntax(mutation.mutated_source)
-    return prism_error if prism_error
-
-    pin_autoloaded_constants(mutation.original_source)
-    clear_concern_state(mutation.file_path)
-    with_redefinition_recovery(mutation.original_source) do
-      eval_mutated_source(mutation)
-    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
-    {
-      passed: false,
-      error: "#{e.class}: #{e.message}",
-      error_class: e.class.name,
-      error_backtrace: Array(e.backtrace).first(5)
-    }
-  end
-
-  def validate_mutated_syntax(source)
-    return nil if Prism.parse(source).success?
-
-    {
-      passed: false,
-      error: "mutated source has syntax errors",
-      error_class: "SyntaxError",
-      error_backtrace: []
-    }
-  end
-
-  # Evaluate the mutated source with __FILE__ set to the original path so
-  # that `require_relative` and `__dir__` resolve against the real source
-  # tree, where sibling files actually exist.
-  def eval_mutated_source(mutation)
-    absolute = File.expand_path(mutation.file_path)
-    # rubocop:disable Security/Eval
-    eval(mutation.mutated_source, TOPLEVEL_BINDING, absolute, 1)
-    # rubocop:enable Security/Eval
-  end
-
-  def with_redefinition_recovery(original_source)
-    yield
-  rescue ArgumentError => e
-    raise unless redefinition_conflict?(e)
-
-    remove_defined_constants(original_source)
-    yield
-  end
-
-  def redefinition_conflict?(error)
-    error.message.include?("already defined")
-  end
-
-  def pin_autoloaded_constants(source)
-    collect_constant_names(Prism.parse(source).value).each do |name|
-      Object.const_get(name) if Object.const_defined?(name, false)
-    rescue NameError # :nodoc:
-      nil
-    end
-  end
-
-  def collect_constant_names(node, nesting = [])
-    names = []
-    case node
-    when Prism::ModuleNode, Prism::ClassNode
-      const = node.constant_path.full_name
-      qualified = nesting.any? && !const.include?("::") ? "#{nesting.join("::")}::#{const}" : const
-      names << qualified
-      names.concat(collect_constant_names(node.body, nesting + [const])) if node.body
-    when Prism::ProgramNode
-      names.concat(collect_constant_names(node.statements, nesting)) if node.statements
-    when Prism::StatementsNode
-      node.body.each { |child| names.concat(collect_constant_names(child, nesting)) }
-    end
-    names
-  end
-
-  def remove_defined_constants(source)
-    collect_constant_names(Prism.parse(source).value).reverse_each do |name|
-      parent_name, _, local_name = name.rpartition("::")
-      parent = resolve_loaded_constant_parent(parent_name)
-      next unless parent
-      next unless parent.const_defined?(local_name, false)
-      next if parent.autoload?(local_name)
-
-      parent.send(:remove_const, local_name.to_sym)
-    end
-  end
-
-  def resolve_loaded_constant_parent(parent_name)
-    return Object if parent_name.empty?
-
-    parent_name.split("::").reduce(Object) do |mod, part|
-      return nil unless mod.const_defined?(part, false)
-      return nil if mod.autoload?(part)
-
-      resolved = mod.const_get(part, false)
-      return nil unless resolved.is_a?(Module)
-
-      resolved
-    end
-  end
-
-  def clear_concern_state(file_path)
-    return unless defined?(ActiveSupport::Concern)
-
-    absolute = File.expand_path(file_path)
-    subpath = resolve_require_subpath(file_path)
-
-    ObjectSpace.each_object(Module) do |mod|
-      next unless mod.singleton_class.ancestors.include?(ActiveSupport::Concern)
-
-      %i[@_included_block @_prepended_block].each do |ivar|
-        next unless mod.instance_variable_defined?(ivar)
-
-        block = mod.instance_variable_get(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)
-      end
-    end
-  end
-
-  def source_matches?(block_path, absolute, subpath)
-    block_path == absolute || (subpath && block_path.end_with?("/#{subpath}"))
-  end
-
-  def resolve_require_subpath(file_path)
-    absolute = File.expand_path(file_path)
-    best_subpath = nil
-
-    $LOAD_PATH.each do |entry|
-      dir = File.expand_path(entry)
-      prefix = dir.end_with?("/") ? dir : "#{dir}/"
-      next unless absolute.start_with?(prefix)
-
-      candidate = absolute.delete_prefix(prefix)
-      best_subpath = candidate if best_subpath.nil? || candidate.length < best_subpath.length
-    end
-
-    best_subpath
-  end
 end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+require_relative "../../load_path/subpath_resolver"
+
+# Re-evaluating an `ActiveSupport::Concern` module raises
+# "MultipleIncludedBlocks" because AS::Concern records the block source
+# location on the first include/prepend call. Before a re-eval we clear the
+# `@_included_block` / `@_prepended_block` ivar on modules whose block came
+# from the file we're about to re-eval.
+class Evilution::Integration::Loading::ConcernStateCleaner
+  IVARS = %i[@_included_block @_prepended_block].freeze
+
+  def initialize(subpath_resolver: Evilution::LoadPath::SubpathResolver.new)
+    @subpath_resolver = subpath_resolver
+  end
+
+  def call(file_path)
+    return unless defined?(ActiveSupport::Concern)
+
+    absolute = File.expand_path(file_path)
+    subpath = @subpath_resolver.call(file_path)
+
+    ObjectSpace.each_object(Module) do |mod|
+      next unless mod.singleton_class.ancestors.include?(ActiveSupport::Concern)
+
+      clear_concern_ivars(mod, absolute, subpath)
+    end
+  end
+
+  private
+
+  def clear_concern_ivars(mod, absolute, subpath)
+    IVARS.each do |ivar|
+      next unless mod.instance_variable_defined?(ivar)
+
+      block = mod.instance_variable_get(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)
+    end
+  end
+
+  def source_matches?(block_path, absolute, subpath)
+    block_path == absolute || (subpath && block_path.end_with?("/#{subpath}"))
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+require_relative "../../ast/constant_names"
+
+# Defeat Zeitwerk's re-autoload hook when we re-eval a file in place. Walking
+# the source AST for top-level class/module names and calling `const_get` on
+# each tells Zeitwerk "this constant is loaded" so our re-eval does not lose
+# state (e.g. `@_included_block`) to a follow-up autoload.
+class Evilution::Integration::Loading::ConstantPinner
+  def initialize(constant_names: Evilution::AST::ConstantNames.new)
+    @constant_names = constant_names
+  end
+
+  def call(source)
+    names = @constant_names.call(source)
+    names.each do |name|
+      Object.const_get(name) if Object.const_defined?(name, false)
+    rescue NameError # :nodoc:
+      nil
+    end
+    names
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+require_relative "syntax_validator"
+require_relative "constant_pinner"
+require_relative "concern_state_cleaner"
+require_relative "source_evaluator"
+require_relative "redefinition_recovery"
+
+# Composes the load-time pipeline that applies a mutation's new source to the
+# running VM: syntax-validate -> pin top-level constants (beats Zeitwerk) ->
+# clear AS::Concern state -> eval inside a redefinition-recovery wrapper.
+# Returns nil on success or a failure-shaped hash on any error.
+class Evilution::Integration::Loading::MutationApplier
+  def initialize(syntax_validator: Evilution::Integration::Loading::SyntaxValidator.new,
+                 constant_pinner: Evilution::Integration::Loading::ConstantPinner.new,
+                 concern_state_cleaner: Evilution::Integration::Loading::ConcernStateCleaner.new,
+                 source_evaluator: Evilution::Integration::Loading::SourceEvaluator.new,
+                 redefinition_recovery: Evilution::Integration::Loading::RedefinitionRecovery.new)
+    @syntax_validator = syntax_validator
+    @constant_pinner = constant_pinner
+    @concern_state_cleaner = concern_state_cleaner
+    @source_evaluator = source_evaluator
+    @redefinition_recovery = redefinition_recovery
+  end
+
+  def call(mutation)
+    syntax_error = @syntax_validator.call(mutation.mutated_source)
+    return syntax_error if syntax_error
+
+    @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
+    {
+      passed: false,
+      error: "#{e.class}: #{e.message}",
+      error_class: e.class.name,
+      error_backtrace: Array(e.backtrace).first(5)
+    }
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+require_relative "../../ast/constant_names"
+
+# Some DSLs (Rails 8 enum, define_method guards) raise ArgumentError on
+# re-declaration. On such a conflict we strip constants declared in the source
+# and retry the load once against a fresh namespace.
+class Evilution::Integration::Loading::RedefinitionRecovery
+  def initialize(constant_names: Evilution::AST::ConstantNames.new)
+    @constant_names = constant_names
+  end
+
+  def call(source, &block)
+    block.call
+  rescue ArgumentError => e
+    raise unless redefinition_conflict?(e)
+
+    remove_defined_constants(source)
+    block.call
+  end
+
+  private
+
+  def redefinition_conflict?(error)
+    error.message.include?("already defined")
+  end
+
+  def remove_defined_constants(source)
+    @constant_names.call(source).reverse_each do |name|
+      parent_name, _, local_name = name.rpartition("::")
+      parent = resolve_loaded_constant_parent(parent_name)
+      next unless parent
+      next unless parent.const_defined?(local_name, false)
+      next if parent.autoload?(local_name)
+
+      parent.send(:remove_const, local_name.to_sym)
+    end
+  end
+
+  def resolve_loaded_constant_parent(parent_name)
+    return Object if parent_name.empty?
+
+    parent_name.split("::").reduce(Object) do |mod, part|
+      return nil unless mod.const_defined?(part, false)
+      return nil if mod.autoload?(part)
+
+      resolved = mod.const_get(part, false)
+      return nil unless resolved.is_a?(Module)
+
+      resolved
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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.
+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/loading/syntax_validator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../loading"
+
+class Evilution::Integration::Loading::SyntaxValidator
+  ERROR_MESSAGE = "mutated source has syntax errors"
+
+  def call(source)
+    return nil if Prism.parse(source).success?
+
+    {
+      passed: false,
+      error: ERROR_MESSAGE,
+      error_class: "SyntaxError",
+      error_backtrace: []
+    }
+  end
+end

data/lib/evilution/integration/loading.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+
+module Evilution::Integration::Loading
+end

data/lib/evilution/load_path/subpath_resolver.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../load_path"
+
+# Given an absolute (or expandable) file path, returns the shortest path
+# relative to any `$LOAD_PATH` entry the file lives under, or nil if the file
+# is outside every entry. The shortest match wins because a deeper LOAD_PATH
+# entry yields a shorter subpath that better matches `require` resolution.
+class Evilution::LoadPath::SubpathResolver
+  def call(file_path)
+    absolute = File.expand_path(file_path)
+    best_subpath = nil
+
+    $LOAD_PATH.each do |entry|
+      dir = File.expand_path(entry)
+      prefix = dir.end_with?("/") ? dir : "#{dir}/"
+      next unless absolute.start_with?(prefix)
+
+      candidate = absolute.delete_prefix(prefix)
+      best_subpath = candidate if best_subpath.nil? || candidate.length < best_subpath.length
+    end
+
+    best_subpath
+  end
+end

data/lib/evilution/load_path.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Evilution::LoadPath
+end

data/lib/evilution/runner/isolation_resolver.rb

@@ -30,10 +30,10 @@ class Evilution::Runner::IsolationResolver
 
   def perform_preload
     return if config.preload == false
-    return unless resolve_isolation == :fork
 
     path = resolve_preload_path
     return unless path
+    return unless should_preload?
 
     prepare_load_path_for_preload
     require File.expand_path(path)
@@ -48,6 +48,17 @@ class Evilution::Runner::IsolationResolver
 
   attr_reader :config, :hooks
 
+  # Under :fork, allow preloading — caller resolves whether a path exists (an
+  # explicit --preload / preload: value, or an auto-detected rails_helper) and
+  # bails early when none does. Under :in_process, only allow preloading when
+  # the user explicitly asked via --preload or preload: in YAML — don't
+  # auto-load spec/rails_helper.rb for a user who opted out of fork.
+  def should_preload?
+    return true if resolve_isolation == :fork
+
+    config.preload.is_a?(String)
+  end
+
   def target_files
     @target_files ||= @target_files_callback.call
   end

data/lib/evilution/runner/subject_pipeline.rb

@@ -20,13 +20,7 @@ class Evilution::Runner::SubjectPipeline
   end
 
   def target_files
-    @target_files ||= if source_glob_target?
-                        resolve_source_glob
-                      elsif !config.target_files.empty?
-                        config.target_files
-                      else
-                        Evilution::Git::ChangedFiles.new.call
-                      end
+    @target_files ||= resolve_target_files
   end
 
   private
@@ -88,11 +82,27 @@ class Evilution::Runner::SubjectPipeline
 
   def filter_by_target(subjects)
     matched = subjects.select(&target_matcher)
-    raise Evilution::Error, "no method found matching '#{config.target}'" if matched.empty?
+    raise Evilution::Error, build_no_match_error if matched.empty?
 
     matched
   end
 
+  def resolve_target_files
+    return resolve_source_glob if source_glob_target?
+    return config.target_files unless config.target_files.empty?
+
+    @used_git_fallback = true
+    Evilution::Git::ChangedFiles.new.call
+  end
+
+  def build_no_match_error
+    base = "no subject matched '#{config.target}'"
+    return base unless @used_git_fallback
+
+    "#{base}; scanned git-changed files only. Pass file paths or " \
+      "--target source:<glob> to scan the full codebase."
+  end
+
   def target_matcher
     target = config.target
     if target.end_with?("*")

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "0.25.0"
+  VERSION = "0.26.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-20 00:00:00.000000000 Z
+date: 2026-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -72,6 +72,7 @@ files:
 - ".claude/prompts/devops.md"
 - ".claude/prompts/tests.md"
 - ".claude/settings.json"
+- ".claude/skills/create-issue/SKILL.md"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
@@ -88,6 +89,7 @@ files:
 - exe/evilution
 - lib/evilution.rb
 - lib/evilution/ast.rb
+- lib/evilution/ast/constant_names.rb
 - lib/evilution/ast/inheritance_scanner.rb
 - lib/evilution/ast/parser.rb
 - lib/evilution/ast/pattern.rb
@@ -135,6 +137,7 @@ files:
 - lib/evilution/compare/categorizer.rb
 - lib/evilution/compare/detector.rb
 - lib/evilution/compare/fingerprint.rb
+- lib/evilution/compare/invalid_input.rb
 - lib/evilution/compare/normalizer.rb
 - lib/evilution/compare/record.rb
 - lib/evilution/config.rb
@@ -158,12 +161,21 @@ files:
 - lib/evilution/integration.rb
 - lib/evilution/integration/base.rb
 - lib/evilution/integration/crash_detector.rb
+- lib/evilution/integration/loading.rb
+- lib/evilution/integration/loading/concern_state_cleaner.rb
+- lib/evilution/integration/loading/constant_pinner.rb
+- lib/evilution/integration/loading/mutation_applier.rb
+- lib/evilution/integration/loading/redefinition_recovery.rb
+- lib/evilution/integration/loading/source_evaluator.rb
+- lib/evilution/integration/loading/syntax_validator.rb
 - lib/evilution/integration/minitest.rb
 - lib/evilution/integration/minitest_crash_detector.rb
 - lib/evilution/integration/rspec.rb
 - lib/evilution/isolation.rb
 - lib/evilution/isolation/fork.rb
 - lib/evilution/isolation/in_process.rb
+- lib/evilution/load_path.rb
+- lib/evilution/load_path/subpath_resolver.rb
 - lib/evilution/mcp.rb
 - lib/evilution/mcp/info_tool.rb
 - lib/evilution/mcp/mutate_tool.rb
@@ -174,9 +186,6 @@ files:
 - lib/evilution/mcp/mutate_tool/report_trimmer.rb
 - lib/evilution/mcp/mutate_tool/survived_enricher.rb
 - lib/evilution/mcp/server.rb
-- lib/evilution/mcp/session_diff_tool.rb
-- lib/evilution/mcp/session_list_tool.rb
-- lib/evilution/mcp/session_show_tool.rb
 - lib/evilution/mcp/session_tool.rb
 - lib/evilution/memory.rb
 - lib/evilution/memory/leak_check.rb

data/lib/evilution/mcp/session_diff_tool.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "mcp"
-require_relative "../session/store"
-require_relative "../session/diff"
-
-require_relative "../mcp"
-
-# @deprecated Superseded by {Evilution::MCP::SessionTool} (action: "diff") as of 0.22.8.
-#   No longer registered with the MCP server; retained only for direct Ruby callers.
-#   Will be removed entirely — tracked by EV-h8pw / GH #686.
-class Evilution::MCP::SessionDiffTool < MCP::Tool
-  tool_name "evilution-session-diff"
-  description "DEPRECATED: use evilution-session with action: 'diff'. " \
-              "Compare two mutation testing sessions and return the diff. " \
-              "Shows new regressions, fixed mutations, and persistent survivors."
-  input_schema(
-    properties: {
-      base: {
-        type: "string",
-        description: "Path to the base (older) session JSON file"
-      },
-      head: {
-        type: "string",
-        description: "Path to the head (newer) session JSON file"
-      }
-    }
-  )
-
-  class << self
-    # rubocop:disable Lint/UnusedMethodArgument
-    def call(server_context:, base: nil, head: nil)
-      return error_response("config_error", "base is required") unless base
-      return error_response("config_error", "head is required") unless head
-
-      store = Evilution::Session::Store.new
-      base_data = store.load(base)
-      head_data = store.load(head)
-
-      diff = Evilution::Session::Diff.new
-      result = diff.call(base_data, head_data)
-
-      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(result.to_h) }])
-    rescue Evilution::Error => e
-      error_response("not_found", e.message)
-    rescue ::JSON::ParserError => e
-      error_response("parse_error", e.message)
-    rescue SystemCallError => e
-      error_response("runtime_error", e.message)
-    end
-    # rubocop:enable Lint/UnusedMethodArgument
-
-    private
-
-    def error_response(type, message)
-      ::MCP::Tool::Response.new(
-        [{ type: "text", text: ::JSON.generate({ error: { type: type, message: message } }) }],
-        error: true
-      )
-    end
-  end
-end

data/lib/evilution/mcp/session_list_tool.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "mcp"
-require_relative "../session/store"
-
-require_relative "../mcp"
-
-# @deprecated Superseded by {Evilution::MCP::SessionTool} (action: "list") as of 0.22.8.
-#   No longer registered with the MCP server; retained only for direct Ruby callers.
-#   Will be removed entirely — tracked by EV-h8pw / GH #686.
-class Evilution::MCP::SessionListTool < MCP::Tool
-  tool_name "evilution-session-list"
-  description "DEPRECATED: use evilution-session with action: 'list'. " \
-              "List past mutation testing sessions with summary statistics. " \
-              "Returns sessions in reverse chronological order."
-  input_schema(
-    properties: {
-      results_dir: {
-        type: "string",
-        description: "Session results directory (default: .evilution/results)"
-      },
-      limit: {
-        type: "integer",
-        description: "Return only the N most recent sessions"
-      }
-    }
-  )
-
-  class << self
-    # rubocop:disable Lint/UnusedMethodArgument
-    def call(server_context:, results_dir: nil, limit: nil)
-      store_opts = {}
-      store_opts[:results_dir] = results_dir if results_dir
-      store = Evilution::Session::Store.new(**store_opts)
-      entries = store.list
-      entries = entries.first(limit) if limit
-
-      payload = entries.map { |e| stringify_keys(e) }
-      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }])
-    end
-    # rubocop:enable Lint/UnusedMethodArgument
-
-    private
-
-    def stringify_keys(hash)
-      hash.transform_keys(&:to_s)
-    end
-  end
-end

data/lib/evilution/mcp/session_show_tool.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "mcp"
-require_relative "../session/store"
-
-require_relative "../mcp"
-
-# @deprecated Superseded by {Evilution::MCP::SessionTool} (action: "show") as of 0.22.8.
-#   No longer registered with the MCP server; retained only for direct Ruby callers.
-#   Will be removed entirely — tracked by EV-h8pw / GH #686.
-class Evilution::MCP::SessionShowTool < MCP::Tool
-  tool_name "evilution-session-show"
-  description "DEPRECATED: use evilution-session with action: 'show'. " \
-              "Show full details of a past mutation testing session, " \
-              "including survived mutations with diffs."
-  input_schema(
-    properties: {
-      path: {
-        type: "string",
-        description: "Path to the session JSON file (as returned by evilution-session-list)"
-      }
-    }
-  )
-
-  class << self
-    # rubocop:disable Lint/UnusedMethodArgument
-    def call(server_context:, path: nil)
-      unless path
-        return ::MCP::Tool::Response.new(
-          [{ type: "text", text: ::JSON.generate({ error: { type: "config_error", message: "path is required" } }) }],
-          error: true
-        )
-      end
-
-      store = Evilution::Session::Store.new
-      data = store.load(path)
-      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(data) }])
-    rescue Evilution::Error => e
-      ::MCP::Tool::Response.new(
-        [{ type: "text", text: ::JSON.generate({ error: { type: "not_found", message: e.message } }) }],
-        error: true
-      )
-    rescue ::JSON::ParserError => e
-      ::MCP::Tool::Response.new(
-        [{ type: "text", text: ::JSON.generate({ error: { type: "parse_error", message: e.message } }) }],
-        error: true
-      )
-    rescue SystemCallError => e
-      ::MCP::Tool::Response.new(
-        [{ type: "text", text: ::JSON.generate({ error: { type: "runtime_error", message: e.message } }) }],
-        error: true
-      )
-    end
-    # rubocop:enable Lint/UnusedMethodArgument
-  end
-end