mutineer 1.5.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50113a063a85737ad99476f85e78cb2ac015f267018d19ba6350ba36ff4ac6df
-  data.tar.gz: c12343a00d2df6d495859644c326bc650e33d013ddf009f2648c06a199aceb86
+  metadata.gz: 2afb9e81b16cbdf3b7ecd0d074365ee05eb58bdb0045ff6a73643a68893a4b1a
+  data.tar.gz: 949369679de39fbc53025fc470896bbef0c5310fc59c11cb928ad80aa748cc22
 SHA512:
-  metadata.gz: a170b15c6883a4dcec6a2798c3b102a5f9c9ded1f46c166df98d0e5bdf5b891ca5b24892efe06245680b45a94da38638adc36ca9a48a48d2ac1c07b29126f173
-  data.tar.gz: a30272ff6afb48dd666d6945c6532d987ef335e0e78dc422420cf26cdbec639ee1c850118a10ba25e10a426a2644b3926e39698126eaad0646707a4f2be2e719
+  metadata.gz: d78d0145b257b25321b7a9f05ebebc51e1818459eacecd26917953ef2dd0296af34fcb755a3a782102ef5453a9f27d90cb3fb2d8261fd8760ab557f273b2d866
+  data.tar.gz: 3d844218d9e05bc1c09bc7c1bfa7617c7fa79b49c943bb1a96af20ab68fa85312baf08ed9fa37d4f9929bc07c027c943717e2ce4344e15639509feeae66ff560

data/CHANGELOG.md

@@ -6,6 +6,477 @@ All notable changes to this project are documented here. The format is based on
 
 ## [Unreleased]
 
