henitai 0.5.3 → 0.6.0

data/lib/henitai/result.rb

@@ -26,9 +26,8 @@ module Henitai
       process_abort: true
     }.freeze
 
-    # Maps each criterion to the mutant status it governs. process_abort has no
-    # producer in lib/ yet -- nothing classifies a mutant as :runtime_error --
-    # so that entry is forward-looking wiring rather than a live code path.
+    # Maps each criterion to the mutant status it governs. MutantVerdict emits
+    # :runtime_error for process aborts, signals, and unknown child outcomes.
     CRITERION_STATUSES = {
       test_result: :killed,
       timeout: :timeout,
@@ -36,7 +35,7 @@ module Henitai
     }.freeze
 
     attr_reader :mutants, :started_at, :finished_at, :thresholds, :survivor_stats,
-                :session_id, :git_sha, :since, :coverage_criteria
+                :session_id, :git_sha, :since, :coverage_criteria, :complete_files, :sampling
 
     # @param source_provider [#call] maps a file path to its source string.
     #   Injected so the domain object performs no disk IO; the caller (which
@@ -48,12 +47,16 @@ module Henitai
     #   canonical report; non-authoritative (subject-scoped, --since,
     #   --survivors-from) runs are merged into it instead — see
     #   CanonicalReportMerger.
+    # @param complete_files [Array<String>, nil] source files this run mutated
+    #   completely (every subject). The merger replaces a prior report's entry
+    #   for such a file wholesale instead of merging by stableId, so stale
+    #   mutants of changed or deleted code do not linger.
     # rubocop:disable Metrics/ParameterLists
     def initialize(mutants:, started_at:, finished_at:, thresholds: nil,
                    partial_rerun: false, survivor_stats: nil,
                    session_id: SecureRandom.uuid, git_sha: nil,
                    source_provider: ->(_file) { "" }, authoritative: true,
-                   since: nil, coverage_criteria: nil)
+                   since: nil, coverage_criteria: nil, complete_files: nil, sampling: nil)
       @mutants         = mutants
       @started_at      = started_at
       @finished_at     = finished_at
@@ -65,7 +68,9 @@ module Henitai
       @source_provider = source_provider
       @authoritative   = authoritative
       @since           = since
+      @complete_files = Array(complete_files)
       @coverage_criteria = DEFAULT_COVERAGE_CRITERIA.merge(coverage_criteria || {})
+      @sampling = sampling
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -89,11 +94,12 @@ module Henitai
 
     # Mutation Score (MS) — Architektur-Formel aus Abschnitt 6.1:
     #
-    #   MS = detected / (total − ignored − no_coverage − compile_error − equivalent)
+    #   MS = detected / (total − ignored − no_coverage − compile_error − equivalent − pending)
     #
     # Confirmed equivalent mutants werden aus BEIDEN Seiten der Gleichung entfernt:
     # Sie sind weder im Zähler (nicht detektierbar) noch im Nenner (nicht testbar).
-    # Das ist der entscheidende Unterschied zum MSI.
+    # Das ist der entscheidende Unterschied zum MSI. Pending mutants (left over from
+    # an interrupted run, without a verdict) are excluded from both sides as well.
     #
     # @return [Float, nil] 0.0–100.0, nil wenn kein valider Mutant vorhanden
     def mutation_score
@@ -102,8 +108,9 @@ module Henitai
 
     # Mutation Score Indicator (MSI) — naive Berechnung ohne Äquivalenz-Bereinigung:
     #
-    #   MSI = killed / all_mutants
+    #   MSI = killed / (total − pending)
     #
+    # Only mutants with a verdict count; pending mutants have none.
     # MSI ist immer ≤ MS. Der Unterschied kommuniziert die Äquivalenz-Unsicherheit.
     # Beide Werte MÜSSEN im Report zusammen ausgewiesen werden (Anti-Pattern: nur MS).
     #
@@ -151,6 +158,8 @@ module Henitai
       schema = base_schema
       sha = @git_sha
       schema[:gitSha] = sha if sha
+      schema[:completeFiles] = complete_files if complete_files.any? && !authoritative?
+      schema[:sampling] = @sampling if @sampling
       return schema unless partial_rerun?
 
       schema[:partialRerun] = true
@@ -171,7 +180,7 @@ module Henitai
     end
 
     def mutation_score_for(list)
-      excluded = %i[ignored no_coverage compile_error equivalent]
+      excluded = %i[ignored no_coverage compile_error equivalent pending]
       valid = list.reject { |m| excluded.include?(m.status) }
       return nil if valid.empty?
 
