henitai 0.5.3 → 0.6.0

data/lib/henitai/suite_boot_clock.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Measures how long a baseline suite process spent before its first test
+  # started. The parent passes its spawn wall-clock time through
+  # STARTED_AT_ENV; the boot time covers loading helpers and spec files and
+  # running before(:suite).
+  class SuiteBootClock
+    STARTED_AT_ENV = "HENITAI_SUITE_STARTED_AT"
+
+    # @param started_at [Float, nil] epoch seconds of the suite spawn
+    # @param clock [#call] returns the current epoch seconds
+    def initialize(started_at:, clock: -> { Time.now.to_f })
+      @started_at = started_at
+      @clock = clock
+      @boot_seconds = nil
+    end
+
+    # @param env [Hash] environment of the suite process
+    # @return [SuiteBootClock]
+    def self.from_env(env, clock: -> { Time.now.to_f })
+      new(started_at: parse_timestamp(env[STARTED_AT_ENV]), clock:)
+    end
+
+    def self.parse_timestamp(value)
+      Float(value)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    # Records boot time at the first test start only; later calls are ignored.
+    def mark_first_test_started
+      return if @boot_seconds || @started_at.nil?
+
+      @boot_seconds = [@clock.call - @started_at, 0.0].max
+    end
+
+    # @return [Float] boot seconds, 0.0 when unknown
+    def boot_seconds
+      @boot_seconds || 0.0
+    end
+
+    # @return [Boolean] true once a boot time has been recorded
+    def measured?
+      !@boot_seconds.nil?
+    end
+  end
+end

data/lib/henitai/survivor_activation_cache.rb

@@ -4,7 +4,7 @@ require "json"
 require "fileutils"
 
 module Henitai
-  # Stores and retrieves pre-computed +define_method+ activation sources for
+  # Stores and retrieves pre-computed activations (see Mutant::Activation) for
   # survived mutants, enabling survivor reruns to skip the full mutant-generation
   # pipeline.
   #
@@ -14,7 +14,7 @@ module Henitai
   # objects directly and execute them without re-parsing source files.
   #
   # A recipe entry encodes everything needed to activate and re-report a mutant:
-  # the +define_method+ source, subject coordinates, operator, description,
+  # the activation (source, mode, file, line), subject coordinates, operator, description,
   # location, and the coveredBy test list.
   class SurvivorActivationCache
     FILENAME = "activation-recipes.json"
@@ -26,10 +26,10 @@ module Henitai
     # @return [Hash<String, Hash>] stableId → recipe
     def self.compute(survived_mutants)
       survived_mutants.each_with_object({}) do |mutant, cache|
-        source = Mutant::Activator.activation_source_for(mutant)
-        next unless source
+        activation = Mutant::Activator.activation_for(mutant)
+        next unless activation
 
-        cache[mutant.stable_id] = build_recipe(mutant, source)
+        cache[mutant.stable_id] = build_recipe(mutant, activation)
       end
     end
 
@@ -53,13 +53,11 @@ module Henitai
     class << self
       private
 
-      def build_recipe(mutant, activation_source)
+      def build_recipe(mutant, activation)
         {
-          "activationSource" => activation_source,
-          "namespace" => mutant.subject.namespace,
-          "methodName" => mutant.subject.method_name,
-          "methodType" => mutant.subject.method_type.to_s,
-          "sourceFile" => mutant.subject.source_file,
+          "activation" => activation.to_h,
+          "replacement" => mutant.mutated_source,
+          **subject_fields(mutant.subject),
           "operator" => mutant.operator,
           "description" => mutant.description,
           "location" => serialize_location(mutant.location),
@@ -67,6 +65,15 @@ module Henitai
         }
       end
 
