kimera 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c0b6544c638890d575523723b8d86dcac500e247c22a989fda9fa13b9f8d68b
-  data.tar.gz: 4b354333f7a2173a49932c9761f1731e034cd0a91df2a6534081412bd0598f92
+  metadata.gz: 558ffe918ec2624918506fb0616bd8426d8bb1a4c569abb4dd31e4ef9e74217d
+  data.tar.gz: 8ab25fa8b1f4c06085fb63606e20b1fb26691017d1bffc06c2d5dfa59b9e743c
 SHA512:
-  metadata.gz: 84b6ffd6aac361151843796089b6a4b85e1aa34aafdc8b9a78caf407ef18e774b72527235d4596649b08c52454d2a743e1e35d032240d7eaf6c577f6ad80a3d9
-  data.tar.gz: 0b1cd61f82643207a14f2fff230b46e05de8be433f8989a8e55df6e9e5e7af0198f55cd009d411a6beeeeedd5f4c68946d119ba1aa77326e27f12cb3406fe566
+  metadata.gz: 889e8498b185c70c2e933954c2343729bfa8292a9651bd3b9f583080e85f9e7c212c4590c9d23388c6415798e81eff89620a598701ce2de1854956f806873434
+  data.tar.gz: bdd9bfab7f3409e107e52921bf6f210f0c25cf56a58b3afa6ebd01485ef1ea806fc5165b7fa732abd19bc1ec3eb59545d6055960f38ba6062c934891bfc9fa72

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Changelog
 