@@ -179,9 +188,10 @@ module Henitai
     end
 
     def mutation_score_indicator_for(list)
-      return nil if list.empty?
+      decided = list.reject { |m| m.status == :pending }
+      return nil if decided.empty?
 
-      ((list.count(&:killed?).to_f / list.count) * 100.0).round(2).to_f
+      ((decided.count(&:killed?).to_f / decided.count) * 100.0).round(2).to_f
     end
 
     def base_schema
@@ -205,10 +215,16 @@ module Henitai
           language: "ruby",
           source: @source_provider.call(file_mutants.first.location[:file]),
           mutants: file_mutants.map { |m| mutant_to_schema(m) }
-        }
+        }.merge(file_provenance)
       end
     end
 
+    # Vendor fields: which run produced this file entry. Kept per file so a
+    # merged report can tell which session snapshot holds its mutants.
+    def file_provenance
+      { sessionId: @session_id, gitSha: @git_sha }.compact
+    end
+
     def mutant_to_schema(mutant)
       {
         id: mutant.id,
@@ -261,11 +277,11 @@ module Henitai
     end
 
     # Serialized as the schema's statusReason so directive reasons show up
-    # next to the Ignored status in the HTML report.
+    # next to the Ignored status, and harness reasons (a failed fidelity
+    # check, for example) next to CompileError, in the HTML report.
     def status_reason_for(mutant)
-      return nil unless mutant.respond_to?(:ignore_reason)
-
-      mutant.ignore_reason
+      reason = mutant.status_reason if mutant.respond_to?(:status_reason)
+      reason || (mutant.ignore_reason if mutant.respond_to?(:ignore_reason))
     end
 
     # Vendored extension field (like stableId): marks verdicts reused from

data/lib/henitai/reuse_context.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+require_relative "verdict_fingerprint"
+
+module Henitai
+  # Run-level fingerprint of everything outside a mutant and its covering
+  # tests that can change a verdict: the test dependency files, the
+  # verdict-relevant configuration and the henitai version. Recorded with every
+  # cached Killed/Survived verdict and required to match for reuse.
+  #
+  # Computed once per instance, so the filter that reads verdicts and the
+  # history store that writes them always agree. nil when the dependency files
+  # cannot be read — nothing is then reusable.
+  class ReuseContext
+    def initialize(config:, version: Henitai::VERSION, root: Dir.pwd)
+      @config = config
+      @version = version
+      @root = root
+    end
+
+    def fingerprint
+      return @fingerprint if defined?(@fingerprint)
+
+      @fingerprint = compute
+    end
+
+    private
+
+    def compute
+      dependencies = VerdictFingerprint.dependency_fingerprint(@root)
+      return nil unless dependencies
+
+      Digest::SHA256.hexdigest(JSON.generate(components(dependencies)))
+    end
+
+    def components(dependencies)
+      {
+        "dependencies" => dependencies,
+        "version" => @version,
+        "integration" => @config.integration.to_s,
+        "operators" => @config.operators.to_s,
+        "test_excludes" => Array(@config.test_excludes).map(&:to_s).sort,
+        "coverage_criteria" => @config.coverage_criteria.to_h.sort_by { |key, _| key.to_s }
+      }
+    end
+  end
+end

data/lib/henitai/rspec_coverage_formatter.rb

@@ -5,6 +5,10 @@ require "henitai/coverage_formatter"
 
 RSpec::Core::Formatters.register(
   Henitai::CoverageFormatter,
+  :example_started,
   :example_finished,
+  :example_group_started,
+  :example_group_finished,
+  :message,
   :dump_summary
 )

data/lib/henitai/rspec_outcomes.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "henitai/test_file_outcomes"
+
+module Henitai
+  # Records the outcome of each finished RSpec example per spec file.
+  #
+  # Failures outside an example produce no failed example. A hook error in
+  # `before(:context)` fails the group's examples, so it is attributed
+  # already; an `after(:context)` error is announced as a message while its
+  # group is open and is attributed to that group's file. Everything else
+  # counted by `errors_outside_of_examples_count` (a spec file that fails to
+  # load, `before(:suite)`) has no file and is recorded as unattributed.
+  module RspecOutcomes
+    EVENTS = %i[example_finished example_group_started example_group_finished message dump_summary].freeze
+    HOOK_ERROR = "An error occurred in "
+
+    # RSpec drops finished examples from its groups after a run, so
+    # outcomes are collected as the reporter announces them.
+    class Listener
+      def initialize(outcomes)
+        @outcomes = outcomes
+        @open_group_files = []
+        @attributed_errors = 0
+      end
+
+      def example_finished(notification)
+        RspecOutcomes.record(@outcomes, notification.example)
+      end
+
+      def example_group_started(notification)
+        @open_group_files.push(RspecOutcomes.group_file(notification.group))
+      end
+
+      def example_group_finished(_notification)
+        @open_group_files.pop
+      end
+
+      def message(notification)
+        file = @open_group_files.last
+        return unless file && notification.message.strip.start_with?(HOOK_ERROR)
+
+        @outcomes.record(file, failed: true)
+        @attributed_errors += 1
+      end
+
+      def dump_summary(summary)
+        return unless summary.errors_outside_of_examples_count > @attributed_errors
+
+        @outcomes.record_unattributed_failure
+      end
+    end
+
+    module_function
+
+    def register(outcomes, reporter)
+      reporter.register_listener(Listener.new(outcomes), *EVENTS)
+    end
+
+    def group_file(group)
+      metadata = group.metadata
+      metadata[:absolute_file_path] || metadata[:file_path]
+    end
+
+    def record(outcomes, example)
+      status = example.execution_result.status
+      return if status.nil?
+
+      outcomes.record(example.metadata[:file_path], failed: status == :failed)
+    end
+  end
+end

data/lib/henitai/runner.rb

@@ -11,16 +11,20 @@ module Henitai
   #
   #   Gate 2 — Mutant generation
   #     Apply operators to each Subject's AST. Filter arid (non-productive)
-  #     nodes via ignore_patterns. Produces the initial mutant list.
+  #     nodes from the built-in catalog. Produces the initial mutant list.
   #
   #   Gate 3 — Static filtering
-  #     Remove ignored mutants (pattern matches), compile-time errors.
+  #     Mark mutants whose original start line matches an ignore_patterns
+  #     entry as :ignored, and remove compile-time errors.
   #     Apply per-test coverage data: mark :no_coverage for uncovered mutants.
   #
   #   Gate 4 — Mutant execution
   #     Run surviving mutants in isolated child processes (fork isolation).
-  #     Each child process loads the test suite with the mutated method
-  #     injected via Module#define_method. Collect kill/survive/timeout results.
+  #     Each child process loads the test suite, then re-evaluates the
+  #     subject's own `def` with the mutation spliced in, inside its original
+  #     module/class openers (ADR-13). Module#define_method is only the fallback
+  #     for subjects that cannot be reopened by name. Collect kill/survive/
+  #     timeout results.
   #
   #   Gate 5 — Reporting
   #     Write results to configured reporters (terminal, html, json, dashboard).
@@ -29,7 +33,8 @@ module Henitai
     attr_reader :config, :result
 
     # @param mode [Hash] execution-mode flags: +dry_run:+ stops before Gate 4,
-    #   +incremental:+ reuses still-valid Killed verdicts from history.
+    #   +incremental:+ reuses still-valid Killed verdicts from history,
+    #   +force:+ disables the verdict reuse that survivor reruns apply.
     # +deps+ is assigned in the body, not defaulted in the signature: the
     # default needs @config, and `config:` itself defaults to a load.
     #
@@ -45,6 +50,7 @@ module Henitai
       @survivors_from = survivors_from
       @dry_run        = mode.fetch(:dry_run, false)
       @incremental    = mode.fetch(:incremental, false)
+      @force          = mode.fetch(:force, false)
     end
 
     # Entry point — runs the full pipeline and returns a Result.
@@ -76,6 +82,9 @@ module Henitai
     # static/skip/arid/stillborn filtering — everything short of execution.
     def pipeline_mutants
       if survivor_rerun? && (fast_mutants = survivor_strategy.try_recipe_run)
+        # Gate 0 still runs: test selection reads the per-test map, which must
+        # include new or edited tests.
+        bootstrap_coverage(fast_mutants.filter_map { |mutant| mutant.subject.source_file }.uniq)
         return fast_mutants
       end
 
@@ -104,8 +113,9 @@ module Henitai
       )
     end
 