+      def subject_fields(subject)
+        {
+          "namespace" => subject.namespace,
+          "methodName" => subject.method_name,
+          "methodType" => subject.method_type.to_s,
+          "sourceFile" => subject.source_file
+        }
+      end
+
       def serialize_location(location)
         {
           "file" => location[:file],

data/lib/henitai/survivor_rerun_strategy.rb

@@ -12,8 +12,15 @@ module Henitai
   #     fast path, bypassing source parsing and mutant generation), or
   #   * filters a freshly generated mutant list down to the prior survivors.
   #
-  # In both cases it records {#survivor_stats} (matched/unmatched counts and the
-  # drift warning) for the Runner to attach to its Result.
+  # Survivors are never trusted on the strength of the prior report alone: a
+  # selected survivor is skipped only when the {IncrementalFilter} content
+  # fingerprint rules prove its stored verdict still valid (new or edited
+  # tests, helpers and configuration all force a re-run). Recipe stubs have no
+  # source range to fingerprint, so they always re-run.
+  #
+  # In both cases it records {#survivor_stats} (matched/unmatched counts, the
+  # reused-verdict count and the drift warning) for the Runner to attach to
+  # its Result.
   class SurvivorRerunStrategy
     attr_reader :survivor_stats
 
@@ -32,26 +39,19 @@ module Henitai
     # bypassing source parsing and mutant generation entirely.
     # Returns the mutant array on success, or nil if recipes are unavailable.
     def try_recipe_run
-      dirty_worktree_files = dirty_worktree_changed_files
       loaded = load_survivor_report
-      return nil unless recipe_fast_path_safe?(loaded, dirty_worktree_files)
+      return nil unless recipe_fast_path_safe?(loaded)
 
-      run_from_recipes(loaded, dirty_worktree_files)
+      run_from_recipes(loaded)
     end
 
-    def apply_selection(mutants)
-      dirty_worktree_files = dirty_worktree_changed_files
-      loaded   = load_survivor_report
-      selector = SurvivorSelector.new(survivor_ids: loaded.survivor_ids)
+    # @param reuse_filter [IncrementalFilter, nil] marks survivors whose
+    #   stored verdict is provably still valid as cache hits.
+    def apply_selection(mutants, reuse_filter: nil)
+      selector = SurvivorSelector.new(survivor_ids: load_survivor_report.survivor_ids)
       selected = selector.select(mutants)
-      finalize_survivor_split(
-        selector,
-        selected,
-        test_filter(
-          loaded,
-          dirty_source_files: dirty_source_files?(dirty_worktree_files, git_sha: loaded.git_sha)
-        ).apply(selected)
-      )
+      reuse_filter&.apply(selected)
+      finalize_selection(selector, selected)
     end
 
     private
@@ -60,20 +60,16 @@ module Henitai
       SurvivorLoader.new(@survivors_from, include_paths: Array(@config.includes)).load
     end
 
-    def run_from_recipes(loaded, dirty_worktree_files)
+    def run_from_recipes(loaded)
       recipes = load_activation_recipes(loaded.survivor_ids)
       return nil if recipes.nil?
 
       selector, stubs = recipe_selector_and_stubs(loaded.survivor_ids, recipes)
-      split = test_filter(
-        loaded,
-        dirty_source_files: dirty_source_files?(dirty_worktree_files, git_sha: loaded.git_sha)
-      ).apply(stubs)
-      finalize_survivor_split(selector, stubs, split)
+      finalize_selection(selector, stubs)
     end
 
-    def recipe_fast_path_safe?(loaded, dirty_worktree_files)
-      !dirty_source_files?(dirty_worktree_files, git_sha: loaded.git_sha)
+    def recipe_fast_path_safe?(loaded)
+      !dirty_source_files?(dirty_worktree_changed_files, git_sha: loaded.git_sha)
     end
 
     # Builds stub Mutants from recipes and a SurvivorSelector primed with the
@@ -92,11 +88,29 @@ module Henitai
       path    = File.join(File.dirname(@survivors_from), SurvivorActivationCache::FILENAME)
       recipes = SurvivorActivationCache.load(path)
       return nil if recipes.nil?
-      return nil unless survivor_ids.all? { |id| recipes.key?(id) }
+      return nil unless survivor_ids.all? { |id| replayable_recipe?(recipes[id]) }
 
       recipes
     end
 
+    # Recipes without an "activation" entry predate ADR-13: their
+    # define_method sources lose lexical scope, so they are not replayed.
+    # A :toplevel activation needs the persisted scope and owner, because the
+    # stub subject has no AST to resolve them from.
+    def replayable_recipe?(recipe)
+      return false unless recipe.is_a?(Hash) && recipe["activation"].is_a?(Hash)
+
+      activation = recipe["activation"]
+      activation["mode"] != "toplevel" || toplevel_fields_valid?(activation)
+    end
+
+    def toplevel_fields_valid?(activation)
+      scope = activation["lexicalScope"]
+      scope.is_a?(Array) && scope.all?(String) &&
+        activation["owner"].is_a?(String) &&
+        [true, false].include?(activation["singleton"])
+    end
+
     def build_stub_mutant(stable_id, recipe)
       mutant = Mutant.new(
         subject: stub_subject_from_recipe(recipe),
@@ -105,7 +119,8 @@ module Henitai
         description: recipe.fetch("description"),
         location: recipe_location(recipe["location"]),
         precomputed_stable_id: stable_id,
-        precomputed_activation_source: recipe.fetch("activationSource")
+        precomputed_activation: Mutant::Activation.from_h(recipe.fetch("activation")),
+        precomputed_replacement: recipe["replacement"]
       )
       mutant.covered_by = recipe["coveredBy"]
       mutant
@@ -132,21 +147,10 @@ module Henitai
       }.compact
     end
 
