mutineer 1.3.0 → 1.5.0

data/lib/mutineer/config.rb

@@ -8,18 +8,68 @@ module Mutineer
   # never kill the host process. The CLI rescues this and maps it to exit 2.
   class ConfigError < StandardError; end
 
+  # One row of the option schema: how a Config field is parsed and where the
+  # user can set it. `yaml_key` is nil for CLI-only options; `flag` is nil for
+  # YAML-only ones. `values`/`aliases` apply to the :enum type.
+  #
+  # @api private
+  ConfigOption = Struct.new(:field, :type, :yaml_key, :flag, :values, :aliases, keyword_init: true)
+
+  # Deprecated internal strategy names, mapped to their canonical equivalents.
+  STRATEGY_ALIASES = { "7a" => "reload", "7b" => "redefine" }.freeze
+
+  # The option schema. Config.parse is the only place that turns a raw value
+  # (a CLI string or a YAML scalar) into a typed one, so a value is checked once,
+  # at the boundary, whichever layer wrote it. Row order fixes the order of
+  # KNOWN_KEYS in warnings.
+  #
+  # @api private
+  CONFIG_OPTIONS = [
+    ConfigOption.new(field: :operators, type: :string_list, yaml_key: "operators", flag: "--operators"),
+    ConfigOption.new(field: :jobs, type: :positive_int, yaml_key: "jobs", flag: "--jobs"),
+    ConfigOption.new(field: :threshold, type: :percent, yaml_key: "threshold", flag: "--threshold"),
+    ConfigOption.new(field: :only, type: :string, yaml_key: "only", flag: "--only"),
+    ConfigOption.new(field: :require_paths, type: :string_list, yaml_key: "require"),
+    ConfigOption.new(field: :boot, type: :string, yaml_key: "boot", flag: "--boot"),
+    ConfigOption.new(field: :rails, type: :bool, yaml_key: "rails", flag: "--rails"),
+    ConfigOption.new(field: :since, type: :since, yaml_key: "since", flag: "--since"),
+    ConfigOption.new(field: :framework, type: :enum, yaml_key: "framework", flag: "--framework",
+                     values: %w[minitest rspec]),
+    ConfigOption.new(field: :verbose, type: :bool, yaml_key: "verbose", flag: "--verbose"),
+    ConfigOption.new(field: :ignore, type: :string_list, yaml_key: "ignore"),
+    ConfigOption.new(field: :baseline, type: :string, yaml_key: "baseline", flag: "--baseline"),
+    ConfigOption.new(field: :fail_fast, type: :bool, yaml_key: "fail_fast", flag: "--fail-fast"),
+    ConfigOption.new(field: :matrix, type: :bool, yaml_key: "matrix", flag: "--matrix"),
+    ConfigOption.new(field: :test_command, type: :string, yaml_key: "test_command", flag: "--test-command"),
+    ConfigOption.new(field: :daemon, type: :bool, yaml_key: "daemon", flag: "--daemon"),
+    ConfigOption.new(field: :timeout, type: :positive_int, yaml_key: "timeout", flag: "--timeout"),
+    ConfigOption.new(field: :capture_timeout, type: :positive_int, yaml_key: "capture_timeout",
+                     flag: "--capture-timeout"),
+    ConfigOption.new(field: :cache_dir, type: :string, yaml_key: "cache_dir", flag: "--cache-dir"),
+    ConfigOption.new(field: :format, type: :enum, flag: "--format", values: %w[human json html]),
+    ConfigOption.new(field: :strategy, type: :enum, flag: "--strategy", values: %w[reload redefine],
+                     aliases: STRATEGY_ALIASES),
+    ConfigOption.new(field: :output, type: :string, flag: "--output"),
+    ConfigOption.new(field: :baseline_epsilon, type: :nonneg_float, flag: "--baseline-epsilon"),
+    ConfigOption.new(field: :dry_run, type: :bool, flag: "--dry-run")
+  ].freeze
+
   # Plain run configuration, populated by the CLI (or directly by the
   # integration test). `operators` nil means "all default operators";
   # `threshold` 0.0 means the CI gate is off (spec §10).
   #
   # Also holds: jobs (parallel workers), format (human|json), output (report
   # file), strategy (reload|redefine), require_paths (extra files to load).
