henitai 0.2.1 → 0.3.1

data/lib/henitai/coverage_bootstrapper.rb

@@ -1,12 +1,30 @@
 # frozen_string_literal: true
 
+require "fileutils"
+require "json"
+
+require_relative "verdict_fingerprint"
+
 module Henitai
   # Ensures coverage data exists before the mutation pipeline starts.
   class CoverageBootstrapper
+    # Sidecar recording which dependency files existed when the coverage
+    # artifacts were produced. Deletions drop a path from the current set but
+    # leave every surviving file's mtime untouched, so freshness must compare
+    # the recorded path set, not just watch existing files.
+    DEPENDENCY_MANIFEST_FILE = "henitai_dependency_manifest.json"
+
     def initialize(static_filter: StaticFilter.new)
       @static_filter = static_filter
     end
 
+    # Writes the current dependency path set next to the coverage artifacts.
+    # Called after every bootstrap; exposed so tests can seed a manifest.
+    def record_dependency_manifest(config)
+      FileUtils.mkdir_p(reports_dir(config))
+      File.write(dependency_manifest_path(config), JSON.generate(current_dependency_paths))
+    end
+
     # Runs the test suite to collect coverage, unless a fresh report already
     # exists.
     #
@@ -62,14 +80,38 @@ module Henitai
       Array(source_files).map { |path| File.expand_path(path) }
     end
 
-    # Returns true when a coverage report already exists and is newer than
-    # every watched source and test file. Stale or absent reports return false.
+    # Returns true when a coverage report already exists, is newer than every
+    # watched source and test file, and the dependency path set is unchanged
+    # since the report was produced. Stale or absent reports return false.
     def coverage_fresh?(source_files, config, test_files)
       watched_files_fresh?(
         coverage_report_path(config),
         source_files,
         test_files
-      )
+      ) && dependency_manifest_current?(config)
+    end
+
+    # False when the manifest is missing, unreadable, or lists a different
+    # path set than the files currently on disk — conservative: a deleted
+    # dependency invalidates the coverage artifacts just like an edit.
+    def dependency_manifest_current?(config)
+      recorded = JSON.parse(File.read(dependency_manifest_path(config)))
+      recorded == current_dependency_paths
+    rescue StandardError
+      false
+    end
+
+    def dependency_manifest_path(config)
+      File.join(reports_dir(config), DEPENDENCY_MANIFEST_FILE)
+    end
+
+    # Paths stored relative to the working directory so the manifest survives
+    # a repository move.
+    def current_dependency_paths
+      root = Dir.pwd
+      VerdictFingerprint.dependency_files(root).map do |path|
+        path.delete_prefix("#{root}#{File::SEPARATOR}")
+      end
     end
 
     def coverage_report_path(config)
@@ -86,7 +128,10 @@ module Henitai
       with_reports_dir(config) do
         with_coverage_dir(config) do
           result = integration.run_suite(test_files)
-          return if result == :survived
+          if result == :survived
+            record_dependency_manifest(config)
+            return
+          end
 
           raise CoverageError, build_bootstrap_error(result)
         end
@@ -172,8 +217,12 @@ module Henitai
       end
     end
 
+    # Dependency files (helpers, support, fixtures, lockfile, tool config)
+    # are watched alongside sources and tests: they shape which tests cover
+    # what, so a stale per-test map after a dependency edit would let the
+    # test selector omit a newly covering test (ADR-11).
     def watched_files(source_files, test_files)
-      Array(source_files) + Array(test_files)
+      Array(source_files) + Array(test_files) + VerdictFingerprint.dependency_files
     end
 
     def resolve_test_files(integration, test_files)

data/lib/henitai/coverage_formatter.rb

@@ -13,7 +13,11 @@ module Henitai
     end
 
     def example_finished(notification)
-      @collector.record_test(notification.example.metadata[:file_path])
+      example = notification.example
+      @collector.record_test(
+        example.metadata[:file_path],
+        duration: example.execution_result.run_time
+      )
     end
 
     def dump_summary(_summary)

data/lib/henitai/coverage_report_reader.rb

@@ -22,17 +22,40 @@ module Henitai
     end
 
     def test_lines_by_file(path = DEFAULT_PER_TEST_COVERAGE_REPORT_PATH)