-    def finalize_survivor_split(selector, selected, split)
-      split[:stable].each { |m| m.status = :survived }
+    def finalize_selection(selector, selected)
       warn_survivor_drift(selector) if selector.drift_warning?
-      @survivor_stats = build_survivor_stats(selector, selected, split)
-      split[:stable] + split[:pending]
-    end
-
-    def test_filter(loaded, dirty_source_files:)
-      SurvivorTestFilter.new(
-        coverage_map: loaded.coverage_map,
-        git_sha: loaded.git_sha,
-        dirty_source_files:,
-        worktree_changed_files: Array(dirty_worktree_changed_files),
-        diff_analyzer: @git_diff_analyzer
-      )
+      @survivor_stats = build_survivor_stats(selector, selected)
+      selected
     end
 
     def dirty_worktree_changed_files
@@ -170,12 +174,12 @@ module Henitai
            "could not be matched; the source may have drifted - consider a full run"
     end
 
-    def build_survivor_stats(selector, selected, split)
+    def build_survivor_stats(selector, selected)
       {
         matched: selected.size,
         unmatched_count: selector.unmatched_ids.size,
         unmatched_ids: selector.unmatched_ids,
-        skipped_count: split[:stable].size,
+        skipped_count: selected.count(&:from_cache?),
         drift_warning: selector.drift_warning?
       }
     end