+    # A survivor rerun must see every prior survivor, so it never samples.
     def generate_mutants(subjects)
-      mutant_generator.generate(subjects, operators, config:)
+      mutant_generator.generate(subjects, operators, config:, sample: !survivor_rerun?)
     end
 
     def filter_mutants(mutants)
@@ -116,25 +126,26 @@ module Henitai
       bootstrap_thread = bootstrap_mutants(source_files)
       mutants = generate_mutants(subjects)
       bootstrap_thread.value
-      filtered = apply_incremental_filter(filter_mutants(mutants))
-      return filtered unless survivor_rerun?
+      filtered = filter_mutants(mutants)
+      return apply_incremental_filter(filtered) unless survivor_rerun?
 
-      survivor_strategy.apply_selection(filtered)
+      survivor_strategy.apply_selection(filtered, reuse_filter: @force ? nil : reuse_filter)
     end
 
-    # Opt-in verdict reuse (`--incremental`): still-valid Killed and Survived
-    # verdicts from the history store are marked with their stored status +
-    # from_cache before execution. The filter is only ever constructed when
-    # the flag is set; it runs after the coverage bootstrap join in
-    # mutants_for, so the live per-test map it reads is never mid-write.
+    # Verdict reuse (opt-in `--incremental`; always for `--survivors-from`
+    # reruns, where it runs on the selected survivors): still-valid Killed and
+    # Survived verdicts from the history store are marked with their stored
+    # status + from_cache before execution. It runs after the coverage
+    # bootstrap join in mutants_for, so the live per-test map it reads is never
+    # mid-write.
     def apply_incremental_filter(mutants)
       return mutants unless @incremental
 
