kimera 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a60ca56321e6bfd3e82903b80f1ad75fc16e0647fff5f88be9042424643e3f0
-  data.tar.gz: d204852e218e3707f920e9ab5b1efb422395c971b2fa69aecb5a571ac28b7d73
+  metadata.gz: 3c0b6544c638890d575523723b8d86dcac500e247c22a989fda9fa13b9f8d68b
+  data.tar.gz: 4b354333f7a2173a49932c9761f1731e034cd0a91df2a6534081412bd0598f92
 SHA512:
-  metadata.gz: 63e971e4626da90289ad7b6f8a9483190820b6defa09f12d3e070639d3606fdde01cccaf73da24774de75b212764623747be187f3435b9e8cb7e4e50223e0d1f
-  data.tar.gz: be9614ecc3c6d9a89add30e5893a6ccbb5c934b0b06c5df518f19cd0483a9ade6eded8cfd15409c762cb147bf3f6c6803bf75607190e755977bdac0c2b2753a6
+  metadata.gz: 84b6ffd6aac361151843796089b6a4b85e1aa34aafdc8b9a78caf407ef18e774b72527235d4596649b08c52454d2a743e1e35d032240d7eaf6c577f6ad80a3d9
+  data.tar.gz: 0b1cd61f82643207a14f2fff230b46e05de8be433f8989a8e55df6e9e5e7af0198f55cd009d411a6beeeeedd5f4c68946d119ba1aa77326e27f12cb3406fe566

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.1.1 (2026-09-26)
+
+- Fix a boot crash on case-sensitive filesystems (Linux): `require "English"`
+  was spelled `require "english"`.
+- `--isolated` judges a mutant on failed tests, not the child's exit status.
+  A child that exits non-zero with zero failures (e.g. a SimpleCov
+  `minimum_coverage` floor tripped by the partial run) is now `harness_error`
+  instead of a false kill. Kills carry their failing tests. Children run with
+  `KIMERA=1`, and `kimera doctor` warns about an ungated coverage floor.
+- Skill: raising `max_ignored` is a judgment any triager may make when the
+  entry has earned it (isolated survival, a mechanism `reason:`, the raise in
+  the same diff), never a way to make a failing gate pass.
+
 ## 0.1.0 (2026-09-26)
 
 Initial public release.

data/README.md

@@ -218,6 +218,18 @@ process with the code under test. On ordinary code it reaches the same verdicts
 as the warm path. It can also test what the warm path can't: the runtime
 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:
+
+```ruby
+SimpleCov.start { minimum_coverage(line: 100, branch: 100) unless ENV["KIMERA"] }
+```
+
+`kimera doctor` warns when it finds an ungated `minimum_coverage`.
+
 ### Progress output
 
 During a run, a progress bar tracks each phase on stderr. It shows only when
@@ -260,7 +272,8 @@ fail_on_no_coverage: false
 
 # The gate fails when more than this many mutants are ignore-listed. Marking
 # one more mutant equivalent means raising this number in the same diff, so
-# the ignore list stays a reviewed decision, not a shortcut past a test.
+# the ignore list stays a justified decision, reviewed in the diff that makes
+# it, not a shortcut past a test.
 max_ignored: 1
 
 # Accepted pre-adoption survivors, merged with the ignore rules below.

data/lib/kimera/cli/doctor.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "open3"
 require_relative "../error"
 require_relative "../scope/config"
 require_relative "../scope/file_set"
 require_relative "flag"