data/lib/henitai/test_file_outcomes.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+require_relative "per_test_coverage_collector"
+
+module Henitai
+  # Records per-test-file pass/fail outcomes from a test run.
+  #
+  # A failure that happens outside any example (a spec file that fails to
+  # load, a `before(:suite)` hook, a Minitest result without a usable file)
+  # cannot be pinned to a test file. It is recorded separately as an
+  # unattributed failure so consumers never mistake the run for a clean one.
+  class TestFileOutcomes
+    REPORT_FILE_NAME = "henitai_suite_outcomes.json"
+
+    def self.report_path(reports_dir)
+      File.join(reports_dir, REPORT_FILE_NAME)
+    end
+
+    def self.default_report_path
+      report_path(ENV.fetch(PerTestCoverageCollector::REPORT_DIR_ENV, "coverage"))
+    end
+
+    def self.load(path)
+      return new unless File.exist?(path)
+
+      data = JSON.parse(File.read(path))
+      new.tap do |outcomes|
+        outcomes.record_unattributed_failure if data["unattributed_failures"]
+        data.fetch("outcomes", {}).each do |file, outcome|
+          outcomes.record(file, failed: outcome == "failed")
+        end
+      end
+    rescue JSON::ParserError
+      new
+    end
+
+    def initialize
+      @failed = {}
+      @unattributed_failures = false
+    end
+
+    def record(file, failed:)
+      path = File.expand_path(file)
+      @failed[path] = (@failed[path] || false) || failed
+    end
+
+    def record_unattributed_failure
+      @unattributed_failures = true
+    end
+
+    def unattributed_failures?
+      @unattributed_failures
+    end
+
+    def failed_files
+      @failed.select { |_file, failed| failed }.keys.sort
+    end
+
+    def outcomes
+      @failed.transform_values { |failed| failed ? "failed" : "passed" }
+    end
+
+    def write(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, JSON.pretty_generate(payload))
+    end
+
+    private
+
+    def payload
+      data = { "outcomes" => outcomes }
+      data["unattributed_failures"] = true if @unattributed_failures
+      data
+    end
+  end
+end

data/lib/henitai/timeout_calibrator.rb

@@ -3,36 +3,58 @@
 module Henitai
   # Derives a per-mutant timeout from measured per-test-file durations.
   #
-  # The calibrated value is `multiplier × sum(durations of the selected test
-  # files)`, clamped to a floor so a near-instant baseline doesn't flag normal
-  # jitter as a timeout. Returns nil — caller falls back to the static
-  # default — when any selected test lacks timing data, so a partially
-  # measured run is treated as uncalibratable rather than under-estimated.
+  # The measured baseline is `sum(durations of the selected test files) +
+  # boot seconds`, where boot covers loading helpers and spec files and
+  # running before(:suite). The calibrated value is `multiplier × baseline`,
+  # clamped to a floor so a near-instant baseline doesn't flag normal jitter
+  # as a timeout. Returns nil — caller falls back to the static default —
+  # when any selected test lacks timing data, so a partially measured run is
+  # treated as uncalibratable rather than under-estimated.
   class TimeoutCalibrator
     FLOOR_SECONDS = 2.0
 
     # @param timing_source [#call] returns a Hash of test file path to
     #   wall-clock seconds; resolved lazily on first use.
     # @param multiplier [Numeric]
-    def initialize(timing_source:, multiplier:)
+    # @param boot_seconds [#call] returns the measured suite boot time.
+    # @param include_boot [Boolean] false when boot is paid once elsewhere
+    #   (for example by a preloaded fork server) and must not be repeated.
+    def initialize(timing_source:, multiplier:, boot_seconds: -> { 0.0 }, include_boot: true)
       @timing_source = timing_source
       @multiplier = multiplier
+      @boot_seconds = boot_seconds
+      @include_boot = include_boot
     end
 
     # @param test_files [Array<String>]
     # @return [Float, nil]
     def timeout_for(test_files)
+      baseline = baseline_for(test_files)
+      return nil if baseline.nil?
+
+      [@multiplier * baseline, FLOOR_SECONDS].max
+    end
+
+    # @param test_files [Array<String>]
+    # @return [Float, nil] measured baseline seconds, nil without timing data
+    def baseline_for(test_files)
       files = Array(test_files)
       return nil if files.empty? || durations.empty?
 
-      baselines = files.map { |file| durations[normalize(file)] }
-      return nil if baselines.any?(&:nil?)
+      measured = files.map { |file| durations[normalize(file)] }
+      return nil if measured.any?(&:nil?)
 
-      [@multiplier * baselines.sum, FLOOR_SECONDS].max
+      measured.sum + boot_component
     end
 
     private
 