-  # Config loading and the CLI > file > default precedence merge live here.
+  # Config loading and the CLI > file > default precedence merge live here; each
+  # layer holds only the keys the user wrote, and Config#explicit? reports them.
+  #
+  # `matrix` (--matrix) runs every covering test for each mutant and reports
+  # which tests kill it (see KillMatrix); it never changes a verdict.
   #
   # Boot mode adds: boot (a file to require ONCE in the parent so the app env,
   # e.g. Rails, is booted before forking; sources are then NOT manually required)
-  # and rails (sugar: defaults boot to config/environment and strategy to redefine,
-  # and reconnects ActiveRecord per fork).
+  # and rails (sugar: defaults boot to config/environment, prefers redefine without
+  # a daemon, and reconnects ActiveRecord per fork).
   Config = Struct.new(
     :sources, :tests, :operators, :threshold, :only, :dry_run,
     :cache_dir, :project_root, :load_paths,
@@ -28,16 +78,23 @@ module Mutineer
     # :daemon is user-facing (--daemon flag + KNOWN_KEYS + boolean coerce).
     # :daemon_timeout stays programmatic (set by tests/Runner; no flag yet).
     :baseline, :baseline_epsilon, :fail_fast, :test_command,
-    :daemon, :daemon_timeout,
+    :daemon, :daemon_timeout, :timeout, :capture_timeout, :matrix,
     keyword_init: true
   ) do
     # Config file name.
     CONFIG_FILE = ".mutineer.yml"
-    # Keys accepted in .mutineer.yml. `require` maps to the :require_paths field.
-    KNOWN_KEYS = %w[operators jobs threshold only require boot rails since framework verbose ignore baseline fail_fast test_command daemon].freeze
+    # Keys accepted in .mutineer.yml, derived from the schema. `require` maps to the
+    # :require_paths field.
+    KNOWN_KEYS = CONFIG_OPTIONS.filter_map(&:yaml_key).freeze
 
-    def initialize(**kwargs)
-      super
+    # @param explicit [Array<Symbol>] fields the user wrote (CLI or file). Derived
+    #   values fill only the others; a programmatic Config.new writes none.
+    # @param from_file [Array<Symbol>] the explicit fields whose value came from
+    #   the config file (the command line did not override them).
+    def initialize(explicit: [], from_file: [], **kwargs)
+      super(**kwargs)
+      @explicit = explicit.to_a.dup.freeze
+      @from_file = from_file.to_a.dup.freeze
       self.sources       ||= []
       self.tests         ||= []
       self.threshold     ||= 0.0
@@ -55,6 +112,29 @@ module Mutineer
       self.baseline_epsilon ||= 0.0
       self.fail_fast     = false if fail_fast.nil?
       self.daemon        = false if daemon.nil?
+      self.matrix        = false if matrix.nil?
+    end
+
+    # True when the user wrote `key`, on the command line or in the config
+    # file, whatever the value (`false` and `nil` count). The answer comes from
+    # which keys the layers held, so a new option needs no bookkeeping to be
+    # covered.
+    #
+    # @param key [Symbol] Config field name.
+    # @return [Boolean]
+    def explicit?(key)
+      @explicit.include?(key)
+    end
+
+    # Where the user set `key`, for messages: the config-file key (as
+    # `name in .mutineer.yml`) when its value came from the file, else the
+    # command-line flag.
+    #
+    # @param key [Symbol] Config field name (a row of the option schema).
+    # @return [String] e.g. `"--fail-fast"` or `"fail_fast in .mutineer.yml"`.
+    def origin(key)
+      opt = CONFIG_OPTIONS.find { |o| o.field == key } or raise ArgumentError, "unknown option #{key.inspect}"
+      @from_file.include?(key) && opt.yaml_key ? "#{opt.yaml_key} in #{CONFIG_FILE}" : (opt.flag || opt.yaml_key)
     end
 
     # Walk from `start` toward `home`, returning the first .mutineer.yml path found