-      IncrementalFilter.new(history_store:, per_test_coverage:,
-                            dependency_fingerprint: VerdictFingerprint.dependency_fingerprint)
-                       .apply(mutants)
+      reuse_filter.apply(mutants)
     end
 
+    def reuse_filter = deps.reuse_filter
+
     def bootstrap_mutants(source_files) = Thread.new { bootstrap_coverage(source_files) }
 
     def execute_mutants(mutants)
@@ -150,12 +161,16 @@ module Henitai
       Reporter.run_all(names: config.reporters, result:, config:, history_store:)
     end
 
+    # History is an auxiliary trend artifact: a corrupt or locked database
+    # must not discard the run's verdicts, so the reports are still written.
     def persist_history(result, recorded_at)
       history_store.record(
         result,
         version: Henitai::VERSION,
         recorded_at:
       )
+    rescue StandardError => e
+      warn "henitai: could not record mutation history (#{e.class}: #{e.message}); reports are still written"
     end
 
     def build_result(mutants, started_at, finished_at)
@@ -177,10 +192,33 @@ module Henitai
         git_sha: safe_head_sha,
         source_provider: source_provider,
         authoritative: full_run?,
-        since: @since
+        since: @since,
+        complete_files: complete_files,
+        sampling: result_sampling
       )
     end
 
+    # Files whose every subject this run mutated: no subject patterns and no
+    # survivor rerun (a --since run still selects whole changed files).
+    def complete_files
+      return [] if Array(@subjects).any? || survivor_rerun?
+
+      source_files
+    end
+
+    # Records the sampling that actually shaped the mutant set, with the
+    # default seed filled in so the report is reproducible on its own.
+    def result_sampling
+      sampling = optional_config(:sampling)
+      return nil if survivor_rerun? || !(sampling && sampling[:ratio])
+
+      {
+        strategy: (sampling[:strategy] || "stratified").to_s,
+        ratio: sampling[:ratio],
+        seed: sampling[:seed] || SamplingStrategy::DEFAULT_SEED
+      }
+    end
+
     def safe_head_sha
       git_diff_analyzer.head_sha
     rescue StandardError
@@ -205,6 +243,7 @@ module Henitai
     def operators = deps.operators
     def history_store = deps.history_store
     def per_test_coverage = deps.per_test_coverage
+    def source_selection_coverage = deps.source_selection_coverage
     def source_provider = deps.source_provider
 
     def progress_reporter = deps.progress_reporter(full_run: full_run?)
@@ -216,7 +255,7 @@ module Henitai
     def source_file_selection
       @source_file_selection ||= SourceFileSelection.new(
         config: config, since: @since,
-        git_diff_analyzer: git_diff_analyzer, per_test_coverage: per_test_coverage
+        git_diff_analyzer: git_diff_analyzer, per_test_coverage: source_selection_coverage
       )
     end
 

data/lib/henitai/runner_dependencies.rb

@@ -12,6 +12,10 @@ module Henitai
   # {#per_test_coverage} and {#history_store}: the incremental filter proves
   # survivor reuse against the same live coverage map the history store records
   # its intersection set from. Two instances would be two snapshots.