+      per_test_report(path).transform_values do |entry|
+        normalize_test_coverage(unwrap_coverage(entry))
+      end
+    end
+
+    # Wall-clock seconds per test file, from reports whose entries carry a
+    # "duration" field. Legacy reports (plain source-map entries) yield {}.
+    def durations_by_test(path = DEFAULT_PER_TEST_COVERAGE_REPORT_PATH)
+      per_test_report(path).filter_map do |test_file, entry|
+        next unless wrapped_entry?(entry) && entry.key?("duration")
+
+        [test_file, entry.fetch("duration").to_f]
+      end.to_h
+    end
+
+    private
+
+    def per_test_report(path)
       return {} unless File.exist?(path)
 
       parsed = JSON.parse(File.read(path))
-      return {} unless parsed.is_a?(Hash)
+      parsed.is_a?(Hash) ? parsed : {}
+    end
 
-      parsed.transform_values do |coverage|
-        normalize_test_coverage(coverage)
-      end
+    # New-format entries wrap the source map under "coverage" (with a sibling
+    # "duration"); legacy entries are the source map itself. Source-map keys
+    # are absolute file paths, so a plain "coverage" key is unambiguous.
+    def wrapped_entry?(entry)
+      entry.is_a?(Hash) && entry["coverage"].is_a?(Hash)
     end
 
-    private
+    def unwrap_coverage(entry)
+      wrapped_entry?(entry) ? entry.fetch("coverage") : entry
+    end
 
     def covered_lines(file_coverage)
       Array(file_coverage["lines"]).each_with_index.filter_map do |count, index|

data/lib/henitai/execution_engine/env_scope.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Henitai
+  class ExecutionEngine
+    # Run-scoped ENV/working-directory setup for {ExecutionEngine}: exposes the
+    # reports dir, mutation-coverage dir, per-stream log cap and worker-slot
+    # index to forked children via ENV, restoring the prior values afterwards.
+    # Extracted so the engine class stays focused on execution scheduling.
+    module EnvScope
+      private
+
+      def with_reports_dir(config)
+        original = ENV.fetch("HENITAI_REPORTS_DIR", nil)
+        ENV["HENITAI_REPORTS_DIR"] = config.reports_dir
+        yield
+      ensure
+        restore_env("HENITAI_REPORTS_DIR", original)
+      end
+
+      def with_coverage_dir(config)
+        original = ENV.fetch("HENITAI_COVERAGE_DIR", nil)
+        ENV["HENITAI_COVERAGE_DIR"] = mutation_coverage_dir(config)
+        yield
+      ensure
+        restore_env("HENITAI_COVERAGE_DIR", original)
+      end
+
+      def with_max_log_bytes(config)
+        cap = config.respond_to?(:max_log_bytes) ? config.max_log_bytes : nil
+        return yield if cap.nil?
+
+        env_key = Integration::ScenarioLogSupport::MAX_LOG_BYTES_ENV
+        original = ENV.fetch(env_key, nil)
+        ENV[env_key] = cap.to_s
+        yield
+      ensure
+        restore_env(env_key, original) if cap
+      end
+
+      # Linear-path children inherit slot 0 so suite-side isolation code works
+      # identically in both execution modes; the parallel scheduler overwrites
+      # the value per spawn. Restored afterwards like the other run-scoped vars.
+      def with_worker_slot
+        original = ENV.fetch(SlotScheduler::WORKER_SLOT_ENV, nil)
+        ENV[SlotScheduler::WORKER_SLOT_ENV] = "0"
+        yield
+      ensure
+        restore_env(SlotScheduler::WORKER_SLOT_ENV, original)
+      end
+
+      def restore_env(key, original)
+        if original.nil?
+          ENV.delete(key)
+        else
+          ENV[key] = original
+        end
+      end
+
+      def mutation_coverage_dir(config)
+        base_dir = config.respond_to?(:reports_dir) ? config.reports_dir : nil
+        base_dir = "reports" if base_dir.nil? || base_dir.empty?
+
+        File.join(base_dir, "mutation-coverage")
+      end
+    end
+  end
+end

data/lib/henitai/execution_engine.rb

@@ -1,31 +1,41 @@
 # frozen_string_literal: true
 
-require_relative "parallel_execution_runner"
 require_relative "process_worker_runner"
+require_relative "execution_engine/env_scope"
 
 module Henitai
   # Runs pending mutants through the selected integration.
   class ExecutionEngine