@@ -77,10 +157,18 @@ module Mutineer
     end
 
     # Parse a .mutineer.yml into a symbol-keyed hash of recognized keys. Unknown
-    # keys / unknown operator names emit a one-line stderr warning and are ignored.
-    # A YAML syntax error raises ConfigError: never a silent fallback to defaults,
-    # and never an exit from the lib layer.
-    def self.from_file(path)
+    # keys emit a one-line stderr warning and are ignored. Unknown operator names
+    # warn and are dropped. If that leaves no names, the file is an error: an
+    # empty operator list would run nothing and exit 0. Pass
+    # +defer_operators: true+ only when the command line replaces that list, so
+    # a blank or all-unknown file list does not block +--operators+. A YAML
+    # syntax error raises ConfigError: never a silent fallback to defaults, and
+    # never an exit from the lib layer.
+    #
+    # @param path [String] config file path.
+    # @param defer_operators [Boolean] keep an empty operator list for a CLI override.
+    # @return [Hash{Symbol => Object}]
+    def self.from_file(path, defer_operators: false)
       raw = YAML.safe_load(File.read(path)) || {}
       name = File.basename(path)
       unless raw.is_a?(Hash)
@@ -96,28 +184,39 @@ module Mutineer
                "(known: #{KNOWN_KEYS.join(', ')}); ignored"
           next
         end
-        out[field_for(ks)] = coerce(ks, value, name)
+        field = field_for(ks)
+        parsed = parse(field, value, file: name, defer_operators: defer_operators)
+        if field == :operators
+          parsed = filter_operators(parsed, name)
+          if parsed.empty? && !defer_operators
+            raise ConfigError, "#{name}: operators must name at least one known operator"
+          end
+        end
+        out[field] = parsed
       end
       out
     rescue Psych::SyntaxError => e
       raise ConfigError, "#{File.basename(path)} parse error: #{e.message}"
     end
 
-    # Apply precedence: start from the CLI-provided values, then fill in a
-    # config-file value only for keys the user did NOT type on the command line.
-    # `explicit` is a Set of field symbols the CLI saw with a value; a Set (not
-    # nil-sentinels) is used because some valid values are zero/false.
-    def self.resolve(cli_opts, file_hash, explicit)
-      merged = cli_opts.dup
-      file_hash.each { |k, v| merged[k] = v unless explicit.include?(k) }
-      config = new(**merged)
+    # Merges the two user layers, CLI over file, then derives what neither wrote.
+    # A layer is a Hash of only the keys the user set, so precedence is `merge`
+    # and "did the user write this" is whether the key exists. Nothing tracks
+    # provenance by hand, and `false`/`nil` are ordinary values.
+    #
+    # @param cli_opts [Hash{Symbol => Object}] parsed command-line fields.
+    # @param file_hash [Hash{Symbol => Object}] parsed .mutineer.yml fields.
+    # @return [Mutineer::Config]
+    def self.resolve(cli_opts, file_hash)
+      user = file_hash.merge(cli_opts)
+      config = new(**user, explicit: user.keys, from_file: file_hash.keys - cli_opts.keys)
 
       # --rails sugar: boot config/environment. Prefer redefine only for the
       # in-process path (daemon is whole-file reload only). In-process --rails
       # shares one test database, so force serial unless --daemon.
       if config.rails
         config.boot ||= "config/environment"
-        unless config.daemon || explicit.include?(:strategy)
+        unless config.daemon || config.explicit?(:strategy)
           config.strategy = "redefine"
         end
         unless config.daemon
@@ -129,9 +228,9 @@ module Mutineer
         end
       end
 
-      # Auto-detect the framework only when neither CLI nor config file set it
-      # (explicit value, from either source, is already on config.framework and
-      # always wins). Default minitest unless the test files clearly look RSpec.
+      # Auto-detect the framework only when the user wrote none: a value from
+      # either layer is already on config.framework and always wins. Default
+      # minitest unless the test files clearly look RSpec.
       config.framework ||= detect_framework(config.tests)
       config
     end
@@ -155,42 +254,102 @@ module Mutineer
       known_key == "require" ? :require_paths : known_key.to_sym
     end
 