+## [1.7.0] - 2026-10-23
+
+### Added
+
+- **Call-to-receiver operator** (Tier-2, opt-in via `--operators`):
+  `call_to_receiver` replaces the last call of a chain with its receiver, with
+  the arguments and block of that call (`user.full_name` -> `user`). The mutant
+  survives when no test checks what that last call does. It does not overlap
+  with `chain_link`: `chain_link` drops a call in the middle of a chain, and
+  `call_to_receiver` drops only the last call. The two give the same source
+  only when the last call repeats the call before it (`node.name.name`). It
+  skips the same names as `chain_link`, and it skips operator calls and
+  setters.
+- **Reasons on ignored mutants.** Text after `--` on
+  `# mutineer:disable-line`, and a `.mutineer.yml` `ignore:` mapping
+  (`id` plus `reason`), is stored on the ignored mutant. The JSON report
+  (`schema_version` 1.8) and the HTML report show it. A mapping with no
+  `id`, or with an unknown key, warns. Mutineer 1.7 is the first version
+  that reads a mapping. An older version matches no mutant to a mapping
+  and does not warn, so the mutant it names is not ignored. Upgrade
+  every gate that reads the file before you add a mapping.
+  `mutineer migrate` rewrites the old id inside a mapping and keeps its
+  reason.
+- **`mutineer triage`.** It prints `ignore:` mapping entries for survivors
+  in a JSON report. `--reason` is required. Pass `--all` or `--id`. It
+  does not edit files.
+- **Equivalent-skip page.** The docs list every built-in chain-link skip
+  and the endless-range skip, and why each one is equivalent.
+- **Postgres worker databases for `--rails --daemon`.** Each worker gets
+  `<base>-mutineer-<N>`, copied from the test database before mutants run.
+  A second run cannot drop a database another live run holds. An app with
+  more than one database config runs one worker and says so once.
+  The worker databases stay after the run.
+- **MySQL 8 worker databases for Minitest on `--rails --daemon`.** Each worker gets
+  `<base>-mutineer-<N>` on `mysql2` or `trilogy`, with the base shortened to fit
+  MySQL's 64-byte name limit. Mutineer creates the
+  database, loads `schema.rb` or `structure.sql`, and copies rows once at
+  the start. Triggers from the schema do not fire on the copied rows.
+  Mutineer creates them again after the copy.
+  A second run cannot drop a database another live run holds.
+  That work uses the TLS and timeout settings from the database config.
+  MariaDB is not tested. MySQL 5.7 is not supported. The worker databases
+  stay after the run.
+- **`mutineer migrate`.** It rewrites old-format ids in `.mutineer.yml`
+  `ignore:` to the current ids. It keeps comments and every other line.
+  One old id that matches several mutants becomes every new id. An id that
+  matches nothing stays, and the command exits 1. A block scalar under
+  `ignore:` is not supported: the command exits 2 and does not change the
+  file. `--dry-run` prints each change and writes nothing. It does not
+  rewrite a baseline. Generate a new baseline with `--format json`. An
+  old-id warning names `mutineer migrate` and says that this becomes an
+  error in Mutineer 2.0. The baseline warning says to generate a new
+  baseline with `--format json`.
+- **`mutineer init`.** It writes a commented `.mutineer.yml` with the default
+  operators. `since` stays commented, so the first run is a full scan.
+  `init --rails` also sets `rails: true` and prints the first run command.
+  An existing file is kept unless you pass `--force`.
+- **Rails rollout guide.** The page walks from one model, to a report-only CI
+  job, to a `--since` and `--baseline` pull request gate, to `--threshold`
+  on chosen folders. It has a GitHub Actions recipe and a GitLab CI recipe.
+- **A mutation-testing primer in the README.** "What is mutation testing?"
+  walks through one small example, from a surviving mutant to the test that
+  kills it, and says what each report row means and what to do with a
+  survivor. The usage block lists all four commands.
+- **A production-ready section and a stability contract.** The README opens
+  with a support matrix for Ruby, database, framework, and parallelism.
+  `STABILITY.md` lists what a release keeps and what 2.0 will change.
+  `SECURITY.md`, `CONTRIBUTING.md`, and GitHub issue forms are new.
+  The docs home page takes the same section from the README at site build.
+- **`--allow-empty` and `allow_empty:`.** A run with no mutants now warns
+  that Mutineer 2.0 will fail it, unless `--allow-empty` marks it as expected.
+  A `--since` run whose changes hold no mutants does not warn: it says the
+  changes hold nothing to test. A `--since` run with no mutants even before
+  scoping still warns. The exit code does not change in 1.x.
+- **`--no-daemon`.** It beats a `.mutineer.yml` `daemon: true` for one run,
+  like `--no-fail-fast`. A Minitest `--rails` run without a `daemon` value now
+  prints a notice that 2.0 uses `--daemon` by default for `--rails`;
+  `--no-daemon` (or `daemon: false`) keeps the run serial and stops the
+  notice.
+- **"Did you mean" hints.** Unknown names in `--operators`, in
+  `.mutineer.yml` `operators:` and keys, and in `# mutineer:disable-line`
+  markers get the closest valid name. The `.mutineer.yml` warnings also say
+  that 2.0 makes them errors.
+- **`--coverage-from FILE` lets parallel shards share one coverage capture.**
+  A `--rails`/`--boot` run reads the `coverage.json` of an earlier run with
+  the same tests over these sources or more. It skips the capture. Each test
+  that covers one of its sources still runs alone, as on a cache hit, because
+  a mutant runs only those tests. A test that covers none of them does not,
+  so a shard runs far fewer tests alone than a full suite. All tests then run
+  once together, and the run saves its own cache.
+  Boot-mode caches now also record each source's fingerprint, the ownership
+  list and a digest of the other inputs. A capture that does not fit is an
+  error (exit 2), never a silent recapture. So is one where loading its other
+  sources ran these sources' code, which happens under lazy loading with
+  `--strategy redefine`. Without boot mode, and with `--daemon`,
+  `--test-command` or `--dry-run`, the flag warns that it has no effect.
+
+### Changed
+
+- **Rails test workers stay off during a mutant run.** Mutineer sets
+  `PARALLEL_WORKERS` to `1` for in-process, `--daemon`, and `--test-command`
+  runs. A value you already set is replaced, and Mutineer prints one line.
+  The coverage cache stores the `PARALLEL_WORKERS` value, so a cache from an
+  older version rebuilds once. `--test-command` also sets `DISABLE_SPRING=1`.
+  The README explains `parallelize`, Bootsnap, and Redis after a fork.
+- **`--test-command` exit codes 126 and 127 are scored `error`, not
+  `killed`.** A wrapper that could not start the suite ran no test. Under
+  `--threshold`, such a run can now score lower or fail the no-verdict limit,
+  where before it passed on false kills.
+- **A run with errored mutants and no `--threshold` says so.** Errors are not
+  in the score, so they do not fail the run; the message says what
+  `--threshold` would enforce.
+- **`--since` also narrows suppressed mutants.** A scoped report lists only
+  `ignored` mutants on changed lines, as `--dry-run --since` already did.
+- **The empty-run message moved from the human report to one stderr warning
+  for every format.** "No mutations generated" is gone. An empty `--since`
+  run prints "nothing to test in the changes since REF" instead.
+
+### Fixed
+
+- **Daemon errors no longer show the database password.** Rails parses
+  `DATABASE_URL` itself, and a malformed URL makes it raise an error that
+  quotes the whole URL. The daemon sent that error to the terminal when
+  the app failed to boot, and the same could happen when it set up worker
+  databases or the coverage map, and in a `--verbose` coverage warning.
+  Mutineer now replaces the password in any URL, and the `DATABASE_URL`
+  password anywhere else (escaped or cut short included), with
+  `[REDACTED]` before it reports the error.
+- **`--strategy reload` runs concern files with an `included` or `prepended`
+  block (#256).** Every mutant in such a file was `errored`: ActiveSupport
+  raised `MultipleIncludedBlocks` (or `MultiplePrependBlocks`) because the
+  mutant loads from a temp file with another path. Before each reload mutant
+  loads, in-process and on the daemon, the forked child now forgets the blocks
+  that the source file stored, so methods in the concern body and in
+  `class_methods` are killed or survive as usual. A block the mutant's load
+  does not store again (a concern under an `unless defined?` guard) is put
+  back. A method inside an
+  `included` or `prepended` block is `unplaceable` under reload too: the block
+  does not run again in a class that already includes or prepends the
+  concern, so the mutant would falsely survive. That includes a method of a
+  class defined inside the block. Use `--test-command` to run those mutants.
+- **No heredoc opener without its body.** A mutation that kept a heredoc
+  opener but replaced the lines of its body gave source that does not parse,
+  such as `operand_removal` on `foo(<<~EOS) ||` with the body and `bar` on
+  the next lines. The mutant showed only as `skipped (invalid)`. Now the
+  operator does not emit it.
+- **An RSpec run that fails only on an error outside examples scores the
+  mutant `errored`, not `killed`.** A spec file that raised while loading, or
+  a failing `before(:suite)` hook, made RSpec exit 1, and every mutant was
+  scored `killed`. On a Rails app, `rails_helper` called `SimpleCov.start`
+  after `--rails` had suspended Coverage (#228), so each spec file raised as
+  it loaded, and 18 of 18 mutants were scored `killed`; 3 of them survive.
+  Now the runner returns 2 when RSpec recorded an error outside examples and
+  no example failed, so the mutant is `errored`: out of the score and in
+  `no_verdict`, so that run now fails `--threshold` instead of passing at
+  100%. A failed example still kills.
+  Minitest and `--daemon` already score a test file that raises at load as
+  `errored`. `--test-command` sees only the exit status and still scores it
+  `killed`.
+- **A Rails daemon boots again while a mutant file is still open.**
+  The file stays when another process holds it. The next boot skips
+  that file name instead of stopping.
+- **A daemon crash no longer leaves a mutant file in your source folder
+  (#250).** When a daemon dies during a mutant, its child dies a moment
+  later. The new daemon cleaned up before that, so the child's file stayed.
+  The next Rails boot then failed on the file name. Each daemon run now
+  cleans up again when it ends or stops early. It waits up to 1.5 seconds
+  for the child to go. A file whose owner still runs after that stays
+  until the next daemon run removes it. On Linux, a file whose owner is a
+  zombie (in a container whose pid 1 does not reap it) is now removed.
+  With `--jobs N`, an error in one worker stops the others after their
+  current mutant, and a Ctrl-C quits every worker daemon before the run
+  ends.
+- **SimpleCov in a test helper no longer breaks every mutant under
+  `--rails` or `--boot` (#248).** After the coverage map is built, mutineer
+  pauses Ruby's coverage (#228). SimpleCov saw the paused coverage as off and
+  tried to start it. Ruby refuses that while coverage is paused, so the test
+  helper raised in every mutant. Now a start in a mutant first stops the
+  paused coverage. A mutant whose tests start nothing keeps it paused and pays
+  nothing. This applies to `--daemon` too.
+- **Methods in an ActiveSupport::Concern `class_methods` block are mutated
+  under `--strategy redefine` (#252).** ActiveSupport puts these methods in
+  the concern's `ClassMethods` module, and each includer gets them as class
+  methods. Mutineer named them as instance methods of the concern itself.
+  Redefine (the `--rails` default) then loaded each mutant onto the concern.
+  The tests called the includer's method, so every mutant falsely survived.
+  A concern with an instance method of the same name failed the other way:
+  the mutant replaced that instance method, so tests calling it ran the
+  wrong method and failed (an ArgumentError, when the arities differ), and
+  the mutant counted as killed whatever it changed. Both false survivors
+  and false kills are gone. An earlier redefine score is unreliable for
+  any file with a `class_methods` block: too low from false survivors, or
+  too high from false kills. Re-run those files.
+  These methods are now named `Concern::ClassMethods#name`, and redefine
+  loads the mutant onto that module. This applies to a module that ran
+  `extend ActiveSupport::Concern` earlier in the same file. The mutant ids of
+  these methods change, because an id contains the qualified name (owner and
+  method). An instance
+  method with the same name, later in the same file, can get a new id too.
+  An `ignore:` entry or a `--baseline` survivor for one of these methods no
+  longer matches. Replace it with the new id from a new run.
+- **Methods in other `class_methods`, `included` and `prepended` blocks are
+  `unplaceable` under `--strategy redefine` (#252).** ActiveSupport runs an
+  `included` or `prepended` block in each includer, so no constant names the
+  class that owns its methods. A `class_methods` block that Mutineer cannot
+  tie to a concern has the same problem: one in a def, in Rails'
+  `concerning`, in an unassigned `Module.new`, or in a module that does not
+  run `extend ActiveSupport::Concern` earlier in the file. Redefine loaded each
+  mutant onto the enclosing module, and the mutant could falsely survive. Now
+  redefine reports these mutants as `unplaceable` and does not run them. Like
+  every `unplaceable` mutant, they leave the score and do not count toward
+  `--threshold`, so a gate that failed on these false survivors can now pass.
+  Their names and mutant ids do not change. `--strategy reload` runs them, except a
+  method in an `included` or `prepended` block (see #256 above). Another library's
+  method with one of these names is `unplaceable` under redefine too, even
+  when that library runs the block in the module itself and redefine used to
+  run it correctly. Mutineer cannot tell that library from ActiveSupport, so it
+  does not guess. For that other library's mutants, use `--strategy reload`.
+- **A file in a namespace directory scores under `--rails --strategy reload`
+  and `--rails --daemon` (#253).** Mutineer writes each mutant to a temp file
+  next to the source and loads it. With lazy loading, loading it can be the
+  first time Zeitwerk scans that directory, such as `app/models/billing/`.
+  Zeitwerk then raised `Zeitwerk::NameError` on the temp file's name, and the
+  mutants of the file errored. Parallel daemon workers hit the same error on
+  each other's files. Now the temp files are hidden: `.mutineer_mutant*.rb`
+  and `.mutineer_daemon*.rb`. Zeitwerk skips hidden files, in every loader.
+  The cleanup sweeps still remove a file an older version left without the
+  dot. Each mode sweeps its own files before the app boots: an in-process run
+  now removes an old `mutineer_mutant*.rb` first, and the daemon removes an
+  old `mutineer_daemon*.rb`. An old file of the other mode still stops the
+  boot, so delete it by hand. Eager loading, the default on CI, scans every
+  directory at boot, so it never hit the error.
+- **A mutant on a later line of a multi-line `&&` or `||` can be killed
+  (#254).** Ruby counts only the first line of a statement. For code that runs
+  only sometimes on a later line, such as the right side of `verified &&` on
+  its own line, Mutineer picked no tests, so the mutant was always
+  `no_coverage`, however good the tests were. Now it runs the tests that ran
+  the statement. A kill counts. A survivor stays `no_coverage`, because the
+  run cannot tell whether those tests reached it, so no survivor is added and
+  a score can rise with no test change. Such a mutant can now also end as
+  `errored` or `timeout`; like any mutant with no verdict, that counts toward
+  the `--threshold` completeness check, so a failure is reported, not hidden.
+  This also applies to a later `when` condition, the value of `x rescue y`,
+  `&.` arguments and an `||=` value on a later line, and to `--daemon`. A
+  branch of a ternary or `if`, and the body of `x if c`, keep the verdict they
+  had before.
+
+## [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
@@ -926,6 +1397,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.7.0]: https://github.com/davidteren/mutineer/releases/tag/v1.7.0
+[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