+  #
+  # {#source_selection_coverage} is deliberately a *different* instance: Gate 1
+  # reads the map as it was before this run's coverage bootstrap rewrote it, and
+  # a shared instance would memoize that stale snapshot for the reuse decisions.
   class RunnerDependencies
     def initialize(config:)
       @config = config
@@ -36,10 +40,27 @@ module Henitai
       @per_test_coverage ||= PerTestCoverage.new(reports_dir: @config.reports_dir)
     end
 
+    def source_selection_coverage
+      @source_selection_coverage ||= PerTestCoverage.new(reports_dir: @config.reports_dir)
+    end
+
     def history_store
       @history_store ||= MutantHistoryStore.new(
         path: File.join(@config.reports_dir, Henitai::HISTORY_STORE_FILENAME),
-        per_test_coverage: per_test_coverage
+        per_test_coverage: per_test_coverage,
+        reuse_context: reuse_context
+      )
+    end
+
+    # Shared by the incremental filter and the history store: verdicts are
+    # recorded under exactly the context they are later checked against.
+    def reuse_context
+      @reuse_context ||= ReuseContext.new(config: @config)
+    end
+
+    def reuse_filter
+      IncrementalFilter.new(
+        history_store: history_store, per_test_coverage: per_test_coverage, reuse_context: reuse_context
       )
     end
 

data/lib/henitai/sampling_strategy.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
+require "digest"
 module Henitai
-  # Samples mutants in a strategy-aware, deterministic way.
+  # Samples mutants deterministically, stratified by operator within each subject.
+  #
+  # Per subject, the sample size is ceil(size * ratio), at least one and at most
+  # size. Mutants are grouped into strata by operator. Each stratum is ordered by
+  # a seeded SHA256 key derived from the mutant's stable id, so a mutant's rank
+  # does not depend on other mutants. Strata are then visited round-robin, which
+  # spreads the sample across operators and positions. Kept mutants are returned
+  # in their input order.
   class SamplingStrategy
-    def sample(mutants, ratio:, strategy: :stratified)
+    DEFAULT_SEED = 0
+
+    def sample(mutants, ratio:, strategy: :stratified, seed: DEFAULT_SEED)
       strategy = strategy.to_sym if strategy.respond_to?(:to_sym)
 
       case strategy
       when :stratified
-        stratified_sample(Array(mutants), ratio:)
+        stratified_sample(Array(mutants), ratio:, seed:)
       else
         raise ArgumentError, "Unsupported sampling strategy: #{strategy}"
       end
@@ -16,12 +26,32 @@ module Henitai
 
     private
 
-    def stratified_sample(mutants, ratio:)
+    def stratified_sample(mutants, ratio:, seed:)
       return [] if ratio.to_f <= 0.0
 
-      mutants.group_by { |mutant| mutant.subject.expression }.flat_map do |_subject, group|
-        group.take(sample_count(group.size, ratio))
+      kept = Set.new.compare_by_identity
+      mutants.group_by { |mutant| mutant.subject.expression }.each_value do |group|
+        select_within_subject(group, ratio:, seed:).each { |mutant| kept << mutant }
       end
+      mutants.select { |mutant| kept.include?(mutant) }
+    end
+
+    def select_within_subject(group, ratio:, seed:)
+      strata = group.group_by { |mutant| mutant.operator.to_s }.sort.map do |_operator, members|
+        members.sort_by { |mutant| sort_key(mutant, seed) }
+      end
+
+      round_robin(strata, sample_count(group.size, ratio))
+    end
+
+    def round_robin(strata, count)
+      depth = strata.map(&:size).max || 0
+
+      (0...depth).flat_map { |index| strata.filter_map { |stratum| stratum[index] } }.first(count)
+    end
+
+    def sort_key(mutant, seed)
+      Digest::SHA256.hexdigest("#{seed}\0#{mutant.stable_id}")
     end
 
     def sample_count(size, ratio)

data/lib/henitai/scenario_execution_result.rb

@@ -3,7 +3,7 @@
 module Henitai
   # Captures the result of one baseline or mutant test run.
   class ScenarioExecutionResult
-    attr_reader :status, :stdout, :stderr, :exit_status, :log_path
+    attr_reader :status, :status_reason, :stdout, :stderr, :exit_status, :log_path, :killing_tests
 
     def self.build(wait_result:, stdout:, stderr:, log_path:)
       new(
@@ -15,12 +15,32 @@ module Henitai
       )
     end
 