-    # Coerces a config value to its target type.
+    # Parses one raw value into the typed value for `field`. A value that does
+    # not fit its type raises ConfigError naming where it came from, so the CLI
+    # and .mutineer.yml report the same mistake in the same way. `nil` and
+    # `false` are valid results for some fields (`since: false` means "no scoping").
     #
-    # @param known_key [String] config key.
-    # @param value [Object] raw YAML value.
-    # @param file_name [String] config file name for warnings.
-    # @return [Object] coerced value.
-    def self.coerce(known_key, value, file_name)
-      case known_key
-      when "operators" then filter_operators(Array(value).map(&:to_s), file_name)
-      when "jobs"      then value.to_i
-      when "threshold"
-        f = Float(value, exception: false)
-        if f.nil?
-          raise ConfigError, "#{file_name}: threshold must be a number between 0 and 100 " \
-                             "(got: #{value.inspect})"
-        end
+    # @param field [Symbol] Config field name (a row of the option schema).
+    # @param value [Object] raw CLI string or YAML value.
+    # @param file [String, nil] config file name when the value came from it;
+    #   nil when it came from the command line.
+    # @param defer_operators [Boolean] when true, a blank operator list is
+    #   returned instead of raising, so +--operators+ can replace it. The flag
+    #   itself still rejects a blank list.
+    # @return [Object] the typed value.
+    # @raise [Mutineer::ConfigError] when the value does not fit the field's type.
+    def self.parse(field, value, file: nil, defer_operators: false)
+      opt = CONFIG_OPTIONS.find { |o| o.field == field } or raise ArgumentError, "unknown option #{field.inspect}"
+      origin = file ? "#{file}: #{opt.yaml_key}" : opt.flag
+      got = "(got: #{value.inspect})"
+      case opt.type
+      when :positive_int
+        n = value.is_a?(Integer) ? value : (value.to_i if value.is_a?(String) && value.match?(/\A\d+\z/))
+        raise ConfigError, "#{origin} must be a positive integer, digits only #{got}" if n.nil? || n < 1
+
+        n
+      when :percent
+        f = finite_float(value)
+        raise ConfigError, "#{origin} must be a number between 0 and 100 #{got}" unless f && (0.0..100.0).cover?(f)
+
         f
-      when "require"   then Array(value).map(&:to_s)
-      when "boot"      then value.to_s
-      when "framework" then value.to_s
-      when "rails"     then value == true || value.to_s == "true"
-      when "daemon"    then value == true || value.to_s == "true"
-      when "verbose"   then value == true || value.to_s == "true"
-      when "fail_fast" then value == true || value.to_s == "true"
-      when "ignore"    then Array(value).map(&:to_s)
-      when "baseline"  then value.to_s
-      when "test_command" then value.to_s
-      when "since"
-        # false / empty normalize to nil ("no scoping"), so every consumer's
-        # nil-check (runner scoping, the report's scoped marker) agrees. A
-        # false left raw would skip scoping but still mark the report scoped.
-        value == false || value.to_s.empty? ? nil : value.to_s
-      else value
+      when :nonneg_float
+        f = finite_float(value)
+        raise ConfigError, "#{origin} must be a finite number, 0 or greater #{got}" unless f && f >= 0.0
+
+        f
+      when :bool
+        return value if [true, false].include?(value)
+        return value == "true" if %w[true false].include?(value)
+
+        raise ConfigError, "#{origin} must be true or false #{got}"
+      when :enum
+        name = opt.aliases&.fetch(value, nil) || value
+        return name if opt.values.include?(name)
+
+        prefix = file ? "#{file}: " : ""
+        raise ConfigError, "#{prefix}unknown #{field} #{value.to_s.inspect}. Expected: #{opt.values.join(', ')}"
+      when :string_list
+        items = Array(value).map(&:to_s)
+        # Only `operators` treats [] as "run these" rather than "use the
+        # default". A blank key then makes no mutants and exits 0. An empty
+        # `require` or `ignore` matches the default, so those stay valid.
+        if field == :operators && !defer_operators && ([nil, true, false].include?(value) || items.empty? || items.all? { |item| item.strip.empty? })
+          raise ConfigError, "#{origin} must name at least one operator, not blank #{got}"
+        end
+
+        items
+      when :string
+        # A key written with no value (`baseline:`) parses as nil. Keeping nil
+        # would switch the feature off without a word; main failed here, so the
+        # typo stays loud. An absent key never reaches parse, so it stays unset.
+        # `only: false` must not become the subject name "false" either: it
+        # matches nothing, so the run has no mutants and still exits 0.
+        raise ConfigError, "#{origin} must be a string #{got}" if [nil, true, false].include?(value)
+        # A blank cache directory (an unset CI variable) would put coverage.json
+        # in the project root, so it is an error, not the default.
+        raise ConfigError, "#{origin} must be a directory, not blank #{got}" if field == :cache_dir && value.to_s.strip.empty?
+
+        value.to_s
+      when :since
+        # `false` is the one way to say "no scoping" in the file. It becomes nil
+        # so every consumer's nil-check (runner scoping, the report's scoped
+        # marker) agrees; a false left raw would skip scoping but still mark
+        # the report scoped. A blank value is an error, not "no scoping": a
+        # `since: "$REF"` whose variable is unset must not turn scoping off.
+        return nil if value == false
+        raise ConfigError, "#{origin} must be a git ref, not blank #{got}" if value.to_s.strip.empty?
+
+        value.to_s
       end
     end
 
