mutineer 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e18649829a9226ea7a5f654ef38602eabff4005ebf8a516fca4402460a7aac09
-  data.tar.gz: 9e3c166e5e2e513278aaf210f271ed0f070cd335d0de588318cb8aa71f6b6a06
+  metadata.gz: eeac45268c75073f522daa5d26dd65fe425ae66b604cfb7543c0b529ab71f2e6
+  data.tar.gz: 834755a3b106f02013ef75b9515f18e692d1c6ac219bee42b837da8a6f696fc7
 SHA512:
-  metadata.gz: 2e10e1214d0b55a4c93c7fa13d4c3b39503d4e2b1e367a995e2d813e98bd55ce2c2774b429bd690f2ae55019a39c7ee539e3ef60ea51bf25e2bc61c602ab72b6
-  data.tar.gz: 146768f9f599d41af9e6549f65ad7658cdd55e3d57a6f35fa6d094cfef6be73b036bb3dc8ebe8616d03cf358cdaf78e5d8a3b40a996c7a4d18a06898b9454824
+  metadata.gz: '092252eef7f756e5fa117784b7c3696777127b0f1f1b96825c38d99a9f8d362a23416ad2351685e62bd780563a2b7fa2eab0e926c10bee3e293293ff88e0d28d'
+  data.tar.gz: 02344ad3f678a639a37f0272577e50e5f189e585a9246be0b0f1451202a03c63cb57e013181e349ab7b4db04f36fb2333e2de7d864063c4da92d4394f5dce6b3

data/CHANGELOG.md

@@ -6,6 +6,479 @@ All notable changes to this project are documented here. The format is based on
 
 ## [Unreleased]
 