+    def boot_component
+      return 0.0 unless @include_boot
+
+      @boot_component ||= @boot_seconds.call.to_f
+    end
+
     def durations
       @durations ||= (@timing_source.call || {}).transform_keys { |key| normalize(key) }
     end

data/lib/henitai/timeout_ceiling.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Applies the max_timeout ceiling to a calibrated timeout. The ceiling stops a
+  # runaway mutant from running for minutes, but it must never push the timeout
+  # below the measured test baseline, or every mutant would be reported as a
+  # timeout instead of being tested.
+  class TimeoutCeiling
+    def initialize(ceiling:, warner:)
+      @ceiling = ceiling
+      @warner = warner
+      @warned = false
+    end
+
+    def cap(calibrated, baseline)
+      return calibrated if calibrated <= @ceiling
+
+      warn_baseline_exceeds_ceiling(baseline) if baseline > @ceiling
+      [@ceiling, baseline + TimeoutCalibrator::FLOOR_SECONDS].max
+    end
+
+    private
+
+    def warn_baseline_exceeds_ceiling(baseline)
+      return if @warned
+
+      @warned = true
+      @warner.call(
+        format(
+          "henitai: measured test baseline of %<baseline>.1fs exceeds max_timeout (%<ceiling>.1fs); " \
+          "using %<timeout>.1fs instead",
+          baseline:, ceiling: @ceiling, timeout: baseline + TimeoutCalibrator::FLOOR_SECONDS
+        )
+      )
+    end
+  end
+end

data/lib/henitai/verdict_fingerprint.rb

@@ -10,9 +10,12 @@ module Henitai
   # Content fingerprints that decide whether a stored verdict is still
   # trustworthy: the subject's source (method body) and the covering test
   # files must both be byte-identical to what was recorded. Survived verdicts
-  # additionally record the full-map covering-set membership plus a run-level
-  # dependency fingerprint (ADR-11). Any read failure yields nil / a mismatch
-  # — conservative, never reuse on doubt.
+  # additionally record the full-map covering-set membership (ADR-11). Both
+  # verdict kinds carry the run's {ReuseContext} fingerprint (test
+  # dependencies, verdict-relevant configuration, henitai version) and are
+  # reusable only under an identical one. Any read failure yields nil / a
+  # mismatch — conservative, never reuse on doubt; rows recorded without a
+  # context are never reusable.
   module VerdictFingerprint
     # Files that influence test behavior but never appear in any covering
     # set: helpers, support code, fixtures/factories, lockfile and tool
@@ -49,24 +52,29 @@ module Henitai
       nil
     end
 
-    # JSON fingerprint of the covering test files: their sorted paths plus a
-    # combined content hash. nil when no tests are known or any is unreadable.
-    def tests_fingerprint(test_files)
+    # JSON fingerprint of the covering test files: their sorted paths, a
+    # combined content hash and the reuse context. nil when no tests are known,
+    # any is unreadable, or there is no context to bind the verdict to.
+    def tests_fingerprint(test_files, context_sha:)
+      return nil if context_sha.nil?
+
       paths = Array(test_files).map(&:to_s).sort
       return nil if paths.empty?
 
       sha = combined_content_sha(paths)
       return nil unless sha
 
-      JSON.generate("paths" => paths, "sha" => sha)
+      JSON.generate("paths" => paths, "sha" => sha, "context" => context_sha)
     end
 
-    # True when every recorded test file still exists with identical content.
-    def tests_fingerprint_current?(fingerprint_json)
-      return false if fingerprint_json.nil?
+    # True when every recorded test file still exists with identical content
+    # and the recorded reuse context equals the current one.
+    def tests_fingerprint_current?(fingerprint_json, context_sha:)
+      return false if fingerprint_json.nil? || context_sha.nil?
 
       fingerprint = JSON.parse(fingerprint_json)