+    include EnvScope
+
     def run(mutants, integration, config, progress_reporter: nil)
       with_reports_dir(config) do
         with_coverage_dir(config) do
-          @flaky_retry_count = 0
-          pending_mutants = Array(mutants).select(&:pending?)
-          mutex = Mutex.new
-          if parallel_execution?(config, pending_mutants)
-            run_parallel(pending_mutants, integration, config, progress_reporter)
-          else
-            run_linear(pending_mutants, integration, config, progress_reporter, mutex)
+          with_max_log_bytes(config) do
+            with_worker_slot do
+              execute(mutants, integration, config, progress_reporter)
+            end
           end
-
-          warn_flaky_mutants(pending_mutants.size)
-          mutants
         end
       end
     end
 
     private
 
+    def execute(mutants, integration, config, progress_reporter)
+      @flaky_retry_count = 0
+      pending_mutants = Array(mutants).select(&:pending?)
+      mutex = Mutex.new
+      if parallel_execution?(config, pending_mutants)
+        run_parallel(pending_mutants, integration, config, progress_reporter)
+      else
+        run_linear(pending_mutants, integration, config, progress_reporter, mutex)
+      end
+
+      warn_flaky_mutants(pending_mutants.size)
+      mutants
+    end
+
     def parallel_execution?(config, mutants)
       worker_count(config) > 1 && mutants.size > 1
     end
@@ -53,7 +63,8 @@ module Henitai
         integration,
         config,
         progress_reporter,
-        test_file_resolver: ->(mutant) { prioritized_tests_for(mutant, integration, config) }
+        test_file_resolver: ->(mutant) { prioritized_tests_for(mutant, integration, config) },
+        timeout_resolver: ->(_mutant, test_files) { resolved_timeout(test_files, config) }
       )
       @flaky_retry_count = runner.flaky_retry_count
       results
@@ -61,11 +72,26 @@ module Henitai
 
     def process_mutant(mutant, integration, config, progress_reporter, mutex)
       test_files = prioritized_tests_for(mutant, integration, config)
-      mutant.covered_by = test_files if mutant.respond_to?(:covered_by=)
-      mutant.tests_completed = test_files.size if mutant.respond_to?(:tests_completed=)
+      record_test_files(mutant, test_files)
+      return record_no_coverage(mutant, progress_reporter, mutex) if test_files.empty?
+
       scenario_result = run_with_flaky_retry(mutant, integration, config, test_files, mutex)
       mutant.status = scenario_status(scenario_result)
 
+      report_progress(mutant, scenario_result, progress_reporter, mutex)
+    end
+
+    def record_test_files(mutant, test_files)
+      mutant.covered_by = test_files if mutant.respond_to?(:covered_by=)
+      mutant.tests_completed = test_files.size if mutant.respond_to?(:tests_completed=)
+    end
+
+    def record_no_coverage(mutant, progress_reporter, mutex)
+      mutant.status = :no_coverage
+      report_progress(mutant, nil, progress_reporter, mutex)
+    end
+
+    def report_progress(mutant, scenario_result, progress_reporter, mutex)
       if mutex
         mutex.synchronize { progress_reporter&.progress(mutant, scenario_result:) }
       else
@@ -74,16 +100,81 @@ module Henitai
     end
 
     def prioritized_tests_for(mutant, integration, config)
-      tests = integration.select_tests(mutant.subject)
+      tests = reject_excluded_tests(integration.select_tests(mutant.subject), config)
       tests = per_test_coverage_selector.filter(
         tests,
         mutant,
         reports_dir: config.reports_dir
       )
-      test_prioritizer.sort(tests, mutant, test_history(config))
+      test_prioritizer(config).sort(tests, mutant, test_history(config))
     end
 