+## [1.6.0] - 2026-10-08
+
+### Added
+
+- **An `unplaceable` mutant status.** Under `--strategy redefine`, a mutant in
+  a method whose class or module has no constant name is not run. It is left
+  out of the score and, unlike `uncapturable`, out of `no_verdict`, so it does
+  not fail `--threshold`. The human report gives it an `Unplaceable:` row, the
+  HTML report a count, and the JSON report `summary.unplaceable` and an
+  `unplaceable[]` list; `schema_version` is `1.7`.
+- **The agent skill installs with `gh skill` and `npx skills` (#125).** It
+  moved from `docs/skill.md` to `skills/mutineer/SKILL.md`, the layout of the
+  Agent Skills specification, so `gh skill install davidteren/mutineer
+  mutineer` finds it and `npx skills add davidteren/mutineer --skill mutineer`
+  installs one `SKILL.md` instead of the whole `docs/` site. The site build
+  copies that file to `skill.md`, so its URL still works. The skill's
+  description now says when to use it, and the README shows how to install it.
+- **A `ran_at_load` mutant status** (#187). A mutant on a method-body line
+  that ran while the app booted or its class loaded gets this status when it
+  survives, or when only the load ran the line. A kill stays a kill. It is
+  left out of the score and out of `no_verdict`, so it does not fail
+  `--threshold`. The human report gives it a `Ran at load:` row that points
+  to `--test-command` to verify these mutants, the HTML report a count, and
+  the JSON report `summary.ran_at_load` and a `ran_at_load[]` list, within
+  schema `1.7`.
+
+### Changed
+
+- **Mutants no longer run under Coverage with `--boot` or `--rails` (#228).** Coverage
+  starts before the app boots so the coverage map can be built, and it used to
+  keep running in every mutant fork after that, though nothing read it. It is
+  now suspended once the map is built, from a fresh capture or from the cache.
+  Coverage that a host process started before the run is left running.
+  On a small app whose test calls tiny methods in a loop, the CPU time of a
+  whole in-process `--boot` run fell from 0.76s to 0.57s (median of five). On
+  the Rails fixture app the run is mostly boot, and the change is within noise
+  (1.61s before, 1.60s after). `--daemon` runs its mutants in worker daemons
+  that never start Coverage, so its time does not change (3.48s before, 3.44s
+  after); the map-building daemon now suspends Coverage after the map too.
+- **A mutant runs its paired test files first, then the cheapest (#203).** The
+  covering test files used to run in the order the coverage map stored them,
+  so a mutant that one fast file kills could still score `timeout` when slow
+  files ran first. Now the files that pairing finds for the source run first,
+  then the rest from fastest to slowest by the time each file took during
+  coverage capture, less the fastest file's time (the startup cost each
+  capture pays). The order is fixed for a given cache. Costs compare in
+  doubling buckets, so files of close cost keep their path order when a
+  rebuilt cache measures them again; a file near a bucket edge can still move,
+  so keep `.mutineer/` between CI runs for the most stable `--baseline`. The
+  order applies to Minitest (after the seeded class shuffle, with
+  `parallelize_me!` classes still last) and to RSpec. `--daemon` runs every
+  covering test with no stop, so the order does not change its verdicts. The
+  coverage cache now saves these timings, so a cache from an earlier version
+  rebuilds once. A complete run gives the same verdicts and `--matrix` rows,
+  but the new order can change which mutants time out, so a `--baseline` gate
+  can see a one-time change on upgrade.
+- **Job selection moved from `Mutineer::Runner` to a new `Mutineer::JobPlan`
+  module (#75).** The in-process runner, the `--daemon` backend and
+  `--dry-run` share it, so each file now requires what it uses and no
+  `require_relative` cycle exists in `lib/mutineer`. The moved methods are
+  `collect_jobs`, `filter_since`, `coverage_selection`, `ran_at_load?`,
+  `load_verdict`, `abort_if_unclean!`, `test_load_roots`, `source_dirs`,
+  `sweep_orphans`, `suppress_map`, `suppressed?` and `result_keys`. These were
+  internal methods, so `Runner` keeps no copies. Runs, reports and caches do
+  not change.
+
+### Fixed
+
+- **An endless method that only the tests call is no longer `no_coverage`
+  under `--rails`, `--boot` or `--daemon` (#209).** Ruby counts no line when
+  an endless method such as `def half(x) = x / 2` runs, only its `def` line
+  when it is defined. The boot defines it before any test runs, so the forked
+  coverage capture never saw that line run. Coverage now also
+  counts methods (`Coverage.start(lines: true, methods: true)`), and a test
+  that calls such a method covers its `def` line. Coverage caches from earlier
+  versions rebuild once.
+- **`module_function :name` in a reopened module inside `class << self`
+  promotes the method from the earlier opening (#216).** Ruby treats both
+  openings as one module, but Mutineer matched them only within one body, so
+  it named the method `#<Class:App>::M#c` instead of `#<Class:App>::M.c`.
+  The two openings now match by the module's full name. A module whose name
+  Mutineer cannot be sure of still matches only within its own body: a path
+  such as `self::X` or `Foo::X` written directly inside `class << self`, a
+  name under an anonymous class, or a module in a `class << self` inside a
+  method or a `class_eval` block. A `module self::X` in a block, or a
+  `self::X = ...` in a `class_eval` block, matches only openings in the same
+  block. A `self::X` like these now also stays apart from a
+  module of the same name outside `class << self`, where a `module_function`
+  in that module used to promote its methods.
+- **A `module self::X` or `class self::X` in a block is `unplaceable` under
+  `--strategy redefine` (#229).** In a block, `self` is not always the
+  enclosing class: in `Other.class_eval do` it is `Other`, and in
+  `Foo = Class.new do` it is the new class. Mutineer gave these modules a
+  known owner on the enclosing namespace, so redefine loaded the mutant onto
+  a module the tests never use, and the mutant could falsely survive or
+  score `error`. Such a module, everything nested in it, and a
+  `self::X = ...` in a block that does not build a class now have
+  their owner unknown: redefine reports their mutants as `unplaceable`, and
+  `--strategy reload` still runs them. In a `Data.define`, `Struct.new`,
+  `Class.new` or `Module.new` block, the module is now named under the
+  builder's constant (`Outer::Foo::X#c`, was `Outer::X#c`), so the subject
+  names and mutant ids of those methods change. `self::X` directly in a class
+  or module body is unchanged.
+
+- **`--daemon` worker databases start as a copy of the test database
+  (#222).** Each worker slot's SQLite database used to start from
+  `db/schema.rb` alone. Rows the daemon wrote while it booted, in
+  initializers or `--require` files, were only in the base test database, so
+  a test that read them passed in-process but failed under `--daemon`. On its
+  first use, a worker database is now a copy of the base test database (schema
+  and rows, made with the SQLite online backup API). The worker still loads
+  `db/schema.rb` when the copy's schema differs from it (another schema
+  version, or another or no `schema_sha1` checksum in `ar_internal_metadata`),
+  for example when the test database is empty, out of date, or set up with a
+  plain `load "db/schema.rb"`. That load drops the
+  copied rows of the tables it defines.
+- **Standalone coverage capture loads the `--require` files (#217).** A run
+  without `--boot` requires the sources and then each `--require` (or
+  `require:`) file before it forks the mutants, but the coverage capture
+  loaded only the sources. A source method that a `--require` file called
+  while it loaded was then not seen as run at load, so its mutant was a false
+  `survived` instead of `ran_at_load`. The capture and the clean-suite check
+  now load the `--require` files after the sources. With or without
+  `--boot`, the coverage cache rebuilds when one of them changes, is added,
+  is removed, or moves in the load order.
+- **`--daemon` loads the `--require` files (#220).** The daemon booted the app
+  but never loaded the `--require` (or `require:`) files, so a test that
+  needs one failed under `--daemon` and passed in-process. A source method
+  that such a file called while it loaded was also not seen as run at load,
+  so its mutant could be a false `survived` instead of `ran_at_load`. The
+  daemon now loads the files after the app boots, as an in-process run does,
+  and the daemon's coverage cache rebuilds when one of them changes.
+- **The release workflow publishes only stable tags** (#161). Its trigger,
+  `v*.*.*`, also matches a prerelease tag such as `v1.3.1-rc1`, and the only
+  guard checked that the tag matched `Mutineer::VERSION`. A prerelease tag
+  could then publish the gem and move the floating major tag (`v1`) that
+  Action users pin. The workflow now stops with a clear error before any
+  publish step unless the tag is a stable `vMAJOR.MINOR.PATCH`.
+- **Coverage capture keeps to `capture_timeout` from start to finish.** Under
+  `--boot` and `--daemon`, a hung test file ignored the timeout and blocked
+  the run; it is now skipped as "timed out", like a standalone capture. A
+  process that a test started and left running could keep the result pipe
+  open and make a boot-mode capture wait for it to exit. Each capture now runs
+  in its own process group, and a timeout stops the whole group, not only the
+  test process. A capture whose test finished just before the deadline could
+  also lose its valid result and report "invalid coverage output"; it now
+  gets a short grace period to read the result. (#101, #129)
+- **`--daemon` no longer waits forever on a daemon that stops answering**
+  (#101). A mutant whose verdict has not arrived 30 seconds after its own
+  timeout is scored `error`, and the daemon is killed and respawned, as after
+  a crash. A boot that has not finished after 600 seconds ends the run with a
+  message that says so (it is not retried by a second daemon), and shutdown no longer waits on a stuck daemon.
+
+- **A method in a `Data.define`, `Struct.new`, `Class.new` or `Module.new`
+  block belongs to the class or module the block builds.** In
+  `class App; Argo = Data.define(:url) do def self.load = ...; end; end` the
+  subject is now `App::Argo.load`, not `App.load`; at the top level it was
+  `.load`, with no owner. Under `--strategy redefine` (the `--rails` default)
+  the mutated method was loaded into the wrong class, so the real method never
+  changed and every such mutant falsely survived. The class or module is
+  named after the constant it is assigned to with `=`, `||=` or `&&=`, through
+  parentheses or `begin`, resolved as Ruby resolves the assignment: `X` in the
+  current namespace, `::X` and any path at the top level from `Object`,
+  `self::X` under the current class. When it cannot be named statically (no
+  constant, a relative path such as `User::Permission` inside a namespace, or
+  a constant assigned in `class << self`), redefine reports its mutants with
+  a new status, `unplaceable`, rather than load them onto the wrong class;
+  reload still runs them. `module_function :name` in a `Module.new` block
+  promotes that module's method. Mutant ids for these subjects change:
+  regenerate `ignore:` entries and baselines that name them.
+- **The automated release PR gets its required CI checks without a token
+  secret (#85).** `release-pr.yml` pushes the release branch with the default
+  `GITHUB_TOKEN`, which starts no other workflow, so the four required checks
+  never ran and the PR stayed blocked until a person closed and reopened it.
+  The job now dispatches `ci.yml` on the release branch (CI gained a
+  `workflow_dispatch` trigger), and those runs report the required checks on
+  the PR's head commit. With a `RELEASE_PR_TOKEN` secret set, the push
+  triggers CI as before and no dispatch is made.
+- **Code that runs while the app boots or a class loads no longer gives a false
+  `survived` or `no_coverage`** (#187). A class body such as
+  `ALL = [price(3)].freeze` runs `price` before any mutant is applied. Under
+  `--strategy redefine` (the `--rails` default) the load never runs again, so
+  a test that checks `ALL` saw the original value and the mutant falsely
+  survived. Under `--rails` or `--boot` no test was credited with lines that
+  ran during boot, so those mutants were falsely `no_coverage`. Mutineer now
+  reads the lines that ran at load (from the boot, or from requiring the
+  sources in standalone capture) and reports these mutants as `ran_at_load`,
+  under both strategies and with `--daemon`: reload runs the file's class body
+  again but not an initializer or another file's code, so a survivor there is
+  not trusted either. Under `--boot` with redefine, a
+  lazily loaded class (Zeitwerk, `autoload`) is loaded before the boot lines
+  are read, so its class body counts as load too. A baseline survivor that is
+  now `ran_at_load` is listed as fixed, not as a regression. Standalone
+  coverage caches from earlier versions rebuild once. A one-line or endless
+  `def` keeps its body on the `def` line, which Ruby counts when the method is
+  defined, so Mutineer reads the method's call count at load for it instead
+  (#209).
+- **A boot file that prints to stdout no longer breaks the daemon handshake
+  (#102).** Output from `puts`, `STDOUT`, `$stdout`, a direct fd 1 write, or a
+  subprocess reached the JSON channel before the ready message, so the daemon
+  failed with "daemon exited before the handshake". The daemon now keeps a
+  private copy of its original stdout for the protocol and points the app's
+  stdout at stderr, where that output stays visible.
+- **A class or module opened inside `class << self` belongs to the singleton
+  class (#208).** In `class App; class << self; class Q; def q1 ...` the
+  subject was `App::Q.q1`, a class method of a constant Ruby never defines:
+  `Q` is `App.singleton_class::Q`, and `q1` is an instance method. It is now
+  `#<Class:App>::Q#q1` with no known owner, as is a class or module opened in
+  a builder block there, and anything nested in either. Inside a builder
+  block, `class << self` opens the built class's singleton class, so a class
+  or constant there is named under it, for example `#<Class:App::P>::W`. Under
+  `--strategy redefine` loading the mutant raised `NameError` and scored
+  `error`; redefine now reports these mutants as `unplaceable`, and reload
+  still runs them. A compact `class Foo::X` and a top-level `class ::X` or
+  `::X = Class.new do` there are named as written (`::X` as `X`, now with
+  instance methods) and are owner-unknown too: redefine reopens them without
+  the singleton class, so constants their bodies look up through it would not
+  resolve. `module_function :name` in a body whose owner is unknown now
+  promotes that body's own methods, wherever it is: a `Foo::X = Module.new`
+  block's `c` is `Foo::X.c`, not `Foo::X#c`, and a def in an anonymous
+  `Class.new` block is no longer promoted by a `module_function` of the module
+  around it. Mutant ids for these subjects change: regenerate `ignore:`
+  entries and baselines that name them.
+
+## [1.5.0] - 2026-10-06
+
+### Added
+- **`--timeout SECONDS` and `--capture-timeout SECONDS`**, also `timeout:` and
+  `capture_timeout:` in `.mutineer.yml`. They set the in-process per-mutant
+  time limit (default 10s) and the coverage-capture time limit (default 120s),
+  which were fixed. On a large Rails suite the clean run of the unmutated
+  tests took longer than 120s, so every run that offered the whole suite
+  stopped as not green, and a mutant on a line many tests cover took longer
+  than 10s and was scored `timeout`. `--daemon` keeps its own per-mutant
+  limit but uses `--capture-timeout` for its coverage capture;
+  `--test-command` uses neither. Either backend warns about a limit it was
+  given and does not use.
+- **`--cache-dir DIR`**, also `cache_dir:` in `.mutineer.yml`, sets where the
+  coverage cache is written (default `.mutineer`, as before). Two runs from the
+  same project root shared `.mutineer/coverage.json` and could overwrite each
+  other's map; each can now have its own directory. `--daemon` uses it too.
+  A blank value (an unset CI variable) exits 2 rather than writing the cache
+  into the project root.
+- **The README states how timeouts affect the score** (#62): a timed-out
+  mutant is left out of the score, and counts as a mutant with no verdict
+  under `--threshold`.
+- **`--matrix` reports which tests kill each mutant** (`matrix: true` in
+  `.mutineer.yml`). Each mutant runs every test in its covering files instead
+  of stopping at the first failure, and the child sends each test's outcome to
+  the parent as it is recorded. The report names blind tests, which ran in a
+  complete row and killed no mutant, and redundant tests, whose every kill
+  another test also makes. Redundancy is judged one test at a time, so delete
+  redundant tests one at a time. The human report lists up to 20 of each, the
+  HTML report all of them, and the JSON report moves to schema `1.5` with a
+  `matrix` block that appears only with the flag. A test is its file and its
+  id (the example id under RSpec), so examples that share a description stay
+  apart and an example whose generated description changes with the mutant
+  stays one test. Verdicts, the score and the exit code do not change: each
+  mutant gets the verdict a run without the flag gives. After a serial test
+  fails, an exit, a crash or the timeout in a later test, class or group
+  leaves it `killed`; an end in the code that run still reaches (the failing
+  test's class wrapper or group hooks, the suite's own cleanup) and a failure
+  in a `parallelize_me!` class keep the exit status. A row is complete only
+  when the child's stream arrived in order and every test reported (under
+  Minitest the recorder saw every test, under RSpec every planned example),
+  so a caught `Interrupt` leaves it incomplete. The human report names up
+  to 20 incomplete rows and the HTML and JSON reports all of them; the human
+  and HTML reports warn not to delete a blind test until its rows are
+  complete.
+  Minitest and RSpec 3.3+ are supported, on the in-process backend only;
+  `--daemon`, `--test-command`, `--fail-fast` and `--dry-run` exit 2 with it.
+  `--no-matrix` and `--no-fail-fast` beat the matching `.mutineer.yml` key,
+  so a file that sets one can still run with a flag that conflicts with it.
+- **`no_coverage[]` and `uncapturable[]` name each mutant.** Every entry in
+  the JSON report now has `operator`, `token` and `id`, as `ignored[]` has, so
+  mutants on one line can be told apart and an `id` can go in `ignore:`. The
+  entries are sorted by `(file, line, operator, id)`. `schema_version` is `1.6`.
+
+- **The site and README explain "clean-room" and compare Mutineer with
+  Mutant**, and the landing page hero has a one-minute explainer video. It
+  plays at 55% volume while in view (not with reduced motion; muted until
+  the first click or key where the browser requires it), pauses when it scrolls
+  away or the tab is hidden, and has an Enlarge button.
+
+### Changed
+- **The human report has a `Timeout:` row**, and the score line lists timeouts
+  apart from errored mutants. Before, the `Errored:` row and the score line
+  added the two together, while the JSON report kept them apart. The HTML
+  summary now shows a `timeout` count apart from `errored` too.
+- **A test file given as a source after `--test` exits 2.** `--test` takes one
+  file, so in `mutineer run app/x.rb --test spec/a_spec.rb spec/b_spec.rb` the
+  second spec became a source to mutate, and the run tested with one spec file
+  without a word. Now a source named `*_test.rb` or `*_spec.rb` inside a
+  `test/` or `spec/` directory, given with `--test`, is a usage error that says
+  to repeat `--test`. The usage line now reads `--test <test> [--test <test>...]`.
+
+### Fixed
+- **The RSpec runner keeps what gems configured before the run.** It called
+  `RSpec.reset`, which drops the whole configuration. Under `rails: true`, a
+  `--boot` file or `require:`, the app's gems load first, so a setting such as
+  rspec-retry's `verbose_retry` was gone, and a support file that set it
+  raised `NoMethodError`. The run stopped with "the unmutated suite is not
+  green". The runner now calls `RSpec.clear_examples`, which keeps the
+  configuration. Hooks that gems added now apply too: an example with
+  rspec-retry's `retry: 3` runs up to 3 times per mutant, as under `rspec`.
+- **`--since` no longer scores a file that Git ignores** (#168). A file
+  outside the index is scored in full, so a new file is not missed. That
+  check also caught files that Git ignores on purpose (`.gitignore`,
+  `.git/info/exclude` or the global excludes file), such as generated code
+  inside a directory run. Those files now get no mutants under `--since`,
+  and a warning names each one. Other untracked files are still scored in
+  full, and so is a file when Git cannot tell, such as one beyond a symlink or
+  inside a submodule.
+- **The human report escapes control characters from the source** (#163).
+  A surviving line that held a terminal control byte (for example ESC) was
+  printed as that byte, so it could change what the terminal showed. The
+  token, the replacement, the diff lines, method names, file paths and the
+  kill matrix's test names now print each control character except tab as
+  its Ruby escape (`\e`), and a byte that is not valid UTF-8 (a Latin-1
+  source) as `\xNN`. The JSON and HTML
+  reports already escaped text and do not change.
+- **One edit on a line is scored once** (#159). Some opt-in operators emitted
+  two mutants that give the same source: `literal_mutation` on `0` (the
+  "change to 1" and "add 1" rules), `negation_removal` on `!!x` (either `!`
+  removed), and `chain_link` or `operand_removal` on a repeated part such as
+  `a.b.b.c` or `x || x`. Each copy had its own id, so one surviving edit
+  counted twice. Now only the first copy on a line runs. Copies that start
+  on different lines (a multi-line chain) both stay, so `--since` never
+  loses the edit. Ids are assigned before the copy is dropped, so every kept
+  mutant keeps its id, and the dropped copy's id simply stops appearing.
+  Default runs do not change. If you use these operators with `--baseline`,
+  regenerate the baseline after upgrading: the score can move with no code
+  change, and in a full (unscoped) comparison a dropped copy that survived
+  is listed as fixed. An ignore entry for one copy's id still ignores only
+  that copy; the other copy still runs.
+- **`# mutineer:disable-line` inside a string no longer silences a line**
+  (#158). The marker was found with a text search, so a string such as
+  `"# mutineer:disable-line"` ignored every mutant on its line and left
+  them out of the score. Only a real `#` comment counts now. A heredoc or
+  regex that holds the text is ignored too.
+- **`./lib/x.rb` and an absolute path pair with a test** (#104). Auto-pairing
+  found the test for `lib/calc.rb` but not for `./lib/calc.rb` or the
+  absolute path to the same file. It reported "no test found by convention"
+  and exited 2. A file argument inside the project is now made relative to
+  the project root first, so equivalent spellings (`./`, `..`, absolute)
+  pair with the same test and run once. A symlink keeps its own name, so it
+  stays a separate source from its target. Reports show that root-relative
+  path. A path outside the project stays as typed.
+- **A mutant on another line of a multi-line statement runs its tests**
+  instead of being reported as `no_coverage`. Ruby counts one line of a
+  statement only. When the mutant's own line has no count, the runner now uses
+  the tests that ran the statement that holds the mutation. A heredoc body
+  belongs to its statement. This fallback skips a first or last line that also
+  holds other code, such as the `def` line, and the body of `x while c` and
+  `x until c`. It also gives no tests to a mutant in code of the statement
+  that runs only sometimes: a `when` or `in` condition, a `rescue` class
+  list, a parameter default, the rescue side of `x rescue y`, the value of
+  `||=` or `&&=`, the operand of `defined?`, the right side of `a ||` or
+  `a &&`, a branch of `x if c`, `x unless c`, a ternary or `else`, the
+  pattern of `v in p` or `v => p`, an
+  argument or block of `x&.m(...)`, and the value of `x&.m += v`. Those
+  mutants stay `no_coverage`, as before.
+- **A survivor diff for a multi-line mutant applies with `git apply`** (#106).
+  The JSON `diff` header always read `@@ -N +N @@`, even when the mutant
+  removed two lines and added one, so `git apply` rejected the patch as
+  corrupt. The header now carries each side's line count (`@@ -3,2 +3 @@`).
+  A one-line diff keeps its old header. A mutant that empties a line now
+  shows that empty line as a `+` line. A side whose last line has no final
+  newline gets ``. Lines of a CRLF file now keep
+  their `\r`, so the patch applies to that file.
+- **Split test files pair with their source** (#87). A source such as
+  `app/foo/bar.rb` now also uses `test/foo/bar_upsert_test.rb` and
+  `test/foo/bar_guards_test.rb`, together with `test/foo/bar_test.rb` when
+  that file exists. The same names under `test/lib/` pair with a `lib/`
+  source. Before, only the exact `bar_test.rb` name was tried, so a suite
+  split across `bar_*_test.rb` files was skipped and a gate could pass with
+  no mutants run. A spec the old rules already find is unchanged. The
+  split name is left for `user_session.rb` when that file exists, so
+  `user.rb` does not run `user_session_test.rb`. The same rule holds outside
+  `app/` and `lib/`: `src/user.rb` does not take `test/src/user_session_test.rb`
+  when `src/user_session.rb` exists. A longer source claims a split file
+  only when that source itself searches the directory the file is in.
+  A failed capture of `test/foo/bar_upsert_test.rb` can mark `app/foo/bar.rb`
+  uncapturable only when no successful capture covered that source and
+  `bar_upsert.rb` does not exist. A test outside that directory does not,
+  and neither does a source that only shares the test basename.
+  `user_session__test.rb` stays with `user.rb` when `user_session.rb`
+  exists, because that name is not the exact test or a split test for
+  `user_session`. A failed exact spec in the mirrored `spec/` or `spec/lib/` directory
+  marks an `app/` or `lib/` source the same way. A failed spec in another
+  directory does not. A project rooted at `/` still finds split tests
+  inside that root. A stored failure keeps the pairing from the moment it
+  was checked. Adding or deleting a longer source rebuilds the coverage
+  map, so that failure is not moved onto the shorter source.
+- **A blank `operators` key no longer runs zero mutants and exits 0** (#167).
+  `operators:` with no value became an empty list. The run made no mutants
+  and the gate passed. A blank operator list is now an error, and so is a
+  list of only unknown operator names. An empty `require` or `ignore` list
+  is still valid. `--operators` on the command line still replaces the
+  file list, including a blank or unknown file list.
+- **The daemon no longer runs the tool's Ruby settings inside the app** (#100).
+  Open3 keeps a variable when the spawn hash omits it, so a parent `RUBYOPT`
+  ran inside the app. The child now gets the environment Bundler saved before
+  it activated, passed with `unsetenv_others`. The app keeps its gem home,
+  excluded groups, Bundler config, and chruby path. An `RBENV_VERSION` or
+  `ASDF_RUBY_VERSION` already in the environment stays. That pin is often
+  the Ruby that started the tool. `.ruby-version` applies only when no pin
+  is set. The tool's `RUBYOPT` and `RUBYLIB` do not reach the child, including
+  a value Bundler had saved. A gem home, `BUNDLE_PATH`, or `BUNDLE_WITHOUT`
+  reaches the child only when Bundler saved the app's value. The same
+  rule covers `GEM_PATH` and `BUNDLER_VERSION`. An rbenv version
+  bin under `RBENV_ROOT`, or under `~/.rbenv` when that variable is unset,
+  leaves `PATH` only when that root has a shim directory. An asdf version
+  bin leaves only when an asdf shim directory exists, including
+  `ASDF_DATA_DIR/shims`. Without that shim, the bin stays and `bundle` can
+  still be found. The app Gemfile, an explicit Ruby pin, and Rails env are
+  applied after that.
+- **The Action refuses to run when `output` and `baseline` are the same file** (#160).
+  That setup used to work, and a failing run copied its report onto the
+  baseline. The next run then treated the failed report as the baseline, so
+  the gate could pass. The Action now stops before the run and exits 2.
+  The baseline may come from the `baseline` input, from `--baseline` in
+  `extra-args`, or from `.mutineer.yml`. A numeric path such as `123` is
+  read the same way as the CLI. Write the report to a separate path. Copy
+  that file onto the baseline in a later step, and only when this step
+  exits 0. You can also refresh the baseline with the CLI, and keep the
+  file only when the run exits 0. The next release moves the `v1` tag, so
+  workflows on `@v1` get this refusal then.
+- **A mutation no longer leaves a heredoc body behind as Ruby** (#134).
+  Replacing a node deletes the heredoc opener and not the body. The body
+  then parses as code, raises, and counts as a kill. A mutation that drops
+  the opener is skipped. A replacement that still contains the opener stays.
+- **A bare `public`, `private` or `protected` ends `module_function` mode**,
+  so later `def`s in the module body are named as instance methods, not
+  singleton methods (#144).
+- **Turning on reduced motion mid-visit finishes the landing page count-ups**,
+  so no number keeps changing after the visitor asks for less motion (#176).
+- **`rake site:build` can no longer delete a directory such as `lib/` or
+  `.git`** (#162). The task removed the destination it was given, and only
+  refused the checkout, its parents and `docs/`. It now always builds into
+  `_site/` at the checkout root, and `rake "site:build[DEST]"` and
+  `SITE_BUILD_DEST` are gone.
+- **Documentation matches the 1.4 behavior.** Config examples use supported keys,
+  agent loops check the exit code and a real score, and report totals explain
+  partial `--fail-fast` runs. The README lists every config key and its validation
+  rules. API README links work outside GitHub, repeated changelog headings have
+  unique anchors, and the website checks validate built links and anchors.
+  Mutant-id wording and the gem's Minitest/RSpec description are also corrected.
+- **A mutant in a nested method counts once** (#157). A `def` inside
+  another method is a subject of its own, but most operators also mutated
+  its code on the outer method. The same edit then counted twice in the
+  score, with two ids. Every operator now skips a nested `def` when it
+  mutates the outer method. A `def` inside `class << obj`, where `obj` is
+  not `self`, is not a subject, so the outer method still mutates its code.
+  `array_literal`, `chain_link`, `condition_true`, `condition_false`,
+  `operand_removal`, `operator_assignment` and `return_nil` skipped that
+  code before. Their new mutants there can show as new survivors against a
+  baseline.
+
+  A mutant id includes an ordinal among the mutants with the same operator
+  and token in a subject. When the duplicates leave the outer method, the
+  ordinals of its own mutants change. An old duplicate id can then name a
+  different mutant on the outer method, and an `ignore:` entry or a
+  baseline entry with that id applies to that mutant with no warning. If
+  your code has nested methods, regenerate the `ignore:` entries and the
+  baseline for the outer methods.
+
+  Under `--strategy redefine` (the `--rails` default), a mutant in a nested
+  method can survive or error even when a test would catch it. `redefine`
+  loads only the inner method, and a call to the outer method defines the
+  original inner method again. Before, the copy of the edit on the outer
+  method was killed. Now each edit has one verdict, from the inner method.
+
 ## [1.4.0] - 2026-09-30
 
 ### Added
@@ -677,6 +1150,8 @@ Rails hardening + CI batch (issues #8–#13), all verified Rails-free.
 - `.mutineer.yml` configuration (CLI > config > default precedence).
 - Byte-correct source handling for multibyte (UTF-8) sources.
 
+[1.6.0]: https://github.com/davidteren/mutineer/releases/tag/v1.6.0
+[1.5.0]: https://github.com/davidteren/mutineer/releases/tag/v1.5.0
 [1.4.0]: https://github.com/davidteren/mutineer/releases/tag/v1.4.0
 [1.3.0]: https://github.com/davidteren/mutineer/releases/tag/v1.3.0
 [1.2.0]: https://github.com/davidteren/mutineer/releases/tag/v1.2.0