-      combined_content_sha(fingerprint.fetch("paths")) == fingerprint.fetch("sha")
+      fingerprint.fetch("context") == context_sha &&
+        combined_content_sha(fingerprint.fetch("paths")) == fingerprint.fetch("sha")
     rescue StandardError
       false
     end
@@ -101,38 +109,29 @@ module Henitai
     def dependency_fingerprint(root = Dir.pwd) = combined_content_sha(dependency_files(root))
 
     # Fingerprint recorded for a Survived verdict: the sorted full-map
-    # intersection set (paths + combined content sha) plus the run-level
-    # dependency sha. nil when any input is unavailable — the verdict is
-    # then never reusable.
-    def survivor_tests_fingerprint(test_files, dependency_sha:)
-      return nil if dependency_sha.nil?
-
-      paths = Array(test_files).map(&:to_s).sort
-      return nil if paths.empty?
-
-      sha = combined_content_sha(paths)
-      return nil unless sha
-
-      JSON.generate("paths" => paths, "sha" => sha, "dependencies" => dependency_sha)
+    # intersection set (paths + combined content sha) plus the reuse context.
+    # nil when any input is unavailable — the verdict is then never reusable.
+    def survivor_tests_fingerprint(test_files, context_sha:)
+      tests_fingerprint(test_files, context_sha:)
     end
 
     # True when the recorded covering set still equals the live one in
-    # membership AND content, and the dependency fingerprint is unchanged.
+    # membership AND content, and the reuse context is unchanged.
     # Any parse/read failure or missing field resolves to stale.
-    def survivor_fingerprint_current?(fingerprint_json, live_paths:, dependency_sha:)
-      return false if fingerprint_json.nil? || dependency_sha.nil?
+    def survivor_fingerprint_current?(fingerprint_json, live_paths:, context_sha:)
+      return false if fingerprint_json.nil? || context_sha.nil?
 
-      survivor_fingerprint_matches?(JSON.parse(fingerprint_json), live_paths, dependency_sha)
+      survivor_fingerprint_matches?(JSON.parse(fingerprint_json), live_paths, context_sha)
     rescue StandardError
       false
     end
 
-    def survivor_fingerprint_matches?(fingerprint, live_paths, dependency_sha)
+    def survivor_fingerprint_matches?(fingerprint, live_paths, context_sha)
       recorded_paths = fingerprint.fetch("paths")
       return false if recorded_paths.empty?
 
       recorded_paths == Array(live_paths).map(&:to_s).sort &&
-        fingerprint.fetch("dependencies") == dependency_sha &&
+        fingerprint.fetch("context") == context_sha &&
         combined_content_sha(recorded_paths) == fingerprint.fetch("sha")
     end
 

data/lib/henitai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Henitai
-  VERSION = "0.5.3"
+  VERSION = "0.6.0"
 end

data/lib/henitai.rb

@@ -28,12 +28,14 @@ module Henitai
   autoload :CoverageReportReader, "henitai/coverage_report_reader"
   autoload :PerTestCoverage, "henitai/per_test_coverage"
   autoload :PerTestCoverageSelector, "henitai/per_test_coverage_selector"
+  autoload :SignatureLine, "henitai/signature_line"
   autoload :Subject, "henitai/subject"
   autoload :Mutant, "henitai/mutant"
   autoload :MutantIdentity, "henitai/mutant_identity"
   autoload :Operator, "henitai/operator"
   autoload :Operators, "henitai/operators"
   autoload :SourceParser, "henitai/source_parser"
+  autoload :ConstantPath, "henitai/constant_path"
   autoload :SubjectResolver, "henitai/subject_resolver"
   autoload :GeneratedArtifacts, "henitai/generated_artifacts"
   autoload :GitDiffAnalyzer, "henitai/git_diff_analyzer"