+require_relative "test_command"
 
 class Kimera::CLI::Doctor
   OPTIONS = Kimera::FlagTable.new(
@@ -16,6 +16,8 @@ class Kimera::CLI::Doctor
 
   FRAMEWORK_FEATURES = { "rspec" => "rspec/core", "minitest" => "minitest" }.freeze
 
+  HELPERS = %w[.simplecov spec/spec_helper.rb spec/rails_helper.rb test/test_helper.rb].freeze
+
   def initialize(io: $stdout, errors: $stderr, root: ".")
     @io = io
     @errors = errors
@@ -38,7 +40,8 @@ class Kimera::CLI::Doctor
   end
 
   def checks(config, options)
-    all = [configuration(config), framework(config), sources(config), tests(config), git, rails]
+    all = [configuration(config), framework(config), sources(config), tests(config), loading(config), git, rails]
+    all.concat(floor)
     options[:check_baseline] ? all << baseline(config) : all
   end
 
@@ -76,7 +79,7 @@ class Kimera::CLI::Doctor
   def found(count, present, absent) = count.zero? ? ["✗", absent] : ["✓", present]
 
   def git
-    return ["✓", "Git: incremental runs are available"] if File.directory?(File.join(@root, ".git"))
+    return ["✓", "Git: incremental runs are available"] if File.exist?(File.join(@root, ".git"))
     ["!", "Git: not a repository; `kimera changed` is unavailable"]
   end
 
@@ -87,22 +90,28 @@ class Kimera::CLI::Doctor
 
   def rails? = File.file?(File.join(@root, "config", "application.rb"))
 
-  def baseline(config)
-    output, status = Open3.capture2e(*command(config), chdir: @root)
-    return ["✓", "Baseline: configured test suite is green"] if status.success?
-    ["✗", "Baseline: #{summary(output)} (fix it, then rerun `kimera doctor --check-baseline`)"]
-  rescue Errno::ENOENT
-    ["✗", "Baseline: Bundler is unavailable; run your test suite, then retry"]
+  def floor
+    helper = HELPERS.find { |path| floor?(File.join(@root, path)) }
+    helper ? [["!", floored(helper)]] : []
+  end
+
+  def floored(helper)
+    "Coverage floor: minimum_coverage in #{helper} fails partial --isolated runs; " \
+      "skip it when ENV[\"KIMERA\"] is set"
   end
 
-  def command(config)
-    files = test_files(config)
-    minitest?(config) ? ["bundle", "exec", "ruby", "-Itest", *files] : ["bundle", "exec", "rspec", *files]
+  def floor?(path)
+    return false unless File.file?(path)
+    source = File.read(path)
+    source.include?("minimum_coverage") && !source.include?("KIMERA")
   end
 
-  def summary(output)
-    output.lines.reverse.find { |line| line.match?(/\d+ failures?|\d+ examples?|failed/i) }&.strip ||
-      "test command failed"
+  def baseline(config) = test_command(config).baseline
+
+  def loading(config) = test_command(config).loading
+
+  def test_command(config)
+    Kimera::CLI::TestCommand.new(config.fetch(:framework, "rspec").to_s, test_files(config), root: @root)
   end
 
   def minitest?(config) = config.fetch(:framework, "rspec") == "minitest"

data/lib/kimera/cli/test_command.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "open3"
+
+class Kimera::CLI::TestCommand
+  LOADER = "ARGV.map { |f| File.expand_path(f) }.tap { ARGV.clear }.each { |f| require(f) }"
+  DRY_RUN = "require 'minitest'; Minitest.class_variable_set(:@@installed_at_exit, true); #{LOADER}; exit!(0)".freeze
+
+  def initialize(framework, files, root:)
+    @framework = framework
+    @files = files
+    @root = root
+  end
+
+  def baseline
+    check(run, "Baseline: configured test suite is green") { |failure| ["✗", "Baseline: #{advice(failure)}"] }
+  end
+
+  def loading
+    check(dry_run, "Test loading: every test file loads") do |failure|
+      failure ? ["✗", "Test loading: #{failure}"] : ["!", "Test loading: Bundler is unavailable; not checked"]
+    end
+  end
+
+  private
+
+  def advice(failure)
+    return "Bundler is unavailable; run your test suite, then retry" unless failure
+    "#{failure} (fix it, then rerun `kimera doctor --check-baseline`)"
+  end
+
+  def check(command, passed)
+    output, status = Open3.capture2e(*command, chdir: @root)
+    status.success? ? ["✓", passed] : yield(summary(output))
+  rescue Errno::ENOENT
+    yield(nil)
+  end
+
+  def run = minitest? ? ruby(LOADER) : rspec
+
+  def dry_run = minitest? ? ruby(DRY_RUN) : rspec("--dry-run")
+
+  def summary(output)
+    output.lines.reverse.find { |line| line.match?(/\d+ failures?|\d+ examples?|failed|Error\b/i) }&.strip ||
+      "test command failed"
+  end
+
+  def ruby(script) = ["bundle", "exec", "ruby", "-Itest", "-e", script, *@files]
+
+  def rspec(*flags) = ["bundle", "exec", "rspec", *flags, *@files]
+
+  def minitest? = @framework == "minitest"
+end

data/lib/kimera/execution/child_process.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "english"
+require "English"
 require "json"
 
 module Kimera

data/lib/kimera/execution/harness.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "english"
+require "English"
 require "json"
 require_relative "../error"
 require_relative "../results/result"

data/lib/kimera/execution/isolated_child.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require "rspec/core"
 require "stringio"
 
@@ -12,4 +13,11 @@ RSpec.configuration.output_stream = StringIO.new
 RSpec.configuration.error_stream = StringIO.new
 RSpec.configuration.deprecation_stream = StringIO.new
 
-exit RSpec::Core::Runner.run(ARGV)
+ledger, *locations = ARGV
+code = RSpec::Core::Runner.run(locations)
+
+failed = RSpec.world.all_examples.select { |example| example.execution_result.status == :failed }
+outside = RSpec.world.non_example_failure ? 1 : 0
+File.write(ledger, JSON.generate(failures: failed.size + outside, failing: failed.map(&:id)))
+
+exit code

data/lib/kimera/execution/isolated_child_command.rb

@@ -16,13 +16,16 @@ class Kimera::Execution::IsolatedPlan::ChildCommand
     @test_files = test_files
   end
 
-  def command(mirror, locations, paths:)
-    bundled(mirror, {}, ["ruby", *paths.flat_map { |path| ["-I", path] }, "-I", helpers, *argv(locations)])
+  ENV_FLAG = { "KIMERA" => "1" }.freeze
+
+  def command(mirror, locations, ledger:, paths:)
+    includes = paths.flat_map { |path| ["-I", path] }
+    bundled(mirror, ENV_FLAG.dup, ["ruby", *includes, "-I", helpers, *argv(locations, ledger)])
   end
 
-  def argv(locations)
-    return [CHILD, *locations] unless minitest?
-    [MINITEST_CHILD, *@test_files, "--", *locations]
+  def argv(locations, ledger)
+    return [CHILD, ledger, *locations] unless minitest?
+    [MINITEST_CHILD, ledger, *@test_files, "--", *locations]
   end
 
   def helpers

data/lib/kimera/execution/isolated_child_minitest.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require "minitest"
 
 Minitest.seed ||= 1
@@ -11,11 +12,13 @@ rescue NameError, ArgumentError
   end
 end
 
-split = ARGV.index("--") or abort("usage: <test files...> -- <ids...>")
-files = ARGV[0...split]
-ids = ARGV[(split + 1)..]
+ledger, *rest = ARGV
+split = rest.index("--") or abort("usage: <ledger> <test files...> -- <ids...>")
+files = rest[0...split]
+ids = rest[(split + 1)..]
+ARGV.clear
 
-files.each { |f| load File.expand_path(f) }
+files.each { |f| require File.expand_path(f) }
 
 methods = {}
 Minitest::Runnable.runnables.each do |runnable|
@@ -23,12 +26,14 @@ Minitest::Runnable.runnables.each do |runnable|
   runnable.runnable_methods.each { |name| methods["#{runnable}##{name}"] = [runnable, name] }
 end
 
-killed =
-  ids.any? do |id|
+killer =
+  ids.find do |id|
     klass, name = methods[id]
     next false unless klass
     result = klass.new(name).run
     !result.passed? && !result.skipped?
   end
 
-exit(killed ? 1 : 0)
+File.write(ledger, JSON.generate(failures: killer ? 1 : 0, failing: [killer].compact))
+
+exit(killer ? 1 : 0)

data/lib/kimera/execution/isolated_outcome.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Kimera
+  module Execution
+  end
+end
+
+class Kimera::Execution::IsolatedOutcome
+  attr_reader :status, :failing, :detail
+
+  def initialize(status, failing = nil, detail = nil)
+    @status = status
+    @failing = failing
+    @detail = detail
+  end
+
+  class << self
+    def judge(exit, path)
+      return new(:timeout) if exit == :timeout
+      ledger = read(path)
+      return unreported(exit) unless ledger
+      tally(exit, ledger)
+    end
+
+    private
+
+    def unreported(exit) = new(exit.success? ? :survived : :killed)
+
+    def tally(exit, ledger)
+      failing = Array(ledger["failing"])
+      return new(:killed, failing) if ledger["failures"].positive?
+      return new(:survived) if exit.success?
+      new(:harness_error, nil, unexplained(exit))
+    end
+
+    def unexplained(exit)
+      "suite exited #{exit.exitstatus || "on signal #{exit.termsig}"} 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 if ledger.is_a?(Hash) && ledger["failures"].is_a?(Integer)
+    rescue Errno::ENOENT, JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/kimera/execution/isolated_plan.rb

@@ -30,8 +30,8 @@ class Kimera::Execution::IsolatedPlan
     selection.recorded(id)
   end
 
-  def command(mirror, locations)
-    child.command(mirror, locations, paths: mutables)
+  def command(mirror, locations, ledger)
+    child.command(mirror, locations, ledger: ledger, paths: mutables)
   end
 
   def mutables

data/lib/kimera/execution/isolated_verdict.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "isolated_outcome"
+
 module Kimera
   module Execution
     module IsolatedExecutionVerdict
@@ -17,8 +19,8 @@ module Kimera
         trial.file = point.file
         tests = plan.tests(trial.id, point)
         return result(trial, :no_coverage, nil) unless tests
-        status, duration = measure(trial, tests)
-        result(trial, status, duration, tests)
+        outcome, duration = measure(trial, tests)
+        result(trial, outcome.status, duration, tests, failing_tests: outcome.failing, detail: outcome.detail)
       end
 
       def measure(trial, tests)
@@ -34,10 +36,15 @@ module Kimera
       end
 
       def verdict(mirror, locations)
-        env, cmd = plan.command(mirror, locations)
-        status = waitfor(Process.spawn(env, *cmd, chdir: mirror, pgroup: true, out: File::NULL, err: File::NULL))
-        return :timeout if status == :timeout
-        status.success? ? :survived : :killed
+        Dir.mktmpdir("kimera-ledger") do |dir|
+          ledger = File.join(dir, "ledger.json")
+          IsolatedOutcome.judge(launch(mirror, locations, ledger), ledger)
+        end
+      end
+
+      def launch(mirror, locations, ledger)
+        env, cmd = plan.command(mirror, locations, ledger)
+        waitfor(Process.spawn(env, *cmd, chdir: mirror, pgroup: true, out: File::NULL, err: File::NULL))
       end
 
       def with_mirror
@@ -54,9 +61,9 @@ module Kimera
         end
       end
 
-      def result(trial, status, duration, cover = nil)
+      def result(trial, status, duration, cover = nil, **outcome)
         MutantResult.new(
-          mutant_id: trial.id, status: status, file: trial.file, duration: duration, covering_tests: cover
+          mutant_id: trial.id, status: status, file: trial.file, duration: duration, covering_tests: cover, **outcome
         )
       end
 

data/lib/kimera/execution/parallel_test_databases.rb

@@ -34,9 +34,16 @@ class Kimera::Execution::ParallelTestDatabases
 
   def cleanup
     return unless active?
+    scrub
     ActiveSupport::Testing::Parallelization.run_cleanup_hooks.each(&:call)
   end
 
+  def scrub
+    return unless defined?(ActiveRecord::Base)
+    connection = ActiveRecord::Base.connection
+    connection.truncate_tables(*connection.tables)
+  end
+
   def errors = @errors || $stderr
 
   def eligible?

data/lib/kimera/execution/schemata.rb

@@ -27,11 +27,20 @@ class Kimera::Execution::Schemata
 
   def overlay!
     Kimera::Execution::OverlayGuards.install!
-    @registry.files.flat_map { |path| load(path) }
+    loaded = weave(@registry.files)
+    (loaded + weave(unresolved)).tap { announce }
   end
 
   private
 
+  def weave(paths) = paths.flat_map { |path| load(path) }
+
+  def unresolved
+    @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 load(path)
     file = File.join(root, path)
     return [] unless File.file?(file)
@@ -44,7 +53,7 @@ class Kimera::Execution::Schemata
     return [] if result.mutant_ids.empty?
     apply(result, file)
   rescue StandardError, ScriptError, SystemExit => error
-    skip(path, error)
+    skip(path, "#{error.class}: #{error.message}")
   end
 
   def synthesize(path, file)
@@ -55,10 +64,8 @@ class Kimera::Execution::Schemata
     silence { result.install(file) }
   end
 
-  def skip(path, error)
-    reason = "#{error.class}: #{error.message}"
+  def skip(path, reason)
     @skipped[path] = reason
-    notice(path, reason)
     []
   end
 

data/lib/kimera/frameworks/adapter.rb

@@ -79,4 +79,17 @@ class Kimera::Frameworks::Adapter
       end
     end
   end
+
+  private
+
+  def each_test_file(files, &)
+    ARGV.clear
+    Array(files).each { |file| load_test_file(file, &) }
+  end
+
+  def load_test_file(file)
+    yield(File.expand_path(file))
+  rescue StandardError, ScriptError => error
+    raise(Kimera::Error, "cannot load test file #{file} (#{error.class}: #{error.message})")
+  end
 end

data/lib/kimera/frameworks/minitest_adapter.rb

@@ -35,7 +35,7 @@ class Kimera::Frameworks::MinitestAdapter < Kimera::Frameworks::Adapter
 
   def source(files)
     paths(files)
-    Array(files).each { |f| load(File.expand_path(f)) }
+    each_test_file(files) { |file| require(file) }
     reindex
     self
   end

data/lib/kimera/frameworks/rspec_adapter.rb

@@ -32,7 +32,7 @@ class Kimera::Frameworks::RSpecAdapter < Kimera::Frameworks::Adapter
   end
 
   def source(files)
-    Array(files).each { |file| load(file) }
+    each_test_file(files) { |file| load(file) }
     reindex
     self
   end

data/lib/kimera/report/actions.rb

@@ -11,28 +11,42 @@ class Kimera::Report::Actions
   end
 
   def show(report, path: nil)
-    lines = [survivors(report.survived, path), uncovered(report.uncovered, path), unjudged(report.errors)].compact
+    hints = path ? SavedHints.new(path) : UnsavedHints.new
+    lines = [
+      advice(report.survived, hints, :survivors), advice(report.uncovered, hints, :uncovered),
+      advice(report.errors, hints, :unjudged)
+    ].compact
     @io.puts("", "Next actions:", *lines) unless lines.empty?
   end
 
   private
 
-  def survivors(found, path)
+  def advice(found, hints, kind)
     first = found.min_by(&:mutant_id)
-    first && advice(found, "surviving mutant(s): inspect ##{first.mutant_id} with `#{inspection(first, path)}`")
+    "  #{found.size} #{hints.public_send(kind, first.mutant_id)}" if first
   end
 
-  def inspection(first, path)
-    path ? "kimera mutant #{first.mutant_id} --report #{path}" : "kimera run --report tmp/kimera.json"
-  end
+  class SavedHints
+    def initialize(path)
+      @path = path
+    end
+
+    def survivors(id) = "surviving mutant(s): inspect ##{id} with `#{mutant(id)}`"
+
+    def uncovered(_id) = "uncovered mutant(s): kimera report #{@path} --status no_coverage"
 
-  def uncovered(found, path) = advice(found, "uncovered mutant(s): #{listing(path)}")
+    def unjudged(id) = "unjudged mutant(s): see why with `#{mutant(id)}`"
+
+    private
+
+    def mutant(id) = "kimera mutant #{id} --report #{@path}"
+  end
 
-  def listing(path) = path ? "kimera report #{path} --status no_coverage" : "rerun with --report tmp/kimera.json"
+  class UnsavedHints
+    def survivors(id) = "surviving mutant(s): inspect ##{id} with `kimera run --report tmp/kimera.json`"
 
-  def unjudged(found) = advice(found, "unjudged mutant(s): retry with `kimera run --isolated`")
+    def uncovered(_id) = "uncovered mutant(s): rerun with --report tmp/kimera.json"
 
-  def advice(found, text)
-    "  #{found.size} #{text}" unless found.empty?
+    def unjudged(_id) = "unjudged mutant(s): retry with `kimera run --isolated`"
   end
 end

data/lib/kimera/report/sections.rb

@@ -45,6 +45,6 @@ module Kimera::Report::Sections
     return if leaks.empty?
     @io.puts
     @io.puts(yellow("State-leak warnings (#{leaks.size}):"))
-    leaks.each { |leak| @io.puts("  - #{leak.detail}") }
+    leaks.each { |leak| @io.puts("  - ##{leak.mutant_id}  #{leak.detail}") }
   end
 end

data/lib/kimera/support/version.rb

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

data/lib/kimera/synthesis/overlay.rb

@@ -8,6 +8,7 @@ require_relative "../error"
 require_relative "../registry/registry"
 require_relative "guard_weaver"
 require_relative "source_map"
+require_relative "superclass_pin"
 
 class Kimera::Overlay
   Result =
@@ -24,7 +25,7 @@ class Kimera::Overlay
 
   class << self
     def evaluate(source, path)
-      Kimera::Warnings.silence { TOPLEVEL_BINDING.eval(source, path) }
+      Kimera::Warnings.silence { TOPLEVEL_BINDING.eval(Kimera::SuperclassPin.pin(source), path) }
     end
   end
 

data/lib/kimera/synthesis/overlay_splice.rb

@@ -20,8 +20,8 @@ module Kimera
     def gather
       edits = []
       dropped = []
-      each { |definition, points| collect(definition, points, edits, dropped) }
-      [edits, dropped]
+      claimed = each { |definition, points| collect(definition, points, edits, dropped) }
+      [edits, dropped + (@safe - claimed)]
     end
 
     def collect(definition, points, edits, dropped)
@@ -60,6 +60,7 @@ module Kimera
     def each(&)
       claimed = []
       definitions.each { |definition| visit(definition, claimed, &) }
+      claimed
     end
 
     def visit(definition, claimed)

data/lib/kimera/synthesis/superclass_pin.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Kimera
+  module SuperclassPin
+    module_function
+
+    def pin(source)
+      classes(Prism.parse(source).value).reverse_each.with_object(source.b) do |node, text|
+        location = node.superclass.location
+        text[location.start_offset, location.length] = reopened(node)
+      end.force_encoding(source.encoding)
+    end
+
+    def existing(scope, name)
+      owner = scope.is_a?(Module) ? scope : Object
+      inherit = false
+      owner.const_defined?(name, inherit) && owner.const_get(name, inherit).superclass
+    end
+
+    def reopened(node)
+      "(::Kimera::SuperclassPin.existing(self, :#{node.constant_path.name}) || #{node.superclass.slice})".b
+    end
+
+    def classes(node, found = [])
+      found << node if dynamic?(node)
+      node.compact_child_nodes.each { |child| classes(child, found) }
+      found
+    end
+
+    def dynamic?(node)
+      return false unless node.is_a?(Prism::ClassNode) && node.constant_path.is_a?(Prism::ConstantReadNode)
+      superclass = node.superclass
+      superclass && !constant?(superclass)
+    end
+
+    def constant?(node) = node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+  end
+end

data/skills/kimera/SKILL.md

@@ -91,13 +91,19 @@ bundle exec kimera run --isolated --jobs 4      # oracle mode (see Strengthen)
 
 ## Ignore discipline: hard rules (especially for agents)
 
-- **Never raise `max_ignored` to make a gate pass.** Raising the budget is a
-  human decision. Surface the failing gate and the candidate entry instead.
+- **Raise `max_ignored` only for an entry that has earned it**: survival
+  under `--isolated`, a `reason:` naming the mechanism, and the raise in the
+  same diff as the entry. Any triager, human or agent, may make that call when
+  all three hold. Never raise it to make a failing gate pass; that is skipping
+  triage, not finishing it.
+- If any criterion is missing (no oracle run, a reason that restates the
+  verdict, a mutant you haven't read), write the test or leave the survivor
+  visible.
 - An ignore entry without an isolated-oracle survival check is inadmissible.
   Warm-path survivors can be measurement artifacts (kimera's own suite once
   had a "clearly equivalent" mutant that 11 specs actually kill).
-- A budget raise goes in the same diff as the entry it admits. Reviewers
-  judge the `reason:`, not the number.
+- Reviewers judge the `reason:`, not the number, so the entry and the raise
+  land together.
 
 ## Strengthen
 
@@ -110,6 +116,11 @@ bundle exec kimera run --isolated --jobs 4      # oracle mode (see Strengthen)
   runner, global state the suite also touches, kimera's own plumbing):
   adjudicate with `--isolated`. Suites that manipulate shared globals can
   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.
 - 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.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Giacomo GK
@@ -95,6 +95,7 @@ files:
 - lib/kimera/cli/survivors.rb
 - lib/kimera/cli/survivors/panel.rb
 - lib/kimera/cli/synthesize.rb
+- lib/kimera/cli/test_command.rb
 - lib/kimera/cli/workflows.rb
 - lib/kimera/error.rb
 - lib/kimera/execution/baseline_failure.rb
@@ -108,6 +109,7 @@ files:
 - lib/kimera/execution/isolated_child.rb
 - lib/kimera/execution/isolated_child_command.rb
 - lib/kimera/execution/isolated_child_minitest.rb
+- lib/kimera/execution/isolated_outcome.rb
 - lib/kimera/execution/isolated_plan.rb
 - lib/kimera/execution/isolated_scheduling.rb
 - lib/kimera/execution/isolated_test_selection.rb
@@ -229,6 +231,7 @@ files:
 - lib/kimera/synthesis/overlay_splice.rb
 - lib/kimera/synthesis/project.rb
 - lib/kimera/synthesis/source_map.rb
+- lib/kimera/synthesis/superclass_pin.rb
 - lib/kimera/version.rb
 - skills/kimera/SKILL.md
 homepage: https://github.com/giacope/kimera