+## 0.1.3 (2026-09-27)
+
+- `--isolated` no longer scores a child that crashes before reporting results
+  as a kill. It is `harness_error`, and its `detail` gives the exit status and
+  the ends of the child's stderr. A Minitest child that fails to load a test
+  file still reports that as a kill, as the RSpec child already did.
+- `--isolated` passes test ids and test files to the child in a request file
+  instead of argv, so a mutant covered by thousands of tests no longer fails
+  with `Errno::E2BIG: Argument list too long`.
+- Warm reload-path mutants (for example, statements in a memoized method) run
+  one test at a time and stop at the first failure. Tests covering the
+  mutant's method run first. The hard timeout now applies to each test, not
+  the whole suite, so a mutant a test kills is no longer reported as
+  "reload worker produced no result". A test that overruns the timeout is a
+  `timeout`, and a worker that dies names its exit status or signal.
+- A scope or association declared in a concern's `included do` block is now
+  instrumented in the classes that already included the concern. It used to be
+  reported `no_coverage`, or `survived` when it was covered through another
+  path.
+- An association overlaid on a parent model now also reaches subclasses that
+  declared associations of their own (such as STI children). They used to keep
+  the unguarded reflection, so mutants in the association's scope lambda
+  survived.
+- The red-baseline hint prints a plain Minitest command for a Minitest suite
+  instead of `rspec …`.
+- `kimera report`/`kimera mutant` and incremental sessions read report JSON as
+  UTF-8, so they no longer crash under a non-UTF-8 locale when a report
+  contains non-ASCII text.
+
+## 0.1.2 (2026-09-26)
+
+- Kimera sets `KIMERA=1` in its own process before loading the suite, and in
+  the `kimera doctor` test commands. A coverage floor gated on
+  `ENV["KIMERA"]` no longer fails a passing warm run with exit 2 or blocks
+  doctor's dry run. (#6)
+- A string interpolating a local bound by a pattern (`in [:ok, chosen]`,
+  `=> chosen`), a `&block` parameter, or a regexp named capture no longer
+  sinks its file's mutants. unparser 0.9 could not round-trip it; Kimera now
+  teaches unparser those bindings. (#7)
+- The per-method splice fallback now claims mutants in an endless method
+  (`def big? = value > 10`), and reopens `Data.define` / `Struct.new`
+  constants instead of redefining them, so spliced guards are reached. (#7)
+- Mutants Kimera could not instrument are reported as `unmutatable`, with the
+  reason, instead of `no_coverage`. They never gate and stay out of the score,
+  so `--fail-on-no-coverage` again means "no test executes this". (#7)
+- `kimera run --since` no longer crashes with "invalid byte sequence in
+  US-ASCII" when the locale isn't UTF-8 (e.g. `LANG` unset) and the diff
+  contains non-ASCII text. Git's diff output is read as UTF-8, with invalid
+  bytes replaced. (#9)
+
 ## 0.1.1 (2026-09-26)
 
 - Fix a boot crash on case-sensitive filesystems (Linux): `require "English"`

data/README.md

@@ -220,9 +220,13 @@ selector and Kimera's own harness-critical files (see below).
 
 An isolated child is judged on its failed tests, not its exit status. A child
 that exits non-zero with no failing test is `harness_error` (unjudged, gated
-by `--max-errors`), not a kill. The usual cause is a coverage floor such as
-SimpleCov's `minimum_coverage`, which a partial run always trips. Children run
-with `KIMERA=1` set, so skip the floor there:
+by `--max-errors`), not a kill. So is a child that dies before reporting any
+results (a boot error, an exit hook, a crash); its `detail` carries the
+child's exit status and the ends of its stderr. The usual cause of a non-zero
+exit with no failures is a coverage floor such as
+SimpleCov's `minimum_coverage`, which a partial run always trips. Kimera sets
+`KIMERA=1` wherever it loads your suite (the warm process, `--isolated`
+children, and `kimera doctor`'s test commands), so skip the floor there:
 
 ```ruby
 SimpleCov.start { minimum_coverage(line: 100, branch: 100) unless ENV["KIMERA"] }
@@ -504,8 +508,11 @@ source ──Prism──▶ registry (mutation points, JSON) ──┬─▶ syn
   baseline, or worse, as kills that are really collisions.
 - **Score definition.** `score = killed / evaluable`.
   - Killed includes timeouts and errors (observable misbehaviour).
-  - Evaluable excludes `no_coverage`, `ignored`, `isolated_only`, and
-    `harness_error` mutants. Each is reported separately.
+  - Evaluable excludes `no_coverage`, `ignored`, `isolated_only`,
+    `unmutatable`, and `harness_error` mutants. Each is reported separately.
+  - An `unmutatable` mutant is one Kimera could not instrument for the warm
+    run (its file or method failed to re-emit or load); the detail says why.
+    It never gates, and it is not `no_coverage`: a test may well run it.
   - A `harness_error` is a mutant Kimera could not judge: its worker died, or
     its reply was unreadable. It is not a kill. It gates via `--max-errors`
     (default 0). A pool that never produces a result aborts the run.

data/lib/kimera/cli/doctor.rb

@@ -96,8 +96,8 @@ class Kimera::CLI::Doctor
   end
 
   def floored(helper)
-    "Coverage floor: minimum_coverage in #{helper} fails partial --isolated runs; " \
-      "skip it when ENV[\"KIMERA\"] is set"
+    "Coverage floor: minimum_coverage in #{helper} fails Kimera's partial runs; " \
+      "skip it when ENV[\"KIMERA\"] is set (Kimera sets it)"
   end
 
   def floor?(path)

data/lib/kimera/cli/report_file.rb

@@ -13,7 +13,7 @@ module Kimera::CLI::ReportFile
   module_function
 
   def parse(path)
-    JSON.parse(File.read(path))
+    JSON.parse(File.read(path, encoding: Encoding::UTF_8))
   rescue JSON::ParserError => error
     raise(Kimera::UsageError, "unreadable report #{path}: #{error.message}")
   end

data/lib/kimera/cli/run/cycle.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../../execution/suite_env"
 require_relative "../../incremental/selection"
 require_relative "../../incremental/session"
 require_relative "digest"
@@ -71,7 +72,8 @@ class Kimera::CLI::Run::Cycle
       .transform_keys(&:to_s)
   end
 
-  def harness(remaining, loaded)
+  def harness(remaining, loaded, env: ENV)
+    env.update(Kimera::Execution::SUITE_ENV)
     adapter = Kimera::Frameworks::Adapter.load(@options[:framework])
     Kimera::CLI::Run::Pass.new(@registry, @options, adapter).call(remaining, loaded)
   end

data/lib/kimera/cli/survivors.rb

@@ -15,7 +15,7 @@ class Kimera::CLI::Survivors
       Kimera::Flag.build(
         "--status NAME", :status,
         "List a different status (survived, no_coverage, " \
-          "timeout, error, killed, isolated_only)"
+          "timeout, error, killed, isolated_only, unmutatable)"
       )
     ]
   )

data/lib/kimera/cli/test_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "open3"
+require_relative "../execution/suite_env"
 
 class Kimera::CLI::TestCommand
   LOADER = "ARGV.map { |f| File.expand_path(f) }.tap { ARGV.clear }.each { |f| require(f) }"
@@ -30,7 +31,7 @@ class Kimera::CLI::TestCommand
   end
 
   def check(command, passed)
-    output, status = Open3.capture2e(*command, chdir: @root)
+    output, status = Open3.capture2e(Kimera::Execution::SUITE_ENV, *command, chdir: @root)
     status.success? ? ["✓", passed] : yield(summary(output))
   rescue Errno::ENOENT
     yield(nil)

data/lib/kimera/execution/baseline_failure.rb

@@ -12,14 +12,14 @@ class Kimera::Execution::BaselineFailure < Kimera::Error
   MAX_MESSAGE = 300
 
   class << self
-    def build(failed, messages)
-      new(summary(failed, messages))
+    def build(failed, messages, command)
+      new(summary(failed, messages, command))
     end
 
-    def summary(failed, messages)
+    def summary(failed, messages, command)
       text = "baseline suite is not green: #{failed.join(", ")}"
       text += appendix(failed, messages)
-      "#{text}\n#{reproduce(failed)}"
+      "#{text}\n  reproduce without kimera: #{command}"
     end
 
     def appendix(failed, messages)
@@ -39,9 +39,5 @@ class Kimera::Execution::BaselineFailure < Kimera::Error
     def truncate(text)
       text.length > MAX_MESSAGE ? "#{text[0, MAX_MESSAGE]}…" : text
     end
-
-    def reproduce(failed)
-      "  reproduce without kimera: rspec #{failed.first(MAX_DETAILS).join(" ")} --order defined"
-    end
   end
 end

data/lib/kimera/execution/baseline_pass.rb

@@ -118,6 +118,7 @@ class Kimera::Execution::BaselinePass
   end
 
   def failure!(failed)
-    raise(Kimera::Execution::BaselineFailure.build(failed, @messages))
+    command = @adapter.reproduce(failed.first(Kimera::Execution::BaselineFailure::MAX_DETAILS))
+    raise(Kimera::Execution::BaselineFailure.build(failed, @messages, command))
   end
 end

data/lib/kimera/execution/isolated_child.rb

@@ -13,7 +13,8 @@ RSpec.configuration.output_stream = StringIO.new
 RSpec.configuration.error_stream = StringIO.new
 RSpec.configuration.deprecation_stream = StringIO.new
 
-ledger, *locations = ARGV
+ledger, request = ARGV
+locations = JSON.parse(File.read(request, encoding: Encoding::UTF_8)).fetch("tests")
 code = RSpec::Core::Runner.run(locations)
 
 failed = RSpec.world.all_examples.select { |example| example.execution_result.status == :failed }

data/lib/kimera/execution/isolated_child_command.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "json"
+require_relative "suite_env"
+
 module Kimera
   module Execution
   end
@@ -16,22 +19,26 @@ class Kimera::Execution::IsolatedPlan::ChildCommand
     @test_files = test_files
   end
 
-  ENV_FLAG = { "KIMERA" => "1" }.freeze
-
   def command(mirror, locations, ledger:, paths:)
+    File.write(request_path(ledger), JSON.generate(request(locations)))
     includes = paths.flat_map { |path| ["-I", path] }
-    bundled(mirror, ENV_FLAG.dup, ["ruby", *includes, "-I", helpers, *argv(locations, ledger)])
+    bundled(mirror, Kimera::Execution::SUITE_ENV.dup, ["ruby", *includes, "-I", helpers, *argv(ledger)])
   end
 
-  def argv(locations, ledger)
-    return [CHILD, ledger, *locations] unless minitest?
-    [MINITEST_CHILD, ledger, *@test_files, "--", *locations]
+  def argv(ledger)
+    [minitest? ? MINITEST_CHILD : CHILD, ledger, request_path(ledger)]
+  end
+
+  def request(locations)
+    { "tests" => locations, "files" => @test_files }
   end
 
   def helpers
     minitest? ? "test" : "spec"
   end
 
+  def request_path(ledger) = "#{ledger}.request"
+
   private
 
   def bundled(mirror, env, argv)

data/lib/kimera/execution/isolated_child_minitest.rb

@@ -12,13 +12,18 @@ rescue NameError, ArgumentError
   end
 end
 
-ledger, *rest = ARGV
-split = rest.index("--") or abort("usage: <ledger> <test files...> -- <ids...>")
-files = rest[0...split]
-ids = rest[(split + 1)..]
+ledger, request = ARGV
+request = JSON.parse(File.read(request, encoding: Encoding::UTF_8))
+files = request.fetch("files")
+ids = request.fetch("tests")
 ARGV.clear
 
-files.each { |f| require File.expand_path(f) }
+begin
+  files.each { |f| require File.expand_path(f) }
+rescue StandardError, ScriptError => error
+  File.write(ledger, JSON.generate(failures: 1, failing: [], load_error: "#{error.class}: #{error.message}"))
+  exit(1)
+end
 
 methods = {}
 Minitest::Runnable.runnables.each do |runnable|

data/lib/kimera/execution/isolated_outcome.rb

@@ -8,6 +8,9 @@ module Kimera
 end
 
 class Kimera::Execution::IsolatedOutcome
+  HEAD_LINES = 5
+  TAIL_LINES = 15
+
   attr_reader :status, :failing, :detail
 
   def initialize(status, failing = nil, detail = nil)
@@ -17,16 +20,33 @@ class Kimera::Execution::IsolatedOutcome
   end
 
   class << self
-    def judge(exit, path)
+    def judge(exit, path, stderr = "")
       return new(:timeout) if exit == :timeout
       ledger = read(path)
-      return unreported(exit) unless ledger
+      return unreported(exit, stderr) unless ledger
       tally(exit, ledger)
     end
 
     private
 
-    def unreported(exit) = new(exit.success? ? :survived : :killed)
+    def unreported(exit, stderr)
+      new(:harness_error, nil, "test child #{status_of(exit)} without reporting results#{tail(stderr)}")
+    end
+
+    def tail(stderr)
+      lines = stderr.to_s.strip.lines(chomp: true)
+      lines.empty? ? "" : ":\n#{ends(lines).join("\n")}"
+    end
+
+    def ends(lines)
+      return lines if lines.size <= HEAD_LINES + TAIL_LINES
+      [*lines.first(HEAD_LINES), "…", *lines.last(TAIL_LINES)]
+    end
+
+    def status_of(exit)
+      code = exit.exitstatus
+      code ? "exited #{code}" : "died on signal #{exit.termsig}"
+    end
 
     def tally(exit, ledger)
       failing = Array(ledger["failing"])
@@ -36,12 +56,12 @@ class Kimera::Execution::IsolatedOutcome
     end
 
     def unexplained(exit)
-      "suite exited #{exit.exitstatus || "on signal #{exit.termsig}"} with 0 failures " \
+      "suite #{status_of(exit)} with 0 failures " \
         "(a coverage floor or exit hook? skip it when ENV[\"KIMERA\"] is set)"
     end
 
     def read(path)
-      ledger = JSON.parse(File.read(path))
+      ledger = JSON.parse(File.read(path, encoding: Encoding::UTF_8))
       ledger if ledger.is_a?(Hash) && ledger["failures"].is_a?(Integer)
     rescue Errno::ENOENT, JSON::ParserError
       nil

data/lib/kimera/execution/isolated_verdict.rb

@@ -38,13 +38,16 @@ module Kimera
       def verdict(mirror, locations)
         Dir.mktmpdir("kimera-ledger") do |dir|
           ledger = File.join(dir, "ledger.json")
-          IsolatedOutcome.judge(launch(mirror, locations, ledger), ledger)
+          stderr = File.join(dir, "stderr.log")
+          IsolatedOutcome.judge(launch(mirror, locations, ledger, stderr), ledger, captured(stderr))
         end
       end
 
-      def launch(mirror, locations, ledger)
+      def captured(path) = File.read(path, encoding: Encoding::UTF_8).scrub
+
+      def launch(mirror, locations, ledger, stderr)
         env, cmd = plan.command(mirror, locations, ledger)
-        waitfor(Process.spawn(env, *cmd, chdir: mirror, pgroup: true, out: File::NULL, err: File::NULL))
+        waitfor(Process.spawn(env, *cmd, chdir: mirror, pgroup: true, out: File::NULL, err: stderr))
       end
 
       def with_mirror

data/lib/kimera/execution/kinship.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../registry/mutation_point"
+
+module Kimera
+  module Execution
+  end
+end
+
+class Kimera::Execution::Kinship
+  def initialize(registry, coverage)
+    @registry = registry
+    @coverage = coverage
+  end
+
+  def order(id, tests)
+    (related(@registry.index.fetch(id, Kimera::MutationPoint::NONE)) & tests) | tests
+  end
+
+  private
+
+  def related(point)
+    siblings = @registry.at(point.file).sort_by { |other| other.method_name == point.method_name ? 0 : 1 }
+    known = @coverage.to_h
+    siblings.flat_map { |other| other.ids.flat_map { |mutant| Array(known[mutant]) } }
+  end
+end

data/lib/kimera/execution/overlay_guard_modules.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "callback"
+require_relative "reflections"
 
 module Kimera
   module Execution
@@ -56,14 +57,30 @@ module Kimera
           define_method(hook) do |base = nil, &block|
             next super(base, &block) unless block && OverlayGuardModules.replacing?(self, stored, base)
             instance_variable_set(stored, block)
+            OverlayGuardModules.reapply(self, block)
           end
         end
       end
 
       def serialization = SERIALIZEGUARD
 
+      def reflection = Reflections::GUARD
+
+      MIXES = Module.instance_method(:include?)
+
       def concern = CONCERNGUARD
 
+      def reapply(concern, block)
+        ObjectSpace.each_object(Class).each { |klass| klass.class_eval(&block) if owner?(klass, concern) }
+      end
+
+      def owner?(klass, concern)
+        return false if klass.singleton_class? || !mixes?(klass, concern)
+        [klass.superclass].compact.none? { |parent| mixes?(parent, concern) }
+      end
+
+      def mixes?(klass, concern) = MIXES.bind_call(klass, concern)
+
       def replacing?(target, stored, base)
         Kimera::Execution::OverlayGuards.overlaying? && !base && target.instance_variable_defined?(stored)
       end

data/lib/kimera/execution/overlay_guards.rb

@@ -26,6 +26,7 @@ module Kimera
         callbacks!
         concern!
         serialize!
+        reflections!
       end
 
       def enum!
@@ -43,6 +44,11 @@ module Kimera
         ActiveRecord::Base.singleton_class.prepend(OverlayGuardModules.serialization)
       end
 
+      def reflections!
+        return unless defined?(ActiveRecord::Reflection)
+        ActiveRecord::Reflection.singleton_class.prepend(OverlayGuardModules.reflection)
+      end
+
       def concern!
         return unless defined?(ActiveSupport::Concern)
         ActiveSupport::Concern.prepend(OverlayGuardModules.concern)

data/lib/kimera/execution/reflections.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Execution
+    module Reflections
+      module_function
+
+      GUARD =
+        Module.new do
+          def add_reflection(owner, name, reflection)
+            key = Reflections.key(owner, name)
+            stale = OverlayGuards.overlaying? && owner._reflections[key]
+            super
+            Reflections.inherit(owner, key, stale, reflection) if stale
+          end
+        end
+
+      def key(owner, name)
+        text = name.to_s
+        owner._reflections.key?(text) ? text : name.to_sym
+      end
+
+      def inherit(owner, key, stale, reflection)
+        owner.descendants.each { |heir| replace(heir, key, stale, reflection) }
+      end
+
+      def replace(heir, key, stale, reflection)
+        held = heir._reflections
+        return unless held[key].equal?(stale)
+        heir.clear_reflections_cache
+        heir._reflections = held.merge(key => reflection)
+      end
+    end
+  end
+end

data/lib/kimera/execution/reload.rb

@@ -5,38 +5,16 @@ require_relative "../runtime"
 require_relative "../synthesis/overlay"
 require_relative "child_process"
 require_relative "overlay_guards"
+require_relative "reload_errand"
 require_relative "verdicts"
 
 class Kimera::Execution::Reload
+  include Kimera::Execution::ChildProcess
+
   Failure =
     Data.define(:exception) do
       def message = "#{exception.class}: #{exception.message}"
     end
-  include Kimera::Execution::ChildProcess
-
-  Errand =
-    Struct.new(:id, :reader, :writer) do
-      def parent!
-        writer.close
-      end
-
-      def child!
-        reader.close
-      end
-
-      def emit(payload)
-        writer.puts(payload)
-        writer.close
-      end
-
-      def await(deadline, &)
-        return reader.gets if reader.wait_readable(deadline)
-        yield
-        nil
-      ensure
-        reader.close
-      end
-    end
 
   def initialize(registry:, adapter:, isolation:, root:)
     @registry = registry
@@ -45,8 +23,8 @@ class Kimera::Execution::Reload
     @root = root
   end
 
-  def run(id, deadline:)
-    errand = Errand.new(id, *IO.pipe)
+  def run(id, deadline:, tests: @adapter.test_ids)
+    errand = Errand.new(id, tests, *IO.pipe)
     collect(errand, child(errand), deadline)
   end
 
@@ -59,32 +37,42 @@ class Kimera::Execution::Reload
   def work(errand)
     errand.child!
     silence!
-    errand.emit(report(errand.id))
+    errand.emit(report(errand))
     exit!(0)
   end
 
-  def report(id)
-    status, fails = evaluate(id)
-    JSON.generate(id: id, status: status.to_s, fails: fails)
+  def report(errand)
+    status, fails = evaluate(errand)
+    JSON.generate(id: errand.id, status: status.to_s, fails: Array(fails).map { |fail| fail.to_s.scrub })
   end
 
   def collect(errand, pid, deadline)
     line = errand.await(deadline) { kill(pid) }
-    reap(pid)
-    verdict(errand.id, line)
+    verdict(errand.id, line, reap(pid), deadline)
   end
 
-  def evaluate(id)
-    mutate(id).verdict
+  def evaluate(errand)
+    failed = mutate(errand)
+    failed ? failed.verdict : [:survived, []]
   rescue StandardError, ScriptError => error
     [:error, [Failure.new(error).message]]
   end
 
-  def mutate(id)
+  def mutate(errand)
+    id = errand.id
     file = verdicts.point(id).file
     overlay(file, File.join(File.expand_path(@root), file), id)
     Kimera::Runtime.active = nil
-    @isolation.around { @adapter.run(@adapter.test_ids) }
+    @isolation.around { hunt(errand) }
+  end
+
+  def hunt(errand)
+    errand.tests.lazy.map { |test| trial(test, errand) }.reject(&:passed?).first
+  end
+
+  def trial(test, errand)
+    errand.tick
+    @adapter.run([test])
   end
 
   def overlay(file, path, id)
@@ -92,12 +80,18 @@ class Kimera::Execution::Reload
     Kimera::Execution::OverlayGuards.overlay { Kimera::Overlay.evaluate(baked, path) }
   end
 
-  def verdict(id, line)
-    return verdicts.unjudged(id, "reload worker produced no result") unless line
+  def verdict(id, line, status = nil, deadline = nil)
+    return verdicts.timeout(id, deadline) if line == :timeout
+    return verdicts.unjudged(id, "reload worker produced no result#{exited(status)}") unless line
     message = parse(line)
     message ? verdicts.parse(message) : verdicts.unjudged(id, "reload worker output unparseable")
   end
 
+  def exited(status)
+    return "" unless status
+    status.signaled? ? " (died on signal #{status.termsig})" : " (exited #{status.exitstatus})"
+  end
+
   def verdicts
     Kimera::Execution::Verdicts.new(@registry)
   end

data/lib/kimera/execution/reload_errand.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Execution
+  end
+end
+
+class Kimera::Execution::Reload; end
+
+Kimera::Execution::Reload::Errand =
+  Struct.new(:id, :tests, :reader, :writer) do
+    tick = "tick\n"
+    def parent!
+      writer.close
+    end
+
+    def child!
+      reader.close
+      writer.sync = true
+    end
+    define_method(:tick) { writer.write(tick) }
+    def emit(payload)
+      writer.puts(payload)
+      writer.close
+    end
+
+    def await(deadline)
+      heard(deadline).tap { |line| yield if line == :timeout }
+    ensure
+      reader.close
+    end
+    define_method(:heard) do |deadline|
+      while reader.wait_readable(deadline)
+        line = reader.gets
+        return line unless line == tick
+      end
+      :timeout
+    end
+  end

data/lib/kimera/execution/schedule.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "priority"
+require_relative "kinship"
 require_relative "reload"
 require_relative "verdicts"
 
 class Kimera::Execution::Schedule
   Ledger = Struct.new(:results, :leaks)
-  Batch = Struct.new(:safe, :reloadable, :deferred, :ledger)
+  Batch = Struct.new(:safe, :reloadable, :deferred, :ledger, :coverage)
 
   LOSSES = { timeout: :expired }.freeze
 
@@ -37,14 +38,16 @@ class Kimera::Execution::Schedule
     safe, unsafe = ids.partition { |id| verdicts.safe?(id) }
     reloadable, deferred = unsafe.partition { |id| verdicts.reloadable?(id) }
     progress.start(safe.size + unsafe.size, label)
-    Batch.new(Kimera::Execution::Priority.new(coverage).order(safe), reloadable, deferred, Ledger.new({}, []))
+    Batch.new(prioritized(safe, coverage), reloadable, deferred, Ledger.new({}, []), coverage)
   end
 
+  def prioritized(safe, coverage) = Kimera::Execution::Priority.new(coverage).order(safe)
+
   def process(batch)
-    safe, reloadable, deferred, ledger = batch.to_a
-    pool(safe, ledger)
-    reload(reloadable, ledger)
-    defer(deferred, ledger)
+    ledger = batch.ledger
+    pool(batch.safe, ledger)
+    reload(batch)
+    defer(batch.deferred, ledger)
   end
 
   def finish(ledger)
@@ -58,8 +61,13 @@ class Kimera::Execution::Schedule
     progress.tick(result.status)
   end
 
-  def reload(ids, ledger)
-    ids.each { |id| record(ledger, id, reloader.run(id, deadline: hard)) }
+  def reload(batch)
+    kinship = Kimera::Execution::Kinship.new(@registry, batch.coverage)
+    batch.reloadable.each { |id| record(batch.ledger, id, rerun(id, kinship)) }
+  end
+
+  def rerun(id, kinship)
+    reloader.run(id, deadline: hard, tests: kinship.order(id, @options.fetch(:adapter).test_ids))
   end
 
   def defer(ids, ledger)
@@ -97,7 +105,7 @@ class Kimera::Execution::Schedule
   def crashed(id) = verdicts.unjudged(id, "worker crashed before result")
 
   def reloader
-    Kimera::Execution::Reload.new(
+    @_reloader ||= Kimera::Execution::Reload.new(
       registry: @registry, adapter: @options.fetch(:adapter),
       isolation: @options.fetch(:isolation), root: @options.fetch(:root)
     )

data/lib/kimera/execution/schemata.rb

@@ -39,7 +39,12 @@ class Kimera::Execution::Schemata
     @skipped.keys.select { |path| @skipped[path].start_with?("NameError:") }.each { |path| @skipped.delete(path) }
   end
 
-  def announce = @skipped.each { |path, reason| notice(path, reason) }
+  def announce
+    @skipped.each do |path, reason|
+      notice(path, reason)
+      @registry.at(path).select(&:safe?).each { |point| point.unmutatable!("schemata setup failed (#{reason})") }
+    end
+  end
 
   def load(path)
     file = File.join(root, path)
@@ -72,7 +77,7 @@ class Kimera::Execution::Schemata
   def notice(path, reason)
     errors.puts(
       "kimera: #{path} cannot run in warm workers — schemata setup failed " \
-        "(#{reason}); its mutants are reported no_coverage"
+        "(#{reason}); its mutants are reported unmutatable"
     )
   end
 

data/lib/kimera/execution/suite_env.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Execution
+    SUITE_ENV = { "KIMERA" => "1" }.freeze
+  end
+end

data/lib/kimera/execution/verdicts.rb

@@ -18,7 +18,7 @@ class Kimera::Execution::Verdicts
   end
 
   def reloadable?(id)
-    !point(id).body?
+    point(id).reloadable?
   end
 
   def reclassify!(results)
@@ -45,7 +45,9 @@ class Kimera::Execution::Verdicts
   end
 
   def quarantine(id)
-    Kimera::MutantResult.new(mutant_id: id, status: :isolated_only, file: path(id), detail: point(id).unsafe_reason)
+    found = point(id)
+    status = found.unmutatable? ? :unmutatable : :isolated_only
+    Kimera::MutantResult.new(mutant_id: id, status: status, file: found.file, detail: found.unsafe_reason)
   end
 
   def point(id)

data/lib/kimera/frameworks/adapter.rb

@@ -42,7 +42,11 @@ class Kimera::Frameworks::Adapter
     id
   end
 
-  @registry = {}
+  def reproduce(ids)
+    "rspec #{(ids & test_ids).join(" ")} --order defined"
+  end
+
+  @registry ||= {}
 
   NO_LOADER = -> {}
   ADAPTER_LOADERS = {

data/lib/kimera/frameworks/minitest_adapter.rb

@@ -51,8 +51,27 @@ class Kimera::Frameworks::MinitestAdapter < Kimera::Frameworks::Adapter
     Kimera::Frameworks::RunOutcome.new(passed: failed.empty?, failed_ids: failed, failures: failures)
   end
 
+  def reproduce(ids)
+    "bundle exec ruby -Itest -rminitest/autorun -e #{quote(loads(ids))} -- -n #{quote(filter(ids))} --seed 1"
+  end
+
   private
 
+  def loads(ids)
+    ids.filter_map { |id| origin(id) }.uniq.map { |file| "require File.expand_path(#{file.dump})" }.join("; ")
+  end
+
+  def filter(ids) = "/^(?:#{ids.map { |id| Regexp.escape(id) }.join("|")})$/"
+
+  def origin(id)
+    klass, name = @methods[id]
+    return unless klass
+    path, = klass.instance_method(name).source_location
+    path.delete_prefix("#{Dir.pwd}#{File::SEPARATOR}")
+  end
+
+  def quote(text) = "'#{text.gsub("'") { "'\\''" }}'"
+
   def record(id, failed, failures)
     klass, name = @methods[id]
     return unless klass

data/lib/kimera/incremental/git_diff.rb

@@ -27,12 +27,14 @@ class Kimera::Incremental::GitDiff
     def parse(text)
       files = {}
       current = nil
-      text.each_line { |line| current = advance(files, current, line) }
+      decoded(text).each_line { |line| current = advance(files, current, line) }
       files
     end
 
     private
 
+    def decoded(text) = text.dup.force_encoding(Encoding::UTF_8).scrub
+
     def advance(files, current, line)
       header = line.match(FILE_HEADER)
       return named(header) if header

data/lib/kimera/incremental/session.rb

@@ -24,7 +24,7 @@ class Kimera::Incremental::Session
   class << self
     def load(path, registry: nil)
       return new unless path && File.exist?(path)
-      session = decode(JSON.parse(File.read(path)))
+      session = decode(JSON.parse(File.read(path, encoding: Encoding::UTF_8)))
       session.prune!(registry) if registry
       session
     end

data/lib/kimera/registry/mutation_point.rb

@@ -17,7 +17,7 @@ module Kimera
       end
 
       def within?(from, to)
-        interior = ((from + 1)...to)
+        interior = ((from + 1)..to)
         interior.cover?(start_offset) && interior.cover?(finish)
       end
 
@@ -66,6 +66,7 @@ end
 
 class Kimera::MutationPoint
   CLASS_BODY_REASON = "class-body DSL (runs at load; evaluate with --isolated)"
+  UNMUTATABLE = "unmutatable: "
   SAFE = true
 
   FIELDS = %i[point_id file operator node_type location original_source method_name mutants unsafe_reason].freeze
@@ -98,6 +99,18 @@ class Kimera::MutationPoint
     unsafe_reason == CLASS_BODY_REASON
   end
 
+  def reloadable?
+    !body? && !unmutatable?
+  end
+
+  def unmutatable?
+    unsafe_reason.to_s.start_with?(UNMUTATABLE)
+  end
+
+  def unmutatable!(detail)
+    unsafe!("#{UNMUTATABLE}#{detail}")
+  end
+
   def safe
     @attributes.fetch(:schema_safe, SAFE)
   end

data/lib/kimera/results/result.rb

@@ -4,9 +4,10 @@ module Kimera
   module Status
     KILLING = %i[killed timeout error].freeze
 
-    UNJUDGED = %i[no_coverage ignored isolated_only harness_error].freeze
+    UNJUDGED = %i[no_coverage ignored isolated_only unmutatable harness_error].freeze
 
-    REPORTED = ([:survived] + (KILLING - [:killed]) + %i[no_coverage harness_error ignored isolated_only]).freeze
+    REPORTED =
+      ([:survived] + (KILLING - [:killed]) + %i[no_coverage harness_error ignored isolated_only unmutatable]).freeze
 
     SELF_SUSPECT = ((KILLING - [:killed]) + [:survived]).freeze
   end

data/lib/kimera/results/run_report.rb

@@ -10,7 +10,7 @@ end
 class Kimera::RunReport
   attr_reader :results, :leaks, :registry
 
-  CONDITIONAL = %i[harness_error ignored isolated_only leaks].freeze
+  CONDITIONAL = %i[harness_error ignored isolated_only unmutatable leaks].freeze
   LABELS = { total: "mutants", harness_error: "unjudged" }.freeze
   SCHEMA_VERSION = 1
 

data/lib/kimera/support/unparse.rb

@@ -11,5 +11,32 @@ module Kimera
     def parse(source) = Kimera::Warnings.silence { Unparser.parse(source) }
 
     def unparse(node) = Kimera::Warnings.silence { Unparser.unparse(node) }
+
+    module Binders
+      private
+
+      def enter(node)
+        super
+        Binders.names(node).each { |name| define(name) }
+      end
+
+      class << self
+        def names(node)
+          case node.type
+          when :match_var, :blockarg then [node.children.first].compact
+          when :match_with_lvasgn then captures(node.children.first)
+          else []
+          end
+        end
+
+        def captures(regexp)
+          *parts, options = regexp.children
+          flags = options.children.include?(:x) ? Regexp::EXTENDED : 0
+          Regexp.new(parts.sum("") { |part| part.children.first }, flags).names.map(&:to_sym)
+        end
+      end
+    end
   end
 end
+
+Unparser::AST::LocalVariableScopeEnumerator.prepend(Kimera::Unparse::Binders)

data/lib/kimera/support/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kimera
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/kimera/synthesis/file_weave.rb

@@ -6,6 +6,8 @@ require_relative "overlay_splice"
 class Kimera::Overlay::FileWeave
   include Kimera::OverlaySplice
 
+  UNGUARDABLE = "unparser could not round-trip its guard"
+
   def initialize(file, map, safe, unsafe)
     @file = file
     @map = map
@@ -43,16 +45,15 @@ class Kimera::Overlay::FileWeave
   def finish(viable)
     dropped = @safe - viable
     notice(dropped)
-    result = attempt(viable)
-    result.skipped_unsafe.concat(dropped.flat_map(&:ids))
-    result
+    dropped.each { |point| point.unmutatable!(UNGUARDABLE) }
+    attempt(viable).tap { |result| result.skipped_unsafe.concat(dropped.flat_map(&:ids)) }
   end
 
   def notice(dropped)
     io.puts(
       "kimera: #{@file}: #{dropped.size} mutation point(s) at " \
         "#{dropped.map { |p| "line #{p.location.start_line}" }.uniq.join(", ")} " \
-        "are unguardable (unparser round-trip); their mutants are reported no_coverage"
+        "are unguardable (unparser round-trip); their mutants are reported unmutatable"
     )
   end
 

data/lib/kimera/synthesis/overlay_splice.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "splice_reopening"
+
 module Kimera
   module OverlaySplice
     private
@@ -13,7 +15,7 @@ module Kimera
       return unless ready?
       edits, dropped = gather
       return if edits.empty?
-      source = apply(edits)
+      source = apply(edits + reopenings)
       [edits, dropped, source] if Kimera::Syntax.parse(source).success?
     end
 
@@ -24,6 +26,8 @@ module Kimera
       [edits, dropped + (@safe - claimed)]
     end
 
+    def reopenings = Kimera::SpliceReopening.new(@map).edits
+
     def collect(definition, points, edits, dropped)
       rewritten = rewrite(definition, points)
       rewritten ? edits << rewritten : dropped.concat(points)
@@ -32,6 +36,7 @@ module Kimera
     def report(edits, dropped, source)
       applied = edits.flat_map(&:last)
       announce(applied, dropped)
+      dropped.each { |point| point.unmutatable!("unparser could not round-trip its method") }
       build(applied, dropped, source)
     end
 
@@ -46,7 +51,7 @@ module Kimera
       io.puts(
         "kimera: #{@file}: file-level round-trip failed; " \
           "#{applied.size} mutant(s) spliced per method, " \
-          "#{dropped.flat_map(&:ids).size} reported no_coverage"
+          "#{dropped.flat_map(&:ids).size} reported unmutatable"
       )
     end
 

data/lib/kimera/synthesis/splice_reopening.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../rewrite/ast_walk"
+require_relative "guardrail_value_objects"
+
+class Kimera::SpliceReopening
+  FACTORIES = Kimera::GuardrailValueObjects::VALUE_OBJECT_FACTORIES
+  LEXICAL = "(is_a?(::Module) ? self : ::Object)"
+
+  Assignment =
+    Data.define(:scope, :name, :value, :location) do
+      def edit = [location.expression.begin_pos, value.location.begin.begin_pos, header, []]
+
+      def header
+        owner = base
+        "#{constant} = (#{owner}.const_defined?(:#{name}, false) ? #{owner}.const_get(:#{name}) : " \
+          "#{factory}); #{constant}.class_eval "
+      end
+
+      def constant = location.expression.begin.join(location.name).source
+
+      def factory = value.children.first.location.expression.source
+
+      def base
+        return LEXICAL unless scope
+        scope.type == :cbase ? "::Object" : scope.location.expression.source
+      end
+    end
+
+  def initialize(map)
+    @map = map
+  end
+
+  def edits = constants.map(&:edit)
+
+  private
+
+  def constants
+    found = []
+    Kimera::Rewrite::AstWalk.visit(@map.ast) { |node| found << assignment(node) if reopenable?(node) }
+    found
+  end
+
+  def assignment(node) = Assignment.new(*node, node.location)
+
+  def reopenable?(node)
+    return false unless node.type == :casgn
+    value = node.children.last
+    value.is_a?(Parser::AST::Node) && value.type == :block && factory?(value.children.first)
+  end
+
+  def factory?(call)
+    receiver, selector = call.children
+    call.type == :send && receiver.is_a?(Parser::AST::Node) && receiver.type == :const &&
+      FACTORIES[receiver.children.last] == selector
+  end
+end

data/skills/kimera/SKILL.md

@@ -72,7 +72,8 @@ bundle exec kimera run --isolated --jobs 4      # oracle mode (see Strengthen)
 - Rails `enum` models overlay warm (the re-declaration is idempotent), so
   their method-body mutants are judged like any other. A file labeled
   `unmutatable` could not be overlaid (a distinct, reported reason); it is not
-  an `--isolated` case.
+  an `--isolated` case. Its mutants report as `unmutatable` (never gating,
+  never scored, with the reason in the detail), not `no_coverage`.
 
 ## Triage a surviving mutant: the only four verdicts
 
@@ -118,9 +119,12 @@ bundle exec kimera run --isolated --jobs 4      # oracle mode (see Strengthen)
   suppress the warm path.
 - `--isolated` judges on failed tests, not the exit status. A child that
   exits non-zero with zero failures (typically a SimpleCov `minimum_coverage`
-  floor tripped by the partial run) is `harness_error`, not a kill. Children
-  run with `KIMERA=1`, so gate the floor on it (`minimum_coverage ... unless
-  ENV["KIMERA"]`); `kimera doctor` warns when it isn't.
+  floor tripped by the partial run) is `harness_error`, not a kill, and so is
+  a child that crashes before reporting (read its `detail` for the stderr).
+  Kimera
+  sets `KIMERA=1` wherever it loads the suite (warm, `--isolated`, doctor), so
+  gate the floor on it (`minimum_coverage ... unless ENV["KIMERA"]`); `kimera
+  doctor` warns when it isn't.
 - A cluster of `error`/`timeout` verdicts in one region usually means harness
   fragility or a missing guard, not test strength. Read the cluster before
   counting the detections.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kimera
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Giacomo GK
@@ -116,13 +116,16 @@ files:
 - lib/kimera/execution/isolated_verdict.rb
 - lib/kimera/execution/isolated_watchdog.rb
 - lib/kimera/execution/isolation.rb
+- lib/kimera/execution/kinship.rb
 - lib/kimera/execution/null_progress.rb
 - lib/kimera/execution/overlay_guard_modules.rb
 - lib/kimera/execution/overlay_guards.rb
 - lib/kimera/execution/parallel_test_databases.rb
 - lib/kimera/execution/pool_driver.rb
 - lib/kimera/execution/priority.rb
+- lib/kimera/execution/reflections.rb
 - lib/kimera/execution/reload.rb
+- lib/kimera/execution/reload_errand.rb
 - lib/kimera/execution/rig.rb
 - lib/kimera/execution/schedule.rb
 - lib/kimera/execution/schemata.rb
@@ -131,6 +134,7 @@ files:
 - lib/kimera/execution/shift/coverage_channel.rb
 - lib/kimera/execution/shift/killer_memory.rb
 - lib/kimera/execution/shift/leak_guard.rb
+- lib/kimera/execution/suite_env.rb
 - lib/kimera/execution/sweep.rb
 - lib/kimera/execution/transaction_isolation.rb
 - lib/kimera/execution/trial.rb
@@ -231,6 +235,7 @@ files:
 - lib/kimera/synthesis/overlay_splice.rb
 - lib/kimera/synthesis/project.rb
 - lib/kimera/synthesis/source_map.rb
+- lib/kimera/synthesis/splice_reopening.rb
 - lib/kimera/synthesis/superclass_pin.rb
 - lib/kimera/version.rb
 - skills/kimera/SKILL.md