+    # Reads a finite Float from a number or a plain decimal string. Rejects booleans,
+    # NaN and Infinity: `Float(true)` is an error, but a YAML `.nan` is a Float.
+    # A string must be digits with an optional fraction, the same digits-only rule
+    # as `jobs`: `Float()` alone would also read `0x10`, `1_0`, `+2` and `1e2`.
+    #
+    # @api private
+    # @param value [Object] raw value.
+    # @return [Float, nil] the number, or nil when it is not a finite number.
+    def self.finite_float(value)
+      f = case value
+          when Integer, Float then value.to_f
+          when String then Float(value) if value.match?(/\A\d+(\.\d+)?\z/)
+          end
+      f if f&.finite?
+    end
+
     # Drop (with a warning) operator names the registry does not know.
     # Referenced lazily so config.rb carries no load-order dependency on the
     # registry; by the time a config is parsed at runtime, it is loaded.

data/lib/mutineer/coverage_map.rb

@@ -10,6 +10,7 @@ require_relative "minitest_integration"
 require_relative "test_runners"
 require_relative "child_stdout"
 require_relative "project_path"
+require_relative "pairing"
 
 module Mutineer
   # Maps `(source_file, line) -> [test_files]` so each mutant runs only against
@@ -98,8 +99,11 @@ module Mutineer
     # rather than a genuine coverage gap? True iff some capture failed this run
     # AND this file got zero coverage from any successful capture AND a failed
     # test file maps to it by the _test/_spec/test_ naming convention. Derived
-    # purely from already-persisted state (@map keys + @failed_test_files); no
-    # rerun, no new cached field, no digest change.
+    # from already-persisted state (@map keys + @failed_test_files). A split
+    # name checks the longer source files that existed when that check first
+    # ran for this map. Adding or deleting one of those files changes the
+    # coverage digest, so the next run captures again instead of retargeting
+    # a stored failure.
     #
     # File-level, convention-based attribution. A line covered only by a failed
     # test in an otherwise-covered file stays no_coverage (condition 2), and a
@@ -112,7 +116,7 @@ module Mutineer
       rel = relativize(absolute(file))
       return false if covered_source_files.include?(rel)
 
-      failed_test_targets.include?(File.basename(rel, ".rb"))
+      failed_test_blames?(rel)
     end
 
     # Per-method taint. A mutant on a line whose enclosing method got zero
@@ -131,7 +135,7 @@ module Mutineer
       return false if @failed_test_files.empty?
 
       rel = relativize(absolute(file))
-      return false unless failed_test_targets.include?(File.basename(rel, ".rb"))
+      return false unless failed_test_blames?(rel)
 
       line_range.none? { |ln| @map.key?("#{rel}:#{ln}") }
     end
@@ -143,17 +147,119 @@ module Mutineer
       @map.keys.map { |k| k.rpartition(":").first }.to_set
     end
 