-    def initialize(status:, stdout:, stderr:, log_path:, exit_status: nil)
+    # Copies the reason behind a harness status onto the mutant the result was
+    # produced for. Tolerates results and mutants that carry no reason.
+    def self.copy_reason(result, mutant)
+      return unless result.respond_to?(:status_reason) && mutant.respond_to?(:status_reason=)
+
+      mutant.status_reason = result.status_reason
+    end
+
+    # Classifies a mutant run from the child's report (see MutantVerdict).
+    def self.build_for_mutant(wait_result:, report:, stdout:, stderr:, log_path:)
+      verdict = MutantVerdict.new(wait_result:, report:, stdout:, stderr:)
+      status, status_reason = verdict.to_a
+      new(status:, status_reason:, stdout:, stderr:, log_path:, exit_status: exit_status_for(wait_result),
+          killing_tests: verdict.killing_tests)
+    end
+
+    # rubocop:disable Metrics/ParameterLists -- one keyword per captured field
+    def initialize(status:, stdout:, stderr:, log_path:, exit_status: nil, status_reason: nil, killing_tests: [])
+      # rubocop:enable Metrics/ParameterLists
       @status = status
+      @status_reason = status_reason
       @stdout = stdout.to_s
       @stderr = stderr.to_s
       @log_path = log_path
       @exit_status = exit_status
+      @killing_tests = killing_tests
     end
 
     # Frees the captured child output once it has been consumed (e.g. by the
@@ -107,14 +127,17 @@ module Henitai
       end
 
       def no_examples_found?(stdout, stderr)
-        stdout.to_s.include?("No examples found.") || stderr.to_s.include?("No examples found.")
+        output = [stdout.to_s, stderr.to_s].join("\n")
+        return false unless ExampleSummary::NO_EXAMPLES_FOUND.match?(output)
+
+        last_summary = output.scan(ExampleSummary::SUMMARY).last
+        last_summary.nil? || last_summary == ["0"]
       end
 
       def zero_examples_failure?(wait_result, stdout, stderr)
         return false unless exit_status_for(wait_result) == 1
 
-        output = [stdout.to_s, stderr.to_s].join("\n")
-        output.include?("0 examples, 0 failures")
+        ExampleSummary.none_ran?([stdout.to_s, stderr.to_s].join("\n"))
       end
     end
 

data/lib/henitai/signature_line.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Whether a mutant sits on its subject's def (signature) line. Line coverage
+  # credits that line only to the test that loaded the file, so the tests that
+  # exercise it are not knowable from the per-test map alone.
+  module SignatureLine
+    module_function
+
+    # A subject without a source range (a recipe stub) has an unknown def
+    # line, so it is treated as one: that only widens test selection and
+    # blocks verdict reuse.
+    def on?(mutant)
+      subject = mutant.respond_to?(:subject) ? mutant.subject : nil
+      return false unless subject.respond_to?(:source_range)
+
+      range = subject.source_range
+      range.nil? || range.begin == mutant.location[:start_line]
+    end
+  end
+end

data/lib/henitai/slot_scheduler/draining.rb

@@ -80,9 +80,17 @@ module Henitai
         end
       end
 
+      # Unrelated events (CHLD of another slot, server traffic) wake the select
+      # early; the SIGTERM grace window must still run its full length.
       def wait_for_drain_window
-        wakeup&.wait(PROCESS_DRAIN_WINDOW)
-        wakeup&.drain
+        return unless wakeup
+
+        deadline = monotonic_time + PROCESS_DRAIN_WINDOW
+        while (remaining = deadline - monotonic_time).positive?
+          woken = wakeup.wait(remaining)
+          wakeup.drain
+          break unless woken
+        end
       end
 
       def signal_draining_slots(draining)
@@ -115,6 +123,7 @@ module Henitai
       def reap_and_finalize_slot(slot)
         _, final_status = wnohang_reap(slot.pid)
         reap_pid(slot.pid) unless final_status
+        tear_down_process_group(slot.pid)
 
         slot_table.release_pid(slot.pid)
         slot_table.delete(slot.slot_id)
@@ -128,6 +137,7 @@ module Henitai
       def record_drain_result(slot, final_status)
         result = drain_verdict.build(slot, final_status)
         slot.mutant.status = result.status
+        ScenarioExecutionResult.copy_reason(result, slot.mutant)
         results << result
         progress_reporter&.progress(slot.mutant, scenario_result: result)
       end