-    def test_prioritizer = @test_prioritizer ||= TestPrioritizer.new
+    # Drops test files matching any config.test_excludes glob. Used to keep a
+    # mutant child from re-running tests that themselves spawn henitai/forked
+    # subprocesses (e.g. the CLI and process-scheduler specs when dogfooding
+    # henitai on itself), which otherwise multiplies processes and log noise.
+    def reject_excluded_tests(tests, config)
+      patterns = config.respond_to?(:test_excludes) ? Array(config.test_excludes) : []
+      return tests if patterns.empty?
+
+      expanded = patterns.map { |pattern| File.expand_path(pattern) }
+      tests.reject do |path|
+        candidate = File.expand_path(path)
+        expanded.any? { |pattern| File.fnmatch?(pattern, candidate, File::FNM_PATHNAME) }
+      end
+    end
+
+    def test_prioritizer(config)
+      @test_prioritizer ||= TestPrioritizer.new(timing_source: timing_source(config))
+    end
+
+    def timing_source(config)
+      path = File.join(config.reports_dir, PerTestCoverageCollector::REPORT_FILE_NAME)
+      -> { CoverageReportReader.new.durations_by_test(path) }
+    end
+
+    # Fixed `mutation.timeout` wins untouched; when unset, the timeout is
+    # calibrated per mutant from its selected tests' measured durations, with
+    # a single warning per run when no timing data is available.
+    def resolved_timeout(test_files, config)
+      return config.timeout unless calibration_enabled?(config)
+
+      calibrated = timeout_calibrator(config).timeout_for(test_files)
+      return [calibrated, max_timeout(config)].min if calibrated
+
+      warn_timeout_fallback_once
+      Configuration::DEFAULT_TIMEOUT
+    end
+
+    # Ceiling on the auto-calibrated timeout so a runaway mutant is killed in
+    # seconds instead of running for minutes when the calibrated value (derived
+    # from a slow baseline) is large. A fixed mutation.timeout bypasses this.
+    def max_timeout(config)
+      return config.max_timeout if config.respond_to?(:max_timeout) && config.max_timeout
+
+      Configuration::DEFAULT_MAX_TIMEOUT
+    end
+
+    def calibration_enabled?(config)
+      config.respond_to?(:timeout_configured?) && !config.timeout_configured?
+    end
+
+    def timeout_calibrator(config)
+      @timeout_calibrator ||= TimeoutCalibrator.new(
+        timing_source: timing_source(config),
+        multiplier: config.timeout_multiplier
+      )
+    end
+
+    def warn_timeout_fallback_once
+      return if @warned_timeout_fallback
+
+      @warned_timeout_fallback = true
+      warn(
+        "Timeout calibration unavailable (no per-test timing data); " \
+        "falling back to the default timeout of #{Configuration::DEFAULT_TIMEOUT}s"
+      )
+    end
 
     def per_test_coverage_selector = @per_test_coverage_selector ||= PerTestCoverageSelector.new
 
@@ -98,10 +189,11 @@ module Henitai
     # runtime on real CI workloads.
     # rubocop:disable Metrics/MethodLength
     def run_with_flaky_retry(mutant, integration, config, test_files, mutex)
+      timeout = resolved_timeout(test_files, config)
       scenario_result = integration.run_mutant(
         mutant:,
         test_files:,
-        timeout: config.timeout
+        timeout: timeout
       )
       return scenario_result unless scenario_status(scenario_result) == :survived
 
@@ -111,7 +203,7 @@ module Henitai
         scenario_result = integration.run_mutant(
           mutant:,
           test_files:,
-          timeout: config.timeout
+          timeout: timeout
         )
         break unless scenario_status(scenario_result) == :survived
       end
@@ -141,37 +233,6 @@ module Henitai
       )
     end
 
-    def with_reports_dir(config)
-      original_reports_dir = ENV.fetch("HENITAI_REPORTS_DIR", nil)
-      ENV["HENITAI_REPORTS_DIR"] = config.reports_dir
-      yield
-    ensure
-      if original_reports_dir.nil?
-        ENV.delete("HENITAI_REPORTS_DIR")
-      else
-        ENV["HENITAI_REPORTS_DIR"] = original_reports_dir
-      end
-    end
-
-    def with_coverage_dir(config)
-      original_coverage_dir = ENV.fetch("HENITAI_COVERAGE_DIR", nil)
-      ENV["HENITAI_COVERAGE_DIR"] = mutation_coverage_dir(config)
-      yield
-    ensure
-      if original_coverage_dir.nil?
-        ENV.delete("HENITAI_COVERAGE_DIR")
-      else
-        ENV["HENITAI_COVERAGE_DIR"] = original_coverage_dir
-      end
-    end
-
-    def mutation_coverage_dir(config)
-      base_dir = config.respond_to?(:reports_dir) ? config.reports_dir : nil
-      base_dir = "reports" if base_dir.nil? || base_dir.empty?
-
-      File.join(base_dir, "mutation-coverage")
-    end
-
     def max_flaky_retries(config)
       return 3 unless config.respond_to?(:max_flaky_retries)
 

