mutineer 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b549b3640aa316aa715732f4e91f3be669b7ab8e7ad877b8207d0e31ac12b4aa
-  data.tar.gz: a626241007cf47b4fb0ef3c68dc1fba7f0c8679d0c41db516dca888893fc5f51
+  metadata.gz: ae2c0b5167b5070a3afc7834ffa6d4d012267b070dd6b73f3d95affa3752c4c0
+  data.tar.gz: 22a328c5b5446d8c937288763d5ab050869b49b58c0bee715c3ec9dbb54005fd
 SHA512:
-  metadata.gz: ba4d45a6ba52ead7da7f580452eb610bfc23b368501c496e80ffa56e2e364a62fcf896a1e9d37c50b1216727eb8a6a02386ba0917c85397ac61a3f2a9f41d694
-  data.tar.gz: 6be383459b367be9b72135b1672d57c63bd4e4a6c032c3301532f50a1bcb96dff2cc6ecf764979d6009fab9e4c1e4d327fbb1e81cf3652232cb38a2eb6a82558
+  metadata.gz: 858c634ce049e4a55ee2c94151a11df0b620edb19630d53719bf94cf6efa9212a4bd6d55c67607a1447ff42fed7804293ae3ec8c28b703b6478f2324aa5593b9
+  data.tar.gz: 2c47217873142ba8dbdffe1adbeb3772532925a951a2d52f058ca4b5e26732877019299de6a98c5c68ad89a5d9c6f8513b06ac424806fe7258e4ef1a7e305a27

data/CHANGELOG.md