@@ -46,31 +48,45 @@ module Henitai
   autoload :EquivalenceDetector, "henitai/equivalence_detector"
   autoload :StaticFilter, "henitai/static_filter"
   autoload :IncrementalFilter, "henitai/incremental_filter"
+  autoload :ReuseContext, "henitai/reuse_context"
   autoload :VerdictFingerprint, "henitai/verdict_fingerprint"
   autoload :StillbornFilter, "henitai/stillborn_filter"
+  autoload :FidelityCheck, "henitai/fidelity_check"
+  autoload :ControlRun, "henitai/control_run"
   autoload :CanonicalReportMerger, "henitai/canonical_report_merger"
   autoload :CanonicalReportWriter, "henitai/canonical_report_writer"
   autoload :CheckpointReporter, "henitai/checkpoint_reporter"
   autoload :CompositeProgressReporter, "henitai/composite_progress_reporter"
+  autoload :BootstrapErrorMessage, "henitai/bootstrap_error_message"
   autoload :ReportsDirectoryLock, "henitai/reports_directory_lock"
   autoload :SurvivorLoader,          "henitai/survivor_loader"
   autoload :SurvivorSelector,        "henitai/survivor_selector"
-  autoload :SurvivorTestFilter,      "henitai/survivor_test_filter"
   autoload :SurvivorActivationCache, "henitai/survivor_activation_cache"
   autoload :SurvivorRerunStrategy, "henitai/survivor_rerun_strategy"
   autoload :DirtySourceDetector, "henitai/dirty_source_detector"
   autoload :SourceFileSelection, "henitai/source_file_selection"
   autoload :SubjectSelection, "henitai/subject_selection"
   autoload :ScenarioExecutionResult, "henitai/scenario_execution_result"
+  autoload :FlakyTestRegistry, "henitai/flaky_test_registry"
+  autoload :FlakyDetectionBaseline, "henitai/flaky_detection_baseline"
+  autoload :FlakyMutantRetrier, "henitai/flaky_mutant_retrier"
+  autoload :TestFileOutcomes, "henitai/test_file_outcomes"
+  autoload :FlakyRetryDecision, "henitai/flaky_retry_decision"
+  autoload :ExampleSummary, "henitai/example_summary"
+  autoload :MutantVerdict, "henitai/mutant_verdict"
   autoload :CoverageFormatter, "henitai/coverage_formatter"
   autoload :MinitestCoverageReporter, "henitai/minitest_coverage_reporter"
   autoload :PerTestCoverageCollector, "henitai/per_test_coverage_collector"
+  autoload :PerTestCoverageDelta, "henitai/per_test_coverage_delta"
   autoload :SyntaxValidator, "henitai/syntax_validator"
   autoload :SamplingStrategy, "henitai/sampling_strategy"
   autoload :TestPrioritizer, "henitai/test_prioritizer"
   autoload :ExcludedTestFilter, "henitai/excluded_test_filter"
+  autoload :SuiteBootClock, "henitai/suite_boot_clock"
   autoload :TimeoutCalibrator, "henitai/timeout_calibrator"
+  autoload :TimeoutCeiling, "henitai/timeout_ceiling"
   autoload :ExecutionEngine, "henitai/execution_engine"
+  autoload :ForkServer, "henitai/fork_server"
   autoload :ProcessWorkerRunner, "henitai/process_worker_runner"
   autoload :SlotScheduler, "henitai/slot_scheduler"
   autoload :ProcessWakeup, "henitai/process_wakeup"

data/sig/configuration_validator.rbs

@@ -46,6 +46,7 @@ module Henitai
       def self?.validate_max_flaky_retries: (untyped) -> void
       def self?.validate_sampling_ratio: (untyped) -> void
       def self?.validate_sampling_strategy: (untyped) -> void
+      def self?.validate_sampling_seed: (untyped) -> void
       def self?.validate_sampling_completeness: (Hash[Symbol, untyped]) -> void
       def self?.describe_array_type: (untyped) -> String
     end