data/lib/henitai/generated_artifacts.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Recognizes directories holding henitai/SimpleCov *output* so dependency
+  # scans can skip them. Detection requires artifact evidence — known output
+  # files inside the directory — not just a conventional name: a directory
+  # merely named reports/ or coverage/ may hold legitimate fixture input,
+  # and wrongly excluding a real dependency would let an obsolete Survived
+  # verdict be reused (unsound). Wrongly including junk merely re-runs.
+  module GeneratedArtifacts
+    # Evidence that a coverage/ directory is SimpleCov output.
+    COVERAGE_MARKERS = %w[.resultset.json .last_run.json].freeze
+
+    # Evidence that a reports/ directory is a henitai reports_dir.
+    REPORT_MARKERS = %w[
+      mutation-report.json
+      mutation-report.html
+      mutation-history.sqlite3
+      mutation-history.json
+      henitai_per_test.json
+      henitai_dependency_manifest.json
+      .henitai-run.lock
+      mutation-logs
+      mutation-coverage
+    ].freeze
+
+    module_function
+
+    # True when the directory carries a generated-artifact name AND contains
+    # evidence of actual output. Unreadable directories count as evidence-
+    # free — they stay in the scan (conservative direction).
+    def generated_dir?(path)
+      case File.basename(path)
+      when "coverage" then evidence?(path, COVERAGE_MARKERS)
+      when "reports" then evidence?(path, REPORT_MARKERS)
+      when "mutation-logs", "mutation-coverage" then per_mutant_evidence?(path)
+      else false
+      end
+    end
+
+    # Dir.each_child returns an Enumerator, which has no #intersect? —
+    # Style/ArrayIntersect's autocorrect would produce a NoMethodError here.
+    def evidence?(dir, markers)
+      Dir.each_child(dir).any? { |entry| markers.include?(entry) } # rubocop:disable Style/ArrayIntersect
+    rescue SystemCallError
+      false
+    end
+
+    # Per-mutant scratch trees hold one entry per mutant (or baseline);
+    # checked lazily — these directories can contain tens of thousands of
+    # files, so never materialize the full listing.
+    def per_mutant_evidence?(dir)
+      Dir.each_child(dir).any? { |entry| entry.start_with?("mutant-", "baseline") }
+    rescue SystemCallError
+      false
+    end
+  end
+end