-    # Basenames of the sources that failed test files pair with by convention:
-    # a trailing _test/_spec is stripped first, as pairing tries that form first.
-    def failed_test_targets
-      @failed_test_files.map do |t|
-        name = File.basename(t, ".rb")
-        case name
-        when /_(test|spec)\z/ then name.sub(/_(test|spec)\z/, "")
-        when "test_helper" then name # Minitest's support file pairs with no source
-        else name.delete_prefix("test_")
+    # True when a failed test file pairs with `source_rel` by convention.
+    # Exact `_test` / `_spec` / `test_` names match by basename, as before.
+    # A split `<name>_*_test.rb` matches only in the mirrored test directory,
+    # and only when no longer source file owns that name (#87). The answer
+    # is kept for this map, so a later delete does not move the failure.
+    #
+    # @param source_rel [String] project-relative source path.
+    # @return [Boolean]
+    def failed_test_blames?(source_rel)
+      @blame_for ||= {}
+      return @blame_for[source_rel] if @blame_for.key?(source_rel)
+
+      @blame_for[source_rel] = exact_failed_test?(source_rel) || split_failed_test?(source_rel)
+    end
+
+    # True when a failed exact `_test` / `_spec` / `test_` file pairs with
+    # this source. An `app/` or `lib/` source only accepts a `test/` or
+    # `spec/` file from its mirrored directory, so
+    # `test/foo/bar_upsert_test.rb` does not taint `app/other/bar_upsert.rb`.
+    # Any other source still matches by basename. A fixture under
+    # `test/fixtures/` and an explicit test both name their source that way.
+    #
+    # @param source_rel [String] project-relative source path.
+    # @return [Boolean]
+    def exact_failed_test?(source_rel)
+      name = File.basename(source_rel, ".rb")
+      base, lib = Pairing.logical_path(source_rel)
+      @failed_test_files.any? do |test_path|
+        next false unless failed_test_target_name(test_path) == name
+
+        rel = relativize(test_path)
+        dir = File.dirname(rel)
+        if app_or_lib_source?(source_rel) && conventional_test_dir?(dir)
+          mirrored_test_dir?(rel, base, lib) || spec_mirror?(rel, base, lib)
+        else
+          true
         end
-      end.to_set
+      end
+    end
+
+    # True when pairing gives this source a mirrored test directory.
+    #
+    # @param source_rel [String] project-relative source path.
+    # @return [Boolean]
+    def app_or_lib_source?(source_rel)
+      source_rel.start_with?("app/", "lib/")
+    end
+
+    # Basename a failed test file would pair with, before the directory check.
+    #
+    # @param test_path [String]
+    # @return [String]
+    def failed_test_target_name(test_path)
+      name = File.basename(test_path, ".rb")
+      case name
+      when /_(test|spec)\z/ then name.sub(/_(test|spec)\z/, "")
+      when "test_helper" then name
+      else name.delete_prefix("test_")
+      end
+    end
+
+    # True when `dir` is `test`, `spec`, or a directory under one of them.
+    #
+    # @param dir [String] project-relative directory.
+    # @return [Boolean]
+    def conventional_test_dir?(dir)
+      dir == "test" || dir == "spec" || dir.start_with?("test/", "spec/")
+    end
+
+    # True when a failed split test file pairs with this source. Directory and
+    # the longer-source check match {Pairing}, so a test outside the mirror, or
+    # one owned by `user_session.rb`, does not taint `user.rb`.
+    #
+    # @param source_rel [String] project-relative source path.
+    # @return [Boolean]
+    def split_failed_test?(source_rel)
+      base, lib = Pairing.logical_path(source_rel)
+      name = File.basename(base)
+      @failed_test_files.any? do |t|
+        test_rel = relativize(t)
+        entry = File.basename(test_rel)
+        next false unless Pairing.split_entry?(entry, name)
+        next false unless mirrored_test_dir?(test_rel, base, lib)
+        next false if Pairing.claimed_by_longer_source?(@project_root, base, entry, File.dirname(test_rel))
+
+        true
+      end
+    end
+
+    # True when `test_rel` sits in a mirrored test directory for `base`.
+    #
+    # @param test_rel [String] project-relative test path.
+    # @param base [String] logical source path without extension.
+    # @param lib [Boolean] whether the source originated from lib/.
+    # @return [Boolean]
+    def mirrored_test_dir?(test_rel, base, lib)
+      dirs = [Pairing.mirror_dir("test", base)]
+      dirs << Pairing.mirror_dir("test/lib", base) if lib
+      dirs.include?(File.dirname(test_rel))
+    end
+
+    # True when `test_rel` sits in a mirrored spec directory for `base`.
+    # Split Minitest names stay in {#mirrored_test_dir?}. An exact `_spec`
+    # file uses this directory.
+    #
+    # @param test_rel [String] project-relative test path.
+    # @param base [String] logical source path without extension.
+    # @param lib [Boolean] whether the source originated from lib/.
+    # @return [Boolean]
+    def spec_mirror?(test_rel, base, lib)
+      dirs = [Pairing.mirror_dir("spec", base)]
+      dirs << Pairing.mirror_dir("spec/lib", base) if lib
+      dirs.include?(File.dirname(test_rel))
     end
 
     # Shared cache dance for both build paths: hit the digest-keyed cache, else