@@ -4,6 +4,35 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/), and this project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## [0.7.0] - 2026-06-30
+
+Rails hardening + CI batch (issues #8–#13), all verified Rails-free.
+
+### Added
+- **Equivalent-mutant suppression** (#10) — inline `# mutineer:disable-line [ops]`
+  and a `.mutineer.yml` `ignore:` list keyed on a stable, offset-free mutant id;
+  suppressed mutants are excluded from the score (100% reachable). The stable id
+  (and readable token) is emitted per survivor in JSON.
+- **Source→test auto-pairing + multi-source runs** (#11) — pass a directory or
+  several sources with `--test` omitted; tests are inferred by convention
+  (`app/`,`lib/` → `test/…_test.rb` / `spec/…_spec.rb`) and run under one boot,
+  with per-source results (human + JSON `per_source`).
+- **`--baseline <file.json>` CI gating** (#13) — diff against a prior run by stable
+  id; exit 1 on new survivors or a score drop (with `--baseline-epsilon`), naming
+  what regressed. Combines with `--threshold` via max exit code.
+- **`--verbose`/`--debug`** (#8) — surface the real error when a fork capture fails.
+- **`:uncapturable` status** (#9) — distinct from `no_coverage`; reported separately
+  ("tests failed to run" vs "genuinely uncovered"). Both excluded from the score.
+
+### Fixed
+- **Fork capture no longer drops fixture transactions** (#8) — `reconnect` skips
+  `clear_all_connections!` when a fixture transaction is open, and stops swallowing
+  the child error; write-heavy Rails tests are mutation-testable again.
+
+### Changed
+- JSON `schema_version` → `1.1` (additive: survivor `id`/`token`, `ignored`,
+  `uncapturable`, `per_source`).
+
 ## [0.6.2] - 2026-06-29
 
 ### Fixed
@@ -100,6 +129,7 @@ All notable changes to this project are documented here. The format is based on
 - `.mutineer.yml` configuration (CLI > config > default precedence).
 - Byte-correct source handling for multibyte (UTF-8) sources.
 
+[0.7.0]: https://github.com/davidteren/mutineer/releases/tag/v0.7.0
 [0.6.2]: https://github.com/davidteren/mutineer/releases/tag/v0.6.2
 [0.6.1]: https://github.com/davidteren/mutineer/releases/tag/v0.6.1
 [0.6.0]: https://github.com/davidteren/mutineer/releases/tag/v0.6.0

data/README.md

@@ -1,6 +1,6 @@
 # Mutineer
 
-[![Socket Badge](https://badge.socket.dev/rubygems/package/mutineer/0.6.2?platform=ruby)](https://socket.dev/rubygems/package/mutineer/overview/0.6.2?platform=ruby)
+[![Socket Badge](https://badge.socket.dev/rubygems/package/mutineer/0.7.0?platform=ruby)](https://socket.dev/rubygems/package/mutineer/overview/0.7.0?platform=ruby)
 
 A clean-room mutation-testing tool for Ruby. Mutineer mutates your source one
 change at a time, runs your test suite (Minitest or RSpec) against each mutant, and reports the
@@ -49,7 +49,10 @@ mutineer run lib/calculator.rb --test test/calculator_test.rb --threshold 90
 | `--only NAME` | Restrict to one fully-qualified subject, e.g. `Calculator#add` |
 | `--framework NAME` | `minitest` (default) or `rspec`; auto-detected as rspec when most `--test` files end in `_spec.rb` |
 | `--since REF` | Only mutate lines changed since git `REF` (e.g. `origin/main`) — ideal for PR CI |
-| `--jobs N` | Parallel worker count (default: processor count) |
+| `--baseline FILE` | Compare against a prior `--format json` run; exit 1 on new survivors / score drop (see [CI](#ci-gating)) |
+| `--baseline-epsilon FLOAT` | Score-drop tolerance for `--baseline` (default: 0) |
+| `--jobs N` | Parallel worker count (default: processor count; `1` under `--rails`) |
+| `--verbose` | Surface the real error when a fork capture fails (alias `--debug`) |
 | `--strategy NAME` | Mutation application: `reload` whole-file (default) or `redefine` surgical (`7a`/`7b` accepted as deprecated aliases) |
 | `--format human\|json` | Report format (default: human) |
 | `--output FILE` | Write the report to FILE instead of stdout |
@@ -96,6 +99,31 @@ Add Mutineer to your Gemfile's test group:
 gem "mutineer", group: :test, require: false
 ```
 
+## Suppressing equivalent mutants
+
+Some mutants are equivalent (behaviour-identical) and survive forever — keeping a
+file off 100%. Suppress them so the score and `--threshold` gate stay meaningful:
+
+- **Inline:** `some_line # mutineer:disable-line` (or scope it: `# mutineer:disable-line comparison`).
+- **Config:** a `.mutineer.yml` `ignore:` list of stable mutant ids. Each survivor's
+  `id` is printed in the JSON report, so copy it straight into `ignore:`.
+
+Suppressed mutants are excluded from the score (so 100% becomes reachable).
+
+## CI gating
+
+Store a JSON run as a baseline, then fail the build only when a PR makes things
+worse:
+
+```sh
+mutineer run app/ --baseline .mutineer/baseline.json   # exit 1 on NEW survivors or a score drop
+```
+
+`--baseline` reports which survivors are new (by stable id) and any score drop. It
+combines with `--threshold` (the worse of the two sets the exit code). Pass a
+directory (or several sources) to audit a whole layer in one boot — tests are
+auto-paired by convention and the report breaks down per source.
+
 ## Configuration
 
 Mutineer reads an optional `.mutineer.yml` from the project root (nearest one,

data/lib/mutineer/baseline.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "config" # for Mutineer::ConfigError
+
+module Mutineer
+  # #13: CI baseline/delta gating. A baseline is literally a prior
+  # `mutineer run --format json` document (KTD-1) — no bespoke format to version.
+  # We diff the current run against it by the #10 stable survivor id (KTD-2): a
+  # NEW survivor (id present now, absent in the baseline) OR a score drop is a
+  # regression the CLI turns into exit 1. Pure data — stdlib `json` only, no fork,
+  # no Rails — so it's testable in isolation from a canned JSON + a hand-built
+  # AggregateResult.
+  class Baseline
+    # The verdict of diffing a current run against the baseline.
+    #   new_survivors   — current Result objects whose stable id is absent from the
+    #                     baseline (the regressions to name).
+    #   fixed_survivors — baseline survivor hashes absent from the current run
+    #                     (informational, never gates).
+    #   score_drop      — current score < baseline score - epsilon. nil on either
+    #                     side skips the check (see #diff).
+    #   regressed       — any new survivors OR a score drop.
+    Delta = Data.define(:new_survivors, :fixed_survivors,
+                        :score_before, :score_after, :score_drop, :regressed)
+
+    # Load a prior --format json run. Raises ConfigError (NOT exit — R8: a data
+    # class must never kill the host) on a missing/unreadable file, unparseable
+    # JSON, or a doc that isn't a baseline shape, so the CLI maps it to exit 2
+    # (usage) like every other bad-path flag.
+    def self.load(path)
+      doc = JSON.parse(File.read(path))
+      unless doc.is_a?(Hash) && doc["schema_version"] && doc["survivors"].is_a?(Array)
+        raise ConfigError, "not a Mutineer JSON report: #{path}"
+      end
+
+      new(doc)
+    rescue JSON::ParserError => e
+      raise ConfigError, "invalid baseline JSON in #{path}: #{e.message}"
+    end
+
+    attr_reader :score
+
+    def initialize(doc)
+      @survivors = doc["survivors"] || []
+      @score = doc.dig("summary", "score")
+    end
+
+    # Diff a current AggregateResult against this baseline by stable survivor id.
+    # `epsilon` tolerates float jitter on the score (default 0.0 = any drop gates).
+    def diff(aggregate, epsilon: 0.0)
+      current = aggregate.surviving_mutants
+      current_ids = current.map(&:id)
+      baseline_ids = @survivors.map { |h| h["id"] }
+
+      new_survivors = current.reject { |r| baseline_ids.include?(r.id) }
+      fixed = @survivors.reject { |h| current_ids.include?(h["id"]) }
+
+      current_score = aggregate.mutation_score
+      # nil-score discipline (mirrors Reporter#exit_code): a score absent on either
+      # side can't be compared — skip the drop check, keep the new-survivor check.
+      score_drop = !@score.nil? && !current_score.nil? &&
+                   current_score < @score - epsilon
+
+      Delta.new(new_survivors: new_survivors, fixed_survivors: fixed,
+                score_before: @score, score_after: current_score,
+                score_drop: score_drop,
+                regressed: !new_survivors.empty? || score_drop)
+    end
+  end
+end

data/lib/mutineer/cli.rb

@@ -7,9 +7,11 @@ require_relative "version"
 require_relative "config"
 require_relative "parser"
 require_relative "project"
+require_relative "pairing"
 require_relative "changed_lines"
 require_relative "runner"
 require_relative "reporter"
+require_relative "baseline"
 require_relative "mutator_registry"
 
 module Mutineer
@@ -33,6 +35,9 @@ module Mutineer
         --test FILE          Test file covering the sources (repeatable)
         --operators LIST     Comma-separated operator names (default: Tier 1 set)
         --threshold FLOAT    Fail (exit 1) when score < FLOAT (default: 0 = off)
+        --baseline FILE      Fail (exit 1) on NEW survivors / score drop vs a prior
+                             --format json run (CI delta gate)
+        --baseline-epsilon FLOAT  Score-drop tolerance for --baseline (default: 0)
         --only NAME          Restrict to one fully-qualified subject
         --since REF          Only mutate lines changed since git REF (e.g. origin/main)
         --jobs N             Parallel worker count (default: processor count)
@@ -44,6 +49,7 @@ module Mutineer
         --format human|json  Report format (default: human)
         --output FILE        Write the report to FILE instead of stdout
         --dry-run            List mutations without executing
+        --verbose            Surface the real error when a fork capture fails (alias: --debug)
 
       Options:
         --list-operators  List available operators (default vs optional) and exit
@@ -84,8 +90,14 @@ module Mutineer
         o.on("--framework NAME") { |v| opts[:framework] = v; explicit << :framework }
         o.on("--boot FILE") { |v| opts[:boot] = v; explicit << :boot }
         o.on("--rails") { opts[:rails] = true }
+        o.on("--verbose") { opts[:verbose] = true }
+        o.on("--debug") { opts[:verbose] = true } # alias of --verbose
         o.on("--format FORMAT") { |v| opts[:format] = v }
         o.on("--output FILE") { |v| opts[:output] = v }
+        # #13: --baseline is also a .mutineer.yml key, so mark it explicit when
+        # typed (CLI wins over the file). --baseline-epsilon is CLI-only.
+        o.on("--baseline FILE") { |v| opts[:baseline] = v; explicit << :baseline }
+        o.on("--baseline-epsilon FLOAT") { |v| opts[:baseline_epsilon] = v.to_f }
       end
 
       begin
@@ -118,8 +130,10 @@ module Mutineer
 
       case argv.first
       when "run"
-        config.sources = argv[1..]
-        run(config)
+        # #11: a directory source expands to its **/*.rb files; literal files pass
+        # through. Test inference (when --test is omitted) happens in validate!.
+        config.sources = Pairing.expand_sources(argv[1..], project_root: config.project_root)
+        run(config, explicit)
       else
         warn "mutineer: unknown command '#{argv.first}'"
         exit 2
@@ -134,12 +148,12 @@ module Mutineer
       end
     end
 
-    def self.run(config)
+    def self.run(config, explicit = Set.new)
       if config.sources.empty?
         warn "mutineer: run requires at least one source file"
         exit 2
       end
-      validate!(config)
+      validate!(config, explicit)
 
       config.dry_run ? dry_run(config) : execute(config)
     rescue ArgumentError => e
@@ -163,7 +177,7 @@ module Mutineer
 
     # Flag validation: every flag/usage failure exits 2 (C7), consistent with the
     # taxonomy above — CI can tell "mistyped flag" from "tests too weak."
-    def self.validate!(config)
+    def self.validate!(config, explicit = Set.new)
       unless (0.0..100.0).cover?(config.threshold)
         warn "mutineer: --threshold must be between 0 and 100"
         exit 2
@@ -194,6 +208,17 @@ module Mutineer
         exit 2
       end
 
+      validate_since!(config) if config.since
+      preflight_output!(config.output) if config.output
+      preflight_baseline!(config.baseline) if config.baseline
+
+      # #11: when --test is omitted, infer each source's test by convention so the
+      # boot-once/fork-per-test core (which pairs empirically by coverage) gets a
+      # populated config.tests. Runs after every flag/usage check above so a
+      # mistyped flag still reports the flag; skipped under --dry-run (no tests
+      # needed). validate_paths! then sees the inferred (real) tests.
+      autopair!(config, explicit) unless config.dry_run
+
       # Boot mode does no coverage selection — every mutant runs the given tests —
       # so at least one --test file is mandatory (there is nothing to select from).
       if config.boot && config.tests.empty?
@@ -201,8 +226,6 @@ module Mutineer
         exit 2
       end
 
-      validate_since!(config) if config.since
-      preflight_output!(config.output) if config.output
       validate_paths!(config)
     end
 
@@ -238,6 +261,45 @@ module Mutineer
       exit 2
     end
 
+    # #11: auto-pair sources to tests by path convention when no --test was given
+    # (explicit --test wins — R5). Each source with an inferred test on disk joins
+    # the run; a source with none is dropped with a one-line stderr warning (R3)
+    # and the run continues with the rest. If every source is dropped: in boot mode
+    # the dedicated --boot/--rails-requires-test check reports it; otherwise exit 2
+    # with a usage message. The framework is re-detected from the inferred set
+    # unless it was set explicitly (a spec-only project loads/reports as rspec).
+    def self.autopair!(config, explicit)
+      return unless config.tests.empty?
+
+      paired = config.sources.filter_map do |s|
+        t = Pairing.infer_test(s, project_root: config.project_root, prefer: config.framework)
+        [s, t] if t
+      end
+      (config.sources - paired.map(&:first)).each do |s|
+        warn "[mutineer] no test found by convention for #{s}; skipping"
+      end
+      config.sources = paired.map(&:first)
+      config.tests   = paired.map(&:last).uniq
+      config.framework = Config.detect_framework(config.tests) unless explicit.include?(:framework)
+
+      return unless config.sources.empty?
+      return if config.boot # let the --boot/--rails-requires-test check report it
+
+      warn "mutineer: no test files found by convention; pass --test or add tests"
+      exit 2
+    end
+
+    # #13: a missing/unreadable/unparseable baseline is a usage error (exit 2),
+    # mirroring --output/--since preflight, so CI sees "bad invocation," not a
+    # backtrace mid-run. Validating up front = attempting the load (it raises
+    # ConfigError/SystemCallError; the actual diff reloads in execute).
+    def self.preflight_baseline!(path)
+      Baseline.load(path)
+    rescue Mutineer::ConfigError, SystemCallError => e
+      warn "mutineer: #{e.message}"
+      exit 2
+    end
+
     def self.preflight_output!(path)
       dir = File.dirname(File.expand_path(path))
       return if File.directory?(dir) && File.writable?(dir)
@@ -255,8 +317,14 @@ module Mutineer
 
       aggregate, source_map = Runner.execute(config)
       reporter = Reporter.new(aggregate, source_map)
+
+      # #13: diff the current run against the baseline (preflighted above) by the
+      # stable survivor id. The delta is rendered inline (human section / additive
+      # json block) and gates exit independently of --threshold.
+      delta = (Baseline.load(config.baseline).diff(aggregate, epsilon: config.baseline_epsilon) if config.baseline)
+
       reporter.report(out: $stdout, err: $stderr, threshold: config.threshold,
-                      format: config.format, output: config.output)
+                      format: config.format, output: config.output, baseline: delta)
 
       # #14: nudge toward the opt-in tier-2 operators (human report only — never
       # pollute JSON output).
@@ -264,7 +332,10 @@ module Mutineer
         puts hint
       end
 
-      exit reporter.exit_code(threshold: config.threshold)
+      # #13/KTD-4: --baseline and --threshold are independent gates OR'd together.
+      # `max` of two 0/1 codes is the OR; usage (2) is handled earlier and wins.
+      baseline_exit = delta&.regressed ? 1 : 0
+      exit [reporter.exit_code(threshold: config.threshold), baseline_exit].max
     end
 
     # The tier-2 operators not in the active set, as a one-line hint (or nil when

data/lib/mutineer/config.rb

@@ -24,12 +24,13 @@ module Mutineer
     :sources, :tests, :operators, :threshold, :only, :dry_run,
     :cache_dir, :project_root, :load_paths,
     :jobs, :format, :output, :strategy, :require_paths,
-    :boot, :rails, :since, :framework,
+    :boot, :rails, :since, :framework, :verbose, :ignore,
+    :baseline, :baseline_epsilon,
     keyword_init: true
   ) do
     CONFIG_FILE = ".mutineer.yml"
     # Keys accepted in .mutineer.yml (R7). `require` maps to the :require_paths field.
-    KNOWN_KEYS = %w[operators jobs threshold only require boot rails since framework].freeze
+    KNOWN_KEYS = %w[operators jobs threshold only require boot rails since framework verbose ignore baseline].freeze
 
     def initialize(**kwargs)
       super
@@ -45,6 +46,9 @@ module Mutineer
       self.strategy      ||= "reload"
       self.require_paths ||= []
       self.rails         = false if rails.nil?
+      self.verbose       = false if verbose.nil?
+      self.ignore        ||= []
+      self.baseline_epsilon ||= 0.0
     end
 
     # Walk from `start` toward `home`, returning the first .mutineer.yml path found
@@ -143,6 +147,9 @@ module Mutineer
       when "boot"      then value.to_s
       when "framework" then value.to_s
       when "rails"     then value == true || value.to_s == "true"
+      when "verbose"   then value == true || value.to_s == "true"
+      when "ignore"    then Array(value).map(&:to_s)
+      when "baseline"  then value.to_s
       else value
       end
     end

data/lib/mutineer/coverage_map.rb

@@ -6,6 +6,7 @@ require "digest"
 require "fileutils"
 require "rbconfig"
 require "coverage"
+require "set"
 require_relative "minitest_integration"
 require_relative "test_runners"
 
@@ -25,7 +26,7 @@ module Mutineer
     def initialize(source_paths:, test_paths:, cache_dir: ".mutineer",
                    load_paths: ["lib"], project_root: Dir.pwd,
                    capture_timeout: DEFAULT_CAPTURE_TIMEOUT, boot_path: nil,
-                   framework: "minitest")
+                   framework: "minitest", verbose: false)
       @source_paths = Array(source_paths)
       @test_paths   = Array(test_paths)
       @cache_dir    = cache_dir
@@ -34,6 +35,7 @@ module Mutineer
       @capture_timeout = capture_timeout
       @boot_path    = boot_path
       @framework    = framework || "minitest"
+      @verbose      = verbose
       @map          = {}
       @failed_test_files = []
       @phase_a_ran  = false
@@ -64,8 +66,40 @@ module Mutineer
       @map["#{relativize(file)}:#{line}"] || []
     end
 
+    # #9: is this source file's empty coverage the result of an *errored* capture
+    # rather than a genuine coverage gap? True iff (KTD-2) 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 standard _test/_spec naming convention. Derived
+    # purely from already-persisted state (@map keys + @failed_test_files); no rerun,
+    # no new cached field, no digest change.
+    #
+    # ponytail: 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 source with no naming-convention test match is never tainted. Upgrade path:
+    # persist per-file coverage per successful run and diff against the failed set,
+    # or record test->source targets explicitly. Not needed for the #8/#9 cases.
+    def uncapturable_source?(file)
+      return false if @failed_test_files.empty?
+
+      rel = relativize(absolute(file))
+      return false if covered_source_files.include?(rel)
+
+      failed_test_targets.include?(File.basename(rel, ".rb"))
+    end
+
     private
 
+    # Source rel-paths that received coverage from any successful capture.
+    def covered_source_files
+      @map.keys.map { |k| k.rpartition(":").first }.to_set
+    end
+
+    # Basenames of failed test files with a trailing _test/_spec (and .rb) stripped,
+    # i.e. the source basenames they would have covered by convention.
+    def failed_test_targets
+      @failed_test_files.map { |t| File.basename(t, ".rb").sub(/_(test|spec)\z/, "") }.to_set
+    end
+
     # Shared cache dance for both build paths: hit the digest-keyed cache, else
     # yield to populate @map and persist it.
     def cached_or
@@ -108,10 +142,16 @@ module Mutineer
       abs_sources = abs_source_paths
 
       @test_paths.each do |test_path|
-        coverage = fork_capture(absolute(test_path), abs_sources, rails)
-        next fail_test(test_path, "fork capture produced no result") unless coverage
-
-        record(coverage, test_path)
+        # Tri-state payload (KTD-1): Hash = coverage, String = error diagnostic
+        # from the child, nil = pipe gone / empty.
+        # ponytail/#9: this String diagnostic is what #9 turns into an :uncapturable status.
+        case (coverage = fork_capture(absolute(test_path), abs_sources, rails))
+        when Hash   then record(coverage, test_path)
+        when String
+          fail_test(test_path, @verbose ? "fork capture failed: #{coverage}" :
+            "fork capture produced no result (re-run with --verbose for the error)")
+        else fail_test(test_path, "fork capture produced no result")
+        end
       end
     end
 
@@ -132,8 +172,10 @@ module Mutineer
             Coverage.result(stop: false)
                     .select { |f, _| abs_sources.include?(f) }
                     .transform_values { |v| v.is_a?(Hash) ? v[:lines] : v }
-          rescue Exception # rubocop:disable Lint/RescueException
-            nil
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            # KTD-1: stringify (an arbitrary Exception may not marshal); the parent
+            # surfaces this under --verbose. A String marshals safely over the pipe.
+            "#{e.class}: #{e.message}#{e.backtrace&.first ? " @ #{e.backtrace.first}" : ''}"
           end
         begin
           wr.write(Marshal.dump(payload))

data/lib/mutineer/mutant_id.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Mutineer
+  # Content-based stable id for a mutant — NOT byte offsets. Pure function, reused
+  # by the Runner (matching the ignore list), the Reporter (emitting a copy-
+  # pasteable id per survivor), and #13 baseline gating (diffing id-sets run to
+  # run). `digest` is stdlib, so zero new deps.
+  #
+  # Offset-free by design: keyed on the subject's qualified_name (a method, not a
+  # byte position) + operator + the normalized mutated token + an occurrence
+  # ordinal among same-(operator, token) twins WITHIN the subject. So it survives
+  # any edit outside the subject method — where raw start/end offsets shift on
+  # every edit earlier in the file and would silently stop matching.
+  module MutantId
+    module_function
+
+    # NUL-joined so token delimiters (`||=`, spaces, `::`, `#`) can never collide
+    # with the separator; SHA256[0,12] gives a fixed-length, copy-pasteable key.
+    def for(subject, mutation, source, occurrence = 0)
+      Digest::SHA256.hexdigest(
+        [subject.qualified_name, mutation.operator,
+         normalized_token(mutation, source), occurrence].join("\x00")
+      )[0, 12]
+    end
+
+    # Ids for a subject's full mutation list, in input order, assigning each its
+    # 0-based occurrence among twins sharing the same (operator, token). This is
+    # what disambiguates `a + b + c`'s two `+` mutants without an offset.
+    def for_subject(subject, source, mutations)
+      seen = Hash.new(0)
+      mutations.map do |m|
+        key = [m.operator, normalized_token(m, source)]
+        occ = seen[key]
+        seen[key] += 1
+        self.for(subject, m, source, occ)
+      end
+    end
+
+    # The exact code being mutated, whitespace-collapsed — same normalization the
+    # Reporter's diff_for uses for its token label.
+    def normalized_token(mutation, source)
+      source.byteslice(mutation.start_offset...mutation.end_offset).gsub(/\s+/, " ").strip
+    end
+  end
+end

data/lib/mutineer/pairing.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Mutineer
+  # Source -> test pairing by path convention (#11). Pure stdlib path logic:
+  # no Rails, no class loading, no process. Two jobs:
+  #   * expand_sources — a directory argument becomes its sorted **/*.rb files.
+  #   * infer_test     — a source's test file by convention (app/ and lib/ sources
+  #                      map to test/.../_test.rb or spec/.../_spec.rb), preserving
+  #                      namespaced subdirectories. First EXISTING candidate wins.
+  #
+  # Independently unit-testable: every method is pure in/out over the filesystem,
+  # so the pairing contract is exercised with plain fixtures, no Rails, no fork.
+  module Pairing
+    module_function
+
+    # Expand each positional source: a directory -> its sorted **/*.rb files
+    # (relative to project_root); a file (or glob, or anything non-directory) ->
+    # itself. Flattened, deduped, order-stable.
+    def expand_sources(args, project_root:)
+      root = File.expand_path(project_root)
+      Array(args).flat_map do |arg|
+        abs = File.expand_path(arg, root)
+        if File.directory?(abs)
+          Dir.glob(File.join(abs, "**", "*.rb")).sort.map { |f| f.delete_prefix("#{root}/") }
+        else
+          [arg]
+        end
+      end.uniq
+    end
+
+    # The first EXISTING candidate test path for a source (relative to
+    # project_root), or nil. `prefer` is the resolved framework ("minitest" |
+    # "rspec"): its candidates are tried first, the other framework's as fallback,
+    # so a minitest default still finds a spec and vice-versa.
+    def infer_test(source_rel, project_root:, prefer: "minitest")
+      base, lib = logical_path(source_rel)
+      candidates(base, lib, prefer).find do |rel|
+        File.exist?(File.expand_path(rel, project_root))
+      end
+    end
+
+    # Strip the source root to a logical path (no ".rb") and flag lib/ sources.
+    # app/foo/bar.rb and lib/foo/bar.rb both -> "foo/bar"; anything else -> the
+    # path minus ".rb" (still attempted). Namespaced subdirs are preserved
+    # verbatim — structural, never constant resolution.
+    def logical_path(source_rel)
+      no_ext = source_rel.sub(/\.rb\z/, "")
+      if no_ext.start_with?("app/")
+        [no_ext.sub(%r{\Aapp/}, ""), false]
+      elsif no_ext.start_with?("lib/")
+        [no_ext.sub(%r{\Alib/}, ""), true]
+      else
+        [no_ext, false]
+      end
+    end
+
+    # Ordered candidate test paths. lib/ sources also get test/lib/... and
+    # spec/lib/... (Rails apps put lib tests under either layout).
+    def candidates(base, lib, prefer)
+      minitest = ["test/#{base}_test.rb"]
+      minitest << "test/lib/#{base}_test.rb" if lib
+      rspec = ["spec/#{base}_spec.rb"]
+      rspec << "spec/lib/#{base}_spec.rb" if lib
+      prefer == "rspec" ? rspec + minitest : minitest + rspec
+    end
+  end
+end

data/lib/mutineer/reporter.rb

@@ -21,13 +21,14 @@ module Mutineer
     # Single entry point (R20/R21). Branches on `format` ("human" | "json") and
     # routes the rendered report to `output` (a file, with a stderr confirmation)
     # or to `out`. Diagnostics always go to `err`.
-    def report(out: $stdout, err: $stderr, threshold: 0.0, format: "human", output: nil)
+    def report(out: $stdout, err: $stderr, threshold: 0.0, format: "human", output: nil, baseline: nil)
       rendered =
         if format == "json"
-          json_report
+          json_report(baseline)
         else
           sio = StringIO.new
           human_report(sio, err, threshold)
+          baseline_section(sio, baseline) if baseline
           sio.string
         end
 
@@ -53,6 +54,7 @@ module Mutineer
       summary(out)
       out.puts
       score_line(out, err)
+      per_source(out)
 
       survivors(out)
       verdict(out, threshold) if threshold && threshold.positive?
@@ -73,7 +75,7 @@ module Mutineer
     # Canonical machine-readable schema (KTD7). survivors/no_coverage are sorted
     # by (file, line, operator) so output is byte-stable regardless of --jobs
     # worker finish order (R22).
-    def json_report
+    def json_report(baseline = nil)
       killed = @agg.killed_count
       survived = @agg.survived_count
       # C8: null (not 0.0) on an empty denominator, matching the nil-vs-0.0
@@ -82,27 +84,70 @@ module Mutineer
       score = @agg.mutation_score
 
       doc = {
-        schema_version: "1.0",
+        schema_version: "1.1",
         summary: {
           total: @agg.total, killed: killed, survived: survived,
           no_coverage: @agg.no_coverage_count,
+          uncapturable: @agg.uncapturable_count,
           skipped_invalid: @agg.skipped_invalid_count,
           errored: @agg.errored_count, timeout: @agg.timeout_count,
+          ignored: @agg.ignored_count,
           score: score
         },
         survivors: @agg.surviving_mutants.map { |r| survivor_json(r) }
                        .sort_by { |h| [h[:file], h[:line], h[:operator]] },
         no_coverage: @agg.results.select(&:no_coverage?).map { |r| no_coverage_json(r) }
-                         .sort_by { |h| [h[:file], h[:line]] }
+                         .sort_by { |h| [h[:file], h[:line]] },
+        # #9: same shape as no_coverage; additive key.
+        uncapturable: @agg.results.select(&:uncapturable?).map { |r| no_coverage_json(r) }
+                          .sort_by { |h| [h[:file], h[:line]] },
+        # #10: equivalent mutants the user suppressed — emitted with their stable
+        # id so the user can audit what is silenced (and copy ids for survivors
+        # they want to add). Excluded from the score; never in `survivors`.
+        ignored: @agg.results.select(&:ignored?).map { |r| ignored_json(r) }
+                     .sort_by { |h| [h[:file], h[:line], h[:operator]] },
+        # #11: per-source breakdown (additive; #13 consumes it). Sorted by file so
+        # output is byte-stable. Reuses AggregateResult via by_source.
+        per_source: @agg.by_source.map { |file, agg| per_source_json(file, agg) }
+                        .sort_by { |h| h[:file] }
       }
+      # #13: additive baseline-delta block, present only with --baseline. Existing
+      # consumers ignore the extra key; schema_version stays 1.1.
+      doc[:baseline] = baseline_json(baseline) if baseline
       "#{JSON.generate(doc)}\n"
     end
 
+    # #13: the same delta facts the human report prints, for dashboards. new_survivors
+    # reuse the ignored_json shape (subject/file/line/operator/token/id) and sort
+    # byte-stably so output doesn't depend on --jobs finish order.
+    def baseline_json(delta)
+      {
+        regressed: delta.regressed,
+        score_before: delta.score_before,
+        score_after: delta.score_after,
+        score_dropped: delta.score_drop,
+        new_survivors: delta.new_survivors.map { |r| ignored_json(r) }
+                            .sort_by { |h| [h[:file], h[:line], h[:operator]] },
+        fixed_survivors: delta.fixed_survivors.map do |h|
+          { subject: h["subject"], file: h["file"], line: h["line"],
+            operator: h["operator"], id: h["id"] }
+        end.sort_by { |h| [h[:file].to_s, h[:line].to_i, h[:operator].to_s] }
+      }
+    end
+
+    def per_source_json(file, agg)
+      {
+        file: file, total: agg.total,
+        killed: agg.killed_count, survived: agg.survived_count,
+        no_coverage: agg.no_coverage_count, score: agg.mutation_score
+      }
+    end
+
     def survivor_json(result)
       m = result.mutation
       file = result.subject.file
       source = @source_map[file] || File.read(file)
-      start_line, original_block, mutated_block, = diff_for(m, source)
+      start_line, original_block, mutated_block, token = diff_for(m, source)
       minus = original_block.each_line.map { |l| "-#{l.chomp}" }.join("\n")
       plus  = mutated_block.each_line.map { |l| "+#{l.chomp}" }.join("\n")
       {
@@ -110,10 +155,30 @@ module Mutineer
         file: file,
         line: start_line,
         operator: m.operator.to_s,
+        # #10: the stable, copy-pasteable id (next to the human-readable token) so a
+        # user can paste it straight into .mutineer.yml `ignore:`.
+        id: result.id,
+        token: token,
         diff: "--- a/#{file}\n+++ b/#{file}\n@@ -#{start_line} +#{start_line} @@\n#{minus}\n#{plus}\n"
       }
     end
 
+    # An entry under the JSON `ignored:` key — what the user already suppressed.
+    def ignored_json(result)
+      m = result.mutation
+      file = result.subject.file
+      source = @source_map[file] || File.read(file)
+      start_line, _orig, _mut, token = diff_for(m, source)
+      {
+        subject: result.subject.qualified_name,
+        file: file,
+        line: start_line,
+        operator: m.operator.to_s,
+        token: token,
+        id: result.id
+      }
+    end
+
     # Builds a line-aligned diff for a mutation whose byte range may span several
     # lines (e.g. statement-removal of a multi-line statement). Returns the
     # mutation's 1-based start line, the full original line-block it touches, the
@@ -151,12 +216,18 @@ module Mutineer
       out.puts format("Survived:     %-6d  No coverage:   %d", @agg.survived_count, @agg.no_coverage_count)
       out.puts format("Skipped:      %-6d  Errored:       %d", @agg.skipped_invalid_count,
                       @agg.errored_count + @agg.timeout_count)
+      # #9: a broken harness, not a coverage gap — report it distinctly from No coverage.
+      out.puts format("Uncapturable: %-6d  (tests failed to run)", @agg.uncapturable_count)
+      # #10: equivalent mutants the user suppressed; excluded from the denominator.
+      out.puts format("Ignored:      %-6d  (equivalent, suppressed)", @agg.ignored_count)
     end
 
     def score_line(out, err)
       score = @agg.mutation_score
-      excluded = "#{@agg.no_coverage_count} no-coverage, #{@agg.skipped_invalid_count} skipped, " \
-                 "#{@agg.errored_count + @agg.timeout_count} errored excluded"
+      excluded = "#{@agg.no_coverage_count} no-coverage, #{@agg.uncapturable_count} uncapturable, " \
+                 "#{@agg.skipped_invalid_count} skipped, " \
+                 "#{@agg.errored_count + @agg.timeout_count} errored, " \
+                 "#{@agg.ignored_count} ignored excluded"
       if score.nil?
         out.puts "Mutation score: N/A  (no covered mutants)"
         err.puts "[mutineer] no covered mutations; mutation score is N/A and the threshold check is skipped."
@@ -165,6 +236,44 @@ module Mutineer
       end
     end
 
+    # #11: one line per source after the global summary, so a multi-source run
+    # shows which file is weak. Omitted for a single-source run — the global
+    # summary already says everything (ponytail: no redundant one-line block).
+    def per_source(out)
+      sources = @agg.by_source
+      return if sources.size <= 1
+
+      out.puts
+      out.puts "Per-source"
+      out.puts "----------"
+      sources.sort.each do |file, agg|
+        score = agg.mutation_score
+        out.puts format("%s  %s  (%d killed / %d survived / %d no-cov)",
+                        file, score.nil? ? "N/A" : "#{score}%",
+                        agg.killed_count, agg.survived_count, agg.no_coverage_count)
+      end
+    end
+
+    # #13: the --baseline delta, appended after the normal report. Names every NEW
+    # survivor (subject (file:line) operator) and the score delta when it dropped,
+    # then a one-line REGRESSION/OK verdict so CI logs show which gate fired.
+    def baseline_section(out, delta)
+      out.puts
+      out.puts "Baseline comparison"
+      out.puts "-------------------"
+      out.puts "killed #{@agg.killed_count}, #{delta.new_survivors.size} new survivors vs baseline"
+      delta.new_survivors
+           .sort_by { |r| [r.subject.file, r.mutation.start_offset] }
+           .each do |r|
+        file = r.subject.file
+        source = @source_map[file] || File.read(file)
+        line, = diff_for(r.mutation, source)
+        out.puts "  + #{r.subject.qualified_name} (#{file}:#{line}) #{r.mutation.operator}"
+      end
+      out.puts "score dropped #{delta.score_before}% -> #{delta.score_after}%" if delta.score_drop
+      out.puts(delta.regressed ? "REGRESSION vs baseline" : "OK: no regression vs baseline")
+    end
+
     def survivors(out)
       mutants = @agg.surviving_mutants
       return if mutants.empty?

data/lib/mutineer/result.rb

@@ -1,42 +1,57 @@
 # frozen_string_literal: true
 
 module Mutineer
-  # Immutable outcome of running one mutant. Six distinct states:
-  #   killed      — a test failed/errored, so the mutation was caught.
-  #   survived    — every test passed, so the mutation went undetected.
-  #   error       — the child crashed (unhandled exception): exit status 2.
-  #   timeout     — the parent SIGKILLed a child that overran its wall clock.
-  #   skipped     — the mutated source failed to re-parse (invalid); no fork.
-  #   no_coverage — no test exercises the mutated line; not run, not scored.
+  # Immutable outcome of running one mutant. Seven distinct states:
+  #   killed       — a test failed/errored, so the mutation was caught.
+  #   survived     — every test passed, so the mutation went undetected.
+  #   error        — the child crashed (unhandled exception): exit status 2.
+  #   timeout      — the parent SIGKILLed a child that overran its wall clock.
+  #   skipped      — the mutated source failed to re-parse (invalid); no fork.
+  #   no_coverage  — no test exercises the mutated line; not run, not scored.
+  #   uncapturable — the line's would-be covering test errored during capture (#9),
+  #                  so coverage was lost. Excluded from the denominator exactly
+  #                  like no_coverage, but reported separately: it signals a broken
+  #                  harness (a test that failed to run), not a genuine coverage gap.
+  #   ignored      — a known-equivalent mutant the user suppressed (#10), via an
+  #                  inline `# mutineer:disable-line` comment or a `.mutineer.yml`
+  #                  `ignore:` id. A pre-fork classification (never run); excluded
+  #                  from the denominator so a strong file can reach 100%.
   #
   # `error` and `skipped` are deliberately distinct: skipped is a pre-fork
   # validity failure (counted separately by the reporter), error is a runtime
-  # crash. Never conflate them via `details` string parsing. `no_coverage` is a
-  # pre-fork selection result (M3): excluded from the score denominator.
+  # crash. Never conflate them via `details` string parsing. `no_coverage` and
+  # `uncapturable` are pre-fork selection results (M3/#9): both excluded from the
+  # score denominator.
   #
-  # `subject` and `mutation` are nil when the Result is built by Isolation/Runner
-  # (which only know the outcome); the orchestrator attaches them afterwards via
-  # `result.with(subject:, mutation:)` so the Reporter can render survivor diffs.
-  Result = Data.define(:status, :details, :subject, :mutation) do
-    def self.killed               = new(status: :killed, details: nil, subject: nil, mutation: nil)
-    def self.survived             = new(status: :survived, details: nil, subject: nil, mutation: nil)
-    def self.error(details = nil) = new(status: :error, details: details, subject: nil, mutation: nil)
-    def self.timeout              = new(status: :timeout, details: nil, subject: nil, mutation: nil)
-    def self.skipped(details = nil) = new(status: :skipped, details: details, subject: nil, mutation: nil)
-    def self.no_coverage          = new(status: :no_coverage, details: nil, subject: nil, mutation: nil)
+  # `subject`, `mutation`, and `id` are nil when the Result is built by Isolation/
+  # Runner (which only know the outcome); the orchestrator attaches them afterwards
+  # via `result.with(subject:, mutation:, id:)` so the Reporter can render survivor
+  # diffs and emit the stable id. `id` is the content-based MutantId (#10).
+  Result = Data.define(:status, :details, :subject, :mutation, :id) do
+    def self.killed               = new(status: :killed, details: nil, subject: nil, mutation: nil, id: nil)
+    def self.survived             = new(status: :survived, details: nil, subject: nil, mutation: nil, id: nil)
+    def self.error(details = nil) = new(status: :error, details: details, subject: nil, mutation: nil, id: nil)
+    def self.timeout              = new(status: :timeout, details: nil, subject: nil, mutation: nil, id: nil)
+    def self.skipped(details = nil) = new(status: :skipped, details: details, subject: nil, mutation: nil, id: nil)
+    def self.no_coverage          = new(status: :no_coverage, details: nil, subject: nil, mutation: nil, id: nil)
+    def self.uncapturable         = new(status: :uncapturable, details: nil, subject: nil, mutation: nil, id: nil)
+    def self.ignored              = new(status: :ignored, details: nil, subject: nil, mutation: nil, id: nil)
 
-    def killed?      = status == :killed
-    def survived?    = status == :survived
-    def error?       = status == :error
-    def timeout?     = status == :timeout
-    def skipped?     = status == :skipped
-    def no_coverage? = status == :no_coverage
+    def killed?       = status == :killed
+    def survived?     = status == :survived
+    def error?        = status == :error
+    def timeout?      = status == :timeout
+    def skipped?      = status == :skipped
+    def no_coverage?  = status == :no_coverage
+    def uncapturable? = status == :uncapturable
+    def ignored?      = status == :ignored
   end
 
   # Aggregates a flat list of Results into counts, the mutation score, and the
   # surviving-mutant list. The score denominator is killed + survived ONLY
-  # (KTD-4): no-coverage, skipped (invalid), errored, and timeout are each
-  # excluded and surfaced separately. An empty denominator yields a nil score
+  # (KTD-4): no-coverage, uncapturable, skipped (invalid), errored, timeout, and
+  # ignored (#10 equivalent-mutant suppression) are each excluded and surfaced
+  # separately — so suppressing every survivor reaches 100%. An empty denominator yields a nil score
   # (rendered "N/A"), never 0.0 — distinguishing "no testable mutants" from
   # "0% killed".
   class AggregateResult
@@ -50,9 +65,11 @@ module Mutineer
     def killed_count          = count(:killed)
     def survived_count        = count(:survived)
     def no_coverage_count     = count(:no_coverage)
+    def uncapturable_count    = count(:uncapturable)
     def skipped_invalid_count = count(:skipped)
     def errored_count         = count(:error)
     def timeout_count         = count(:timeout)
+    def ignored_count         = count(:ignored)
 
     # Every generated, classified mutation. NOT the score denominator.
     def total = @results.size
@@ -70,6 +87,17 @@ module Mutineer
 
     def surviving_mutants = @results.select(&:survived?)
 
+    # #11: split into { source_file => AggregateResult } so the Reporter (per-source
+    # breakdown) and #13 (per-source roll-up / baseline diff) share one shape with
+    # all the score/count methods. After Runner.execute every result carries a
+    # subject, so the grouping is total; bare results (no subject, only in unit
+    # tests) are skipped so file keys stay sortable strings.
+    def by_source
+      @results.select { |r| r.subject }
+              .group_by { |r| r.subject.file }
+              .transform_values { |rs| AggregateResult.new(rs) }
+    end
+
     private
 
     def count(status) = (@by_status[status] || []).size

data/lib/mutineer/runner.rb

@@ -10,6 +10,8 @@ require_relative "coverage_map"
 require_relative "changed_lines"
 require_relative "mutator_registry"
 require_relative "worker_pool"
+require_relative "mutant_id"
+require "set"
 
 module Mutineer
   # Orchestrates one mutation end-to-end: apply it textually, validate the
@@ -70,7 +72,8 @@ module Mutineer
           source_paths: config.sources, test_paths: config.tests,
           cache_dir: config.cache_dir, project_root: config.project_root,
           load_paths: config.load_paths, framework: config.framework,
-          boot_path: File.expand_path(config.boot, config.project_root)
+          boot_path: File.expand_path(config.boot, config.project_root),
+          verbose: config.verbose
         ).build_via_fork(rails: config.rails)
       else
         coverage_map = CoverageMap.new(
@@ -81,13 +84,28 @@ module Mutineer
       end
 
       # Collect every (subject, mutation) up front so the pool can fan them out.
+      # #10: a mutant the user marked known-equivalent (inline disable-line comment
+      # or .mutineer.yml ignore id) is classified :ignored here and NEVER forked —
+      # it is removed from the killed+survived denominator so a strong file reaches
+      # 100%. The stable id is computed per subject (occurrence needs the full list)
+      # and carried on every job so the parent can reattach it after the run.
       source_map = {}
+      disabled_map = {}
+      ignore_set = config.ignore.to_set
       jobs = []
+      ignored_results = []
       Project.discover(config.sources, only: config.only).each do |subject|
         source = (source_map[subject.file] ||= File.read(subject.file))
-        operator_classes.each do |klass|
-          klass.new.mutations_for(subject, source).each do |mutation|
-            jobs << [subject, mutation]
+        disabled = (disabled_map[subject.file] ||= suppress_map(source))
+        mutations = operator_classes.flat_map { |klass| klass.new.mutations_for(subject, source) }
+        ids = MutantId.for_subject(subject, source, mutations)
+        mutations.each_with_index do |mutation, i|
+          id = ids[i]
+          line = source.byteslice(0, mutation.start_offset).count("\n") + 1
+          if suppressed?(mutation.operator, line, id, disabled, ignore_set)
+            ignored_results << Result.ignored.with(subject: subject, mutation: mutation, id: id)
+          else
+            jobs << [subject, mutation, id]
           end
         end
       end
@@ -111,13 +129,42 @@ module Mutineer
                 subject: subject, strategy: strategy, rails: config.rails, framework: framework)
           end
           # The bare Results carry only status (Subjects hold live AST nodes that
-          # do not marshal); reattach subject+mutation in the parent, in order.
-          bare.each_with_index.map { |r, i| r.with(subject: jobs[i][0], mutation: jobs[i][1]) }
+          # do not marshal); reattach subject+mutation+id in the parent, in order.
+          bare.each_with_index.map { |r, i| r.with(subject: jobs[i][0], mutation: jobs[i][1], id: jobs[i][2]) }
         ensure
           sweep_orphans(source_dirs)
         end
 
-      [AggregateResult.new(results), source_map]
+      [AggregateResult.new(results + ignored_results), source_map]
+    end
+
+    # Scan a source once into { line_number => :all | Set[operator_syms] } from
+    # inline `# mutineer:disable-line [ops]` markers (RuboCop semantics: the marker
+    # sits on the same physical line as the code it silences). A bare marker
+    # disables every operator on that line; `disable-line a, b` only the listed
+    # operators. Block-form disable/enable ranges are intentionally not supported.
+    def self.suppress_map(source)
+      map = {}
+      source.each_line.with_index(1) do |text, line|
+        next unless (m = text.match(/#\s*mutineer:disable-line(?:\s+([\w,\s]+))?/))
+
+        ops = m[1]
+        map[line] = ops ? ops.split(",").map { |o| o.strip.to_sym }.reject(&:empty?).to_set : :all
+      end
+      map
+    end
+
+    # True when this mutant is suppressed: its line bears a disable-line marker
+    # (bare, or scoped to its operator), OR its stable id is in the config ignore
+    # list. Checked at job-build time so a suppressed mutant is never forked.
+    def self.suppressed?(operator, line, id, disabled, ignore_set)
+      return true if ignore_set.include?(id)
+
+      case (entry = disabled[line])
+      when :all then true
+      when Set  then entry.include?(operator)
+      else false
+      end
     end
 
     # --since: keep only jobs whose mutation lands on a line changed since the git
@@ -189,7 +236,11 @@ module Mutineer
       # covering test files run in the child.
       line   = source.byteslice(0, mutation.start_offset).count("\n") + 1
       chosen = coverage_map.tests_for(source_file, line)
-      return Result.no_coverage if chosen.empty?
+      # #9: distinguish a genuine coverage gap from a line whose would-be test
+      # errored during capture (coverage lost) — the latter is :uncapturable.
+      if chosen.empty?
+        return coverage_map.uncapturable_source?(source_file) ? Result.uncapturable : Result.no_coverage
+      end
 
       abs_tests = chosen.map { |t| File.expand_path(t, coverage_map.project_root) }
 
@@ -209,10 +260,28 @@ module Mutineer
     def self.reconnect_active_record
       return unless defined?(ActiveRecord::Base)
 
-      ActiveRecord::Base.connection_handler.clear_all_connections!
+      base = ActiveRecord::Base
+      # #8: clearing connections here drops an open transactional-fixture
+      # transaction, so the test loses its fixture rows and fails. Skip the clear
+      # when a transaction is open; otherwise clear (v0.2 per-fork write-safety).
+      return if fixture_transaction_open?(base)
+
+      base.connection_handler.clear_all_connections!
     rescue StandardError
       nil
     end
     private_class_method :reconnect_active_record
+
+    # Pure, injectable predicate: true when a transactional-fixture transaction is
+    # already open on the connection. Keys off open_transactions (KTD-2) so it is
+    # correct whenever the transaction exists, regardless of when it opened. Any
+    # probe error degrades safe to false -> caller clears (existing behaviour).
+    def self.fixture_transaction_open?(base)
+      pool = base.connection_pool
+      pool.active_connection? && base.connection.open_transactions.positive?
+    rescue StandardError
+      false
+    end
+    private_class_method :fixture_transaction_open?
   end
 end

data/lib/mutineer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mutineer
-  VERSION = "0.6.2"
+  VERSION = "0.7.0"
 end

data/lib/mutineer.rb

@@ -6,6 +6,7 @@ require_relative "mutineer/parser"
 require_relative "mutineer/subject"
 require_relative "mutineer/mutation"
 require_relative "mutineer/project"
+require_relative "mutineer/pairing"
 require_relative "mutineer/result"
 require_relative "mutineer/coverage_map"
 require_relative "mutineer/changed_lines"
@@ -25,6 +26,7 @@ require_relative "mutineer/mutator_registry"
 require_relative "mutineer/worker_pool"
 require_relative "mutineer/runner"
 require_relative "mutineer/reporter"
+require_relative "mutineer/baseline"
 require_relative "mutineer/cli"
 
 module Mutineer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutineer
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - David Teren
@@ -52,12 +52,14 @@ files:
 - README.md
 - bin/mutineer
 - lib/mutineer.rb
+- lib/mutineer/baseline.rb
 - lib/mutineer/changed_lines.rb
 - lib/mutineer/cli.rb
 - lib/mutineer/config.rb
 - lib/mutineer/coverage_map.rb
 - lib/mutineer/isolation.rb
 - lib/mutineer/minitest_integration.rb
+- lib/mutineer/mutant_id.rb
 - lib/mutineer/mutation.rb
 - lib/mutineer/mutator_registry.rb
 - lib/mutineer/mutators/arithmetic.rb
@@ -69,6 +71,7 @@ files:
 - lib/mutineer/mutators/literal_mutation.rb
 - lib/mutineer/mutators/return_nil.rb
 - lib/mutineer/mutators/statement_removal.rb
+- lib/mutineer/pairing.rb
 - lib/mutineer/parser.rb
 - lib/mutineer/project.rb
 - lib/mutineer/reporter.rb