data/lib/henitai/incremental_filter.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "verdict_fingerprint"
+
+module Henitai
+  # Marks mutants whose verdict from a prior run is still valid so
+  # `--incremental` runs skip re-executing them (Gate 3.5, opt-in).
+  #
+  # Reuse rules (conservative — any doubt resolves to re-execution):
+  #
+  #   * Killed: the stored verdict must carry both fingerprints, and both the
+  #     subject's source and every recorded covering test file must be
+  #     byte-identical to what was recorded. Killed is monotone, so no live
+  #     coverage is needed.
+  #   * Survived: additionally the LIVE covering set (the full-map
+  #     intersection computed via {PerTestCoverage}) must equal the recorded
+  #     set in membership, and the run-level dependency fingerprint must be
+  #     unchanged — a new or edited test reaching the mutant always forces a
+  #     re-run (ADR-11). Without a live per-test map or dependency
+  #     fingerprint, survivors always re-execute.
+  #
+  # Timeouts, errors, unknown ids and legacy rows always re-execute.
+  class IncrementalFilter
+    def initialize(history_store:, per_test_coverage: nil, dependency_fingerprint: nil)
+      @history_store = history_store
+      @per_test_coverage = per_test_coverage
+      @dependency_fingerprint = dependency_fingerprint
+    end
+
+    # @return [Array<Mutant>] the same collection; cache hits get the stored
+    #   status (:killed or :survived) and from_cache = true.
+    def apply(mutants)
+      collection = Array(mutants)
+      ambiguous = ambiguous_stable_ids(collection)
+      collection.each do |mutant|
+        next unless mutant.pending?
+        next if ambiguous.include?(mutant.stable_id)
+
+        status = reusable_status(mutant)
+        next unless status
+
+        mutant.status = status
+        mutant.from_cache = true if mutant.respond_to?(:from_cache=)
+      end
+
+      mutants
+    end
+
+    private
+
+    attr_reader :history_store, :per_test_coverage, :dependency_fingerprint
+
+    # MutantIdentity deliberately omits source coordinates (line-drift
+    # tolerance), so distinct mutants inside one subject can share a stable
+    # id. A shared id makes the stored verdict ambiguous — one colliding
+    # mutant may have been killed while another errored — so reuse is skipped
+    # for every mutant whose id appears more than once in this run.
+    def ambiguous_stable_ids(mutants)
+      mutants.group_by(&:stable_id).filter_map do |stable_id, group|
+        stable_id if group.size > 1
+      end.to_set
+    end
+
+    def reusable_status(mutant)
+      verdict = history_store.verdict_for(mutant.stable_id)
+      return nil unless verdict
+
+      case verdict.fetch(:status)
+      when :killed
+        :killed if killed_reusable?(mutant, verdict)
+      when :survived
+        :survived if survived_reusable?(mutant, verdict)
+      end
+    end
+
+    def killed_reusable?(mutant, verdict)
+      subject_source_unchanged?(mutant, verdict) &&
+        VerdictFingerprint.tests_fingerprint_current?(verdict.fetch(:covered_tests_fingerprint))
+    end
+
+    # The filter checks per-test map availability itself instead of trusting
+    # the bootstrap's readiness skip: integrations without per-test support
+    # or a missing/empty map mean the live covering set is unknowable, and
+    # unknowable means re-execute.
+    def survived_reusable?(mutant, verdict)
+      return false unless per_test_coverage&.available?
+      return false unless subject_source_unchanged?(mutant, verdict)
+
+      VerdictFingerprint.survivor_fingerprint_current?(
+        verdict.fetch(:covered_tests_fingerprint),
+        live_paths: per_test_coverage.tests_covering(mutant),
+        dependency_sha: dependency_fingerprint
+      )
+    end
+
+    def subject_source_unchanged?(mutant, verdict)
+      VerdictFingerprint.subject_source_hash(mutant) == verdict.fetch(:subject_source_hash)
+    end
+  end
+end

data/lib/henitai/integration/child_debug_support.rb

@@ -10,7 +10,11 @@ module Henitai
 
       def debug_child? = ENV["HENITAI_DEBUG_CHILD"] == "1"
 
+      # Gated here (not only at call sites) so no unguarded caller can leak
+      # debug lines into every child log by default.
       def debug_child_puts(message)
+        return unless debug_child?
+
         $stdout.puts(message)
         $stdout.flush
       end
@@ -79,7 +83,7 @@ module Henitai
 
       def debug_child_activation_check
         location = begin
-          Henitai::Runner.instance_method(:resolve_subjects).source_location&.join(":")
+          Henitai::Runner.instance_method(:resolve_subjects).source_location&.join(":") # henitai:disable
         rescue StandardError
           nil
         end
@@ -105,7 +109,7 @@ module Henitai
       end
 
       def rspec_world_example_count # steep:ignore Ruby::UndeclaredMethodDefinition
-        world = ::RSpec.__send__(:world)
+        world = ::RSpec.world
         world.example_count
       rescue StandardError
         nil

data/lib/henitai/integration/coverage_suppression.rb

@@ -18,7 +18,15 @@ module Henitai
     # mutant child runs. Coverage artifacts are only required during the
     # dedicated bootstrap phase.
     module CoverageRuntimeSuppressors
+      # True once coverage startup has been suppressed in this process —
+      # consumers (e.g. PerTestCoverageCollector) can then treat missing
+      # coverage as expected instead of warning about it.
+      def self.active? = @active ? true : false
+
+      def self.activate! = @active = true
+
       def self.suppress_simplecov!
+        activate!
         require "simplecov"
         sc = Object.const_get(:SimpleCov) # steep:ignore Ruby::UnknownConstant
         sc.external_at_exit = true if sc.respond_to?(:external_at_exit=)
@@ -30,6 +38,7 @@ module Henitai
       end
 
       def self.suppress_coverage!
+        activate!
         require "coverage"
         cov = Object.const_get(:Coverage) # steep:ignore Ruby::UnknownConstant
         return if cov.singleton_class.ancestors.include?(CoverageStartSuppressor)