@@ -809,11 +915,52 @@ module Mutineer
       digest_group(d, "source", @source_paths)
       digest_group(d, "test", @test_paths)
       digest_group(d, "boot", [boot_digest_path]) if @boot_path
+      ownership_paths.each do |rel|
+        d.update("owner\0")
+        d.update(rel)
+        d.update("\0")
+      end
       @load_paths.sort.each { |lp| d.update("loadpath\0#{lp}\0") }
       d.update("framework\0#{@framework}\0")
       d.hexdigest
     end
 
+    # Longer source files that can take a split test from a configured source.
+    # Only their presence is digested. A content edit of a sibling does not
+    # change pairing, and it does not rebuild coverage. Each directory is
+    # listed once, even when many sources share it.
+    #
+    # @return [Array<String>] project-relative paths, sorted.
+    def ownership_paths
+      root = File.expand_path(@project_root)
+      listings = {}
+      paths = @source_paths.flat_map do |source|
+        rel = relativize(absolute(source))
+        next [] if rel.start_with?("/")
+
+        base, = Pairing.logical_path(rel)
+        name = File.basename(base)
+        dir = File.dirname(base)
+        folders = [dir == "." ? nil : dir]
+        %w[app lib].each { |prefix| folders << (dir == "." ? prefix : File.join(prefix, dir)) }
+        folders.uniq.flat_map do |folder|
+          abs = folder ? File.join(root, folder) : root
+          entries = listings.fetch(abs) do
+            listings[abs] = File.directory?(abs) ? Dir.children(abs) : []
+          end
+          entries.filter_map do |entry|
+            next unless entry.end_with?(".rb")
+
+            stem = entry.delete_suffix(".rb")
+            next unless stem.start_with?("#{name}_") && stem.length > name.length
+
+            folder ? File.join(folder, entry) : entry
+          end
+        end
+      end
+      paths.uniq.sort
+    end
+
     # boot_path is a require-style path (e.g. "config/environment", no extension);
     # resolve it to the real file for reading, appending ".rb" when needed.
     def boot_digest_path

data/lib/mutineer/daemon_backend.rb

@@ -279,6 +279,7 @@ module Mutineer
         project_root: config.project_root,
         boot: File.expand_path(config.boot || "config/environment", config.project_root),
         load_paths: Runner.test_load_roots(abs_tests),
+        cache_dir: File.expand_path(config.cache_dir, config.project_root),
         source_dirs: Runner.source_dirs(config), # so the daemon can sweep orphan mutant temps
         framework: config.framework,
         rails: config.rails,
@@ -290,6 +291,8 @@ module Mutineer
         # instrumentation/memory across every mutant fork). `sources`/`tests` are the
         # map-build inputs.
         coverage: coverage,
+        # The map-building daemon's capture limit (--capture-timeout); nil = default.
+        capture_timeout: config.capture_timeout,
         sources: config.sources.map { |s| File.expand_path(s, config.project_root) },
         tests: abs_tests
       }