henitai 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0530ecd98105a394b4466cbe23704f848565c55e318c35a31e096eedc2cba299
-  data.tar.gz: 56c64c5b679b0bc7c66691a4a7b20c274ac90d1d812d7abb65e778190cd6bb39
+  metadata.gz: 4c9ef6e2d806e8d12acfd36adda062192c5cf4ba700ee140ce7d6ad848eff0c8
+  data.tar.gz: 800ba49ba72ce0ab6090e1ab9b40ea5146559738e59af5a81ceeb80923bc974e
 SHA512:
-  metadata.gz: e8725233ea8c806ca65fc488560daafbfc2300f723a054039b29dd45625a935217ebdbe609fde3e2df693299ee5ca069d35ce00b63a4e9a4d90dcfa9e77e2920
-  data.tar.gz: d8052c091f3967d1cc873cb34b02f04ad339714f08950841f65e7ef1ff064573bb0f54226eb3725d29dd3e7a42727d535b469396c76aa0a0ae2ffb5ae1075336
+  metadata.gz: 60acc4fc6df82c4d273c110302af6a73b7c4f7d6f3ebb2ae9fdcea06ca69e5cef2e61945c396b38810f978b8ace3db2b988d224b637d0f8f11c02ccb03eee368
+  data.tar.gz: 9fe40adf6368041348247af329f3153a0027e89bbbe60e9dcdef27a4a666512446ab7569188e891ec7eb2f5fe8419c33eeee2ed1778a5b034c97901ca94a095c

data/CHANGELOG.md

@@ -7,6 +7,226 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-10-20
+
+Minor release with a deliberate score break: false kills and harness
+failures no longer count as detected mutants, so most projects, including
+Henitai's own dogfood run, will report lower Mutation Scores. Re-measure
+before adjusting thresholds.
+
+### Changed
+
+- **Scores will drop, by design.** A mutant now counts as detected only when a
+  test failed because of its mutation (ADR-14). Harness failures that used to
+  be credited as kills are now reported as `CompileError` or `RuntimeError`,
+  with the reason in `statusReason`. On an assertion-free test suite, 0.5.3
+  reported 130 of 137 mutants as killed; this release reports none. Projects
+  should expect lower Mutation Scores. Re-measure before adjusting thresholds.
+- **Flaky-test handling.** Survivors are no longer retried: a retry could only
+  turn a survivor into a kill and inflate the score. Kills are re-checked, up
+  to `max_flaky_retries`, only when every failing test file is known to be
+  flaky, as found by the new opt-in `mutation.flaky_detection` (baseline suite
+  runs twice; flaky files go to `henitai_flaky_tests.json`, removed by
+  `henitai clean`). Without it nothing is retried, so runtime on survivor-heavy
+  suites drops. The ">5% of mutants needed a retry" warning is replaced by a
+  report of flaky tests and re-checked kills. Child reports now carry
+  `failed_tests`. Failures outside an example (an `after(:context)` hook error,
+  a suite-level hook, a Minitest result without a file) are attributed to their
+  spec file when RSpec names it; otherwise the run is flagged
+  `unattributed_failures`, which makes a kill genuine (never retried) and makes
+  the flaky baseline reject the run. Baseline runs that fail on a file the two
+  runs cannot call flaky (for example one seen in a single run) now abort
+  instead of being accepted. Minitest outcomes are keyed to the file defining
+  the test class, not to a shared module that supplies the test method.
+- Mutant runs are classified from an explicit report written by the child
+  process instead of from its exit status. An exception while activating the
+  mutant (for example a `NameError` from a superclass defined in another file)
+  is `CompileError`, not `Killed`. A child killed by a signal, or one that
+  exits without reporting, is `RuntimeError`, not `Killed`. A `SystemExit`
+  raised by the code under test is `RuntimeError`, not `Survived`.
+- Mutants are activated only after the spec or test files have loaded, so a
+  subject whose superclass or constants live in other files can be tested.
+  Previously the child loaded the subject file on its own and failed with a
+  `NameError` (every `ApplicationRecord` model, for example).
+- Mutants are activated by re-evaluating the subject's own `def` inside its
+  original module and class openers (ADR-13), not through `define_method`.
+  Constant lookup through enclosing modules, implicit `super`, `yield`,
+  `block_given?`, argument forwarding, default values, `__FILE__`/`__LINE__`,
+  `frozen_string_literal` and visibility now behave as in the original method.
+  Mutations in default values take effect, and splices no longer shift after
+  multibyte characters or leave heredoc bodies behind. Activation recipes from
+  earlier versions are ignored and regenerated.
+
+### Added
+
+- `mutation.sampling.seed` (integer >= 0, default `0`) and real stratified
+  sampling: per subject `max(1, ceil(size * ratio))` mutants, strata by
+  operator ordered by `SHA256(seed, stable_id)`, visited round-robin, original
+  order kept. The report records `"sampling": {strategy, ratio, seed}`.
+- Report fields: top-level `completeFiles` (non-authoritative runs) and
+  per-file `sessionId` and `gitSha` provenance.
+- `rake oracle:reuse` (run in CI): on a scratch copy of the oracle corpus, the
+  `--incremental` verdicts must equal a fresh full run after scripted edits to
+  source, tests, a helper and the configuration.
+- **Fork server for Minitest and parallel runs.** `mutation.fork_server`
+  (opt-in, ADR-15) now supports Minitest and `jobs > 1`: the environment is
+  booted once and each mutant process is forked from the server. Falls back to
+  per-mutant boot with a warning if the server is unavailable.
+- A fidelity check rejects, before execution, every mutant whose activated
+  code differs from the original method by more than the reported mutation.
+  Examples are a negated condition that lost its parentheses, keyword
+  arguments re-rendered as a positional hash, `|x|` re-rendered as `|x,|`, a
+  splice shifted by a multibyte character, and a removed assignment that turns
+  a later local-variable read into a method call. Such mutants are reported as
+  `CompileError` with the reason.
+- `mutation.control_runs` (default `true`): after execution, every subject
+  with a detected verdict runs once more with its unmutated method injected.
+  If its tests fail, the subject's detected verdicts are reclassified as
+  `CompileError`, because the injection itself broke them.
+- Methods defined in a constructor block assigned to a constant
+  (`Point = Struct.new(:x) do ... end`, likewise `Data.define` and
+  `Class.new`) and in `class << CONST` are now subjects. Top-level
+  `def Const.name` methods are subjects as well.
+- `rake oracle` runs a corpus whose verdicts follow from its construction and
+  fails on false kills or false survivors. CI runs it.
+
+### Fixed
+
+- **Verdict reuse is bound to a reuse context.** `--incremental` reused stale
+  `Killed` verdicts after a spec helper, the configuration or the henitai
+  version changed. Every cached `Killed` and `Survived` verdict now stores a
+  `ReuseContext` fingerprint (test dependency files, henitai version,
+  integration, operators, `test_excludes`, `coverage_criteria`) and is reused
+  only under an identical one; rows recorded without it are never reused.
+  `rake oracle:reuse` reproduced 121 mismatches against fresh runs after a
+  helper edit before the fix and none after it.
+- **`--survivors-from` no longer skips survivors on a git heuristic.** The
+  selected survivors go through the same content-fingerprint reuse rules as
+  `--incremental`, always: new or edited tests and helpers invalidate them,
+  reused survivors are reported with `fromCache`, and recipe stubs without a
+  source range are always re-executed. `SurvivorTestFilter` is removed.
+  The recipe fast path now refreshes coverage (Gate 0) so new or edited tests
+  are selected, recipe stubs also run their name-matched tests, and survivor
+  reruns never sample (sampling had dropped prior survivors before matching).
+  `--force` now also bypasses this reuse. Duplicate programs are collapsed
+  before sampling, so a sampled run keeps the same representative as an
+  unsampled survivor rerun and its survivors are found again.
+- A survived verdict whose covering-test fingerprint cannot be recomputed keeps
+  stored fingerprints only from a survived row of the same subject source,
+  never from a killed row or an edited method.
+- Gate 1 source selection has its own per-test coverage instance, so reuse and
+  history read the post-bootstrap per-test map.
+- Recipe stubs keep their precomputed stable ID and persist the `replacement`
+  source in the history store.
+- **Trend history only records authoritative runs.** `--since`,
+  subject-scoped and survivor-rerun results no longer add a `runs` row.
+- **Canonical report merge.** A scoped run that mutated every subject of a file
+  replaces that file's prior entry wholesale (and removes it when it has no
+  mutants), so stale mutants of edited or deleted code no longer linger.
+  `--survivors-from <canonical report>` redirects to the session snapshot only
+  when every file entry carries the report's `sessionId`; a file whose every
+  prior mutant was re-run takes the new run's provenance.
+- `--since` diffs against the merge base (`REF...HEAD`) instead of the ref's
+  tip, so commits that landed on the base branch after the fork point are not
+  treated as changes.
+- The dashboard reporter uploads the merged canonical report for scoped runs
+  instead of the partial one.
+- `Pending` mutants are excluded from the MS and MSI denominators; MSI is
+  `killed / (total - pending)`.
+- **Equivalence detection only flags sound cases.** `false || x` and
+  `true && x` (left literal only); `n + 0`, `n * 1` and siblings only for
+  Integer/Float literal receivers (not `-0.0`); `==` <-> `eql?` only when both
+  operands are string literals; `==` <-> `equal?` for singleton literals.
+  Unsound rules (`x || false`, `x && true`, unknown receivers, a single string
+  literal) no longer mark mutants `Equivalent`.
+- **`mutation.ignore_patterns` is line-scoped.** A pattern is matched against
+  the source line where the mutant's node starts, in `StaticFilter`; matching
+  mutants are reported as `Ignored` with an `ignore_reason` instead of being
+  dropped at generation time. An enclosing construct whose body matches is no
+  longer suppressed. The line is decoded honouring a magic encoding comment,
+  so a non-UTF-8 source file no longer aborts filtering.
+- **Review follow-ups.** The slot scheduler no longer signals the process
+  group of a reaped pid that owns no mutant slot. Minitest results for tests
+  added by reopening a class in another file are attributed to the file that
+  defines the method, so coverage-first selection no longer misses them. With
+  the fork server active, calibrated timeouts keep the measured suite boot
+  (served mutants still run `before(:suite)` hooks). The `fork_server` schema
+  description and the remediation plan now state the real scope (RSpec and
+  Minitest, any `jobs`).
+- **`--incremental` no longer reuses stale survived verdicts for def-line
+  mutants.** Their test selection is widened with name-matched tests that the
+  survivor fingerprint does not cover, so survived verdicts for mutants on a
+  method's def line always re-execute (killed reuse is unaffected: a kill by
+  an unchanged covering test remains valid).
+- **Output capture no longer delays or races on lingering grandchildren.**
+  Closing a mutant child's captured stdout/stderr no longer waits up to 1 s
+  per stream for EOF and no longer kills the drain thread mid-write (which
+  could exceed the cap or write the truncation marker twice). The drain
+  thread is stopped cooperatively through a stop pipe and takes what is
+  already readable.
+- **Fork-server lifecycle.** A server lost or stalled mid-run no longer turns
+  its in-flight mutants into `runtime_error`: they are rerun through the
+  per-mutant-boot fallback. Fallback runs use boot-inclusive timeouts. Mutant
+  processes forked by the server are cleaned up on timeout, loss and teardown
+  even before they lead a process group, and the connection and wake-pipe fds
+  are no longer inherited by mutant processes. The parallel event loop no
+  longer stalls on an exit event already buffered in the client, and the
+  SIGTERM drain window always runs its full length.
+- The "negated condition" mutant now negates the whole condition
+  (`!(a > b)`), not just its left operand (`!a > b`).
+- Source files are read as UTF-8 regardless of the process locale. With `LANG`
+  unset or `C`, any non-ASCII source file used to abort subject resolution.
+- Per-test coverage now narrows RSpec test selection. RSpec records test files
+  as `./spec/x_spec.rb` while candidates arrive as `spec/x_spec.rb`, so the
+  lookup never matched and every mutant ran all candidate files.
+- `--since` and the dirty-source and survivor checks now work for a project in
+  a sub-directory of its git repository and for non-ASCII file names.
+- A corrupt or locked `mutation-history.sqlite3` no longer discards the run's
+  reports. History recording and export now warn instead.
+- Forked mutant children reset the INT, TERM, HUP and CHLD handlers inherited
+  from the parent, so a draining SIGTERM is no longer ignored.
+- A zero-example check no longer matches `10 examples, 0 failures`, nor a
+  `No examples found.` or `0 examples, 0 failures` quoted in failure output;
+  only the run's last summary line counts. Such kills were reported as
+  `CompileError`.
+- A run in which harness errors (`CompileError`) left no mutant to score now
+  exits `1` with a warning instead of passing its threshold with nothing
+  tested.
+- Mutating an `elsif` condition no longer rewrites the whole `if` chain; only
+  the condition changes.
+- String parts of interpolated strings, symbols, backticks and regexps, and
+  elements of `%w` arrays, are no longer mutated as standalone strings. Their
+  replacement text changed the literal's syntax rather than its value.
+- Operator replacements are parenthesised when spliced, so `a && b && c`
+  mutated to `a || b` no longer reads as `a || (b && c)`.
+- Two mutants at the same position with the same description no longer share
+  one stable identity and history entry.
+- `ReturnValue` mutates only the method's final expression, not every
+  expression that happens to equal it.
+- Subject expressions for predicate, bang, setter and operator methods, such
+  as `Foo#empty?`, `Foo#save!`, `Foo#name=` and `Foo#==`, select their method
+  instead of nothing.
+- Mutants from different operators that produce the same program run once.
+- The implicit value of a shorthand hash pair (`build(config:)`) is no longer
+  mutated. Its replacement rewrote the key to `build(nil:)`.
+- A mutant that removes the only assignment of a local variable read later in
+  the method is no longer generated. Ruby parses the later read as a method
+  call, so every such mutant failed with a `NameError` wherever it ran.
+- Subjects are attributed to the right namespace. A `class ::Top` inside
+  `module Outer` is `Top`, not `Outer::Top`. A `def Other.name` inside `Outer`
+  belongs to `Other`, not `Outer`. Methods of `class << obj` or `def obj.name`
+  for a non-constant `obj` are no longer reported as class methods of the
+  enclosing class.
+- "replaced method call with nil" on a call with a block replaces the call
+  together with its block. Replacing only the call left `nil { ... }`, which
+  does not parse, so these sites were never tested. Blocks attached to
+  logger, output and debug calls stay arid.
+- `RegexMutator` no longer drops the interpolations and later lines of a
+  dynamic or multi-line regexp, which it now leaves unmutated. It skips
+  escaped characters and the contents of character classes, so `[^0-9]` is
+  no longer reported as a removed `^` anchor and `[+-]` no longer as a
+  quantifier swap.
+
 ## [0.5.3] - 2026-08-26
 
 ### Fixed
@@ -588,7 +808,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - CLI critical path: `henitai run` now executes the full pipeline, supports `--since`, returns CI-friendly exit codes, and `henitai version` prints `Henitai::VERSION`
 - RSpec per-test coverage output: `henitai/coverage_formatter` now writes `coverage/henitai_per_test.json`
 
-[Unreleased]: https://github.com/martinotten/henitai/compare/v0.5.3...HEAD
+[Unreleased]: https://github.com/martinotten/henitai/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/martinotten/henitai/compare/v0.5.3...v0.6.0
 [0.5.3]: https://github.com/martinotten/henitai/compare/v0.5.2...v0.5.3
 [0.5.2]: https://github.com/martinotten/henitai/compare/v0.5.1...v0.5.2
 [0.5.1]: https://github.com/martinotten/henitai/compare/v0.5.0...v0.5.1

data/README.md

@@ -82,12 +82,17 @@ test_excludes:
 mutation:
   operators: light   # light | full
   timeout: 10.0
+  timeout_multiplier: 3.0
   max_flaky_retries: 3
+  flaky_detection: false   # run the baseline twice to find flaky test files
   max_log_bytes: 5000000
   max_timeout: 30.0
+  control_runs: true   # re-run detected subjects with the unmutated method
+  fork_server: false   # opt-in: boot the RSpec/Minitest environment once, fork each mutant run from it (any jobs; falls back to per-mutant boot with a warning)
   sampling:
     ratio: 0.05
     strategy: stratified
+    seed: 0   # integer >= 0; selects which mutants of each stratum are kept
 reports_dir: reports
 reporters:
   - terminal
@@ -118,25 +123,79 @@ baseline suite has a fixed timeout. Lines covered only by excluded tests count
 as uncovered and are not mutated. Excluding every test file aborts with
 `Henitai::ConfigurationError`.
 `mutation.max_log_bytes` is a positive per-stream byte cap for captured child
-output. `mutation.max_timeout` caps auto-calibrated timeouts; an explicit
+output. Without an explicit `mutation.timeout`, each mutant's timeout is
+calibrated as `mutation.timeout_multiplier` (default `3.0`) × (the summed
+durations of the selected test files + the measured suite boot time), with a
+2 s floor. `mutation.max_timeout` (default `30.0`) caps the calibrated value,
+but never below the measured baseline plus 2 s; when the baseline alone exceeds
+`max_timeout`, Henitai warns once and uses baseline + 2 s. An explicit
 `mutation.timeout` still takes precedence. When JSON or HTML reporting is
 enabled, `reports.checkpoint*` controls periodic canonical-report checkpoints.
 Each checkpoint updates `mutation-report.json`; when the HTML reporter is
 configured, it also regenerates `mutation-report.html` from that merged JSON.
 
+`mutation.sampling` keeps `ceil(size * ratio)` mutants per subject (at least
+one). Mutants are stratified by operator: each operator's mutants are ordered
+by a SHA256 of `seed` and the mutant's stable ID, and the strata are visited
+round-robin, so every operator is represented before any contributes a second
+mutant. The kept mutants retain their original order. The same seed selects the
+same mutants across runs and line shifts; change `seed` to draw another sample.
+The applied `{strategy, ratio, seed}` is recorded in the report under
+`sampling`.
+
+Scoped runs (`--since`, subject patterns, survivor reruns) are merged into the
+existing `mutation-report.json` by `stableId`. A run that mutated every
+subject of a file (a non-authoritative run without subject patterns, such as
+`--since`) lists it under the top-level `completeFiles` and replaces that
+file's prior entry wholesale, dropping it when it yields no mutants, so stale
+mutants of edited or deleted code do not linger. Each file entry carries
+`sessionId` and `gitSha` provenance of the run that produced it; a file merged
+from several sessions has none. `--since` diffs against the merge base
+(`REF...HEAD`), so commits that landed on the base branch after you forked do
+not count as your changes.
+
 Before mutation testing starts, Henitai checks whether the current coverage data
 covers the configured source files. If not, Henitai runs the configured test
 suite once to bootstrap a usable coverage baseline. If coverage is still
 unavailable for the current sources, `henitai run` aborts with
 `Henitai::CoverageError`.
 
-Surviving mutants are retried up to `mutation.max_flaky_retries` times before
-they are classified as survivors. The default retry budget is 3.
+Survivors are never retried: flakiness can only turn a survivor into a kill, so
+a retry could only inflate the score. A killed mutant is retried, up to
+`mutation.max_flaky_retries` times (default 3), only when every test file that
+failed for it is a known flaky test; if any retry survives, the mutant is
+reported as `Survived`.
+
+Known flaky tests come from the opt-in `mutation.flaky_detection: true`. The
+baseline suite then runs twice (existing coverage is not reused), and test files
+whose pass/fail outcome differs between the runs are written to
+`reports/henitai_flaky_tests.json`. Without `flaky_detection` there is no flaky
+set and nothing is retried. At the end of the run Henitai reports the flaky
+tests and how many kills were re-checked.
+
+A mutant only counts as detected when a test failed because of the mutation.
+Before a mutant runs, Henitai checks that its activated code differs from the
+original method by exactly the reported mutation; a mutant that fails this
+check is reported as `CompileError` with the reason in `statusReason` instead
+of running. Each mutant child reports what it got to — a failed activation, a
+finished test run, or a `SystemExit` raised by the code under test — and only
+a finished test run yields `Killed` or `Survived`. A failed activation is a
+`CompileError`; a child killed by a signal, one that exits without reporting,
+and a `SystemExit` during the tests are `RuntimeError`. With
+`mutation.control_runs` (on by default), every subject that has detected
+mutants is run once more with its unmutated method injected; if its tests fail
+then, the injection itself is broken for that subject and its detected
+verdicts are reclassified as `CompileError`.
 
 Per-test coverage reporting is currently wired through the RSpec child runner.
 Minitest integration reuses the same selection and execution flow, but does not
 yet enable the per-test coverage formatter.
 
+Test selection is coverage first: the per-test coverage map is the primary source
+of candidate tests for a mutant, and name matching is only the fallback for when
+the map cannot decide (no map, no location, or no covering test left in the
+integration).
+
 Henitai currently defaults to linear mutant execution. Set `jobs` in
 `.henitai.yml` or pass `--jobs N` to opt into parallel mutant execution.
 
@@ -161,6 +220,13 @@ for framework errors. With `--strict-exit-codes` (opt-in, additive) it also
 exits `3` when one or more mutants timed out and `4` when runtime/compile
 errors are present; precedence `2` > `3` > `4` > `1` > `0`. The timeout code
 is informational — a run can pass its threshold and still exit `3`.
+A run with no scoreable mutant passes its threshold only when there was
+nothing to score (no changed code, everything ignored). When `CompileError`
+harness errors emptied the score denominator, nothing was tested, and the run
+exits `1`.
+`Pending` mutants (left over from an interrupted run, without a verdict) are
+excluded from both the MS and the MSI denominators; MSI is
+`killed / (total - pending)`.
 
 For pull-request feedback, add the `github` reporter to `reporters:` in
 `.henitai.yml`: it prints one `::warning file=...,line=...` workflow command
@@ -174,10 +240,13 @@ and every covering test file are byte-identical to what was recorded. A
 `Survived` verdict needs more proof, because a *new* test could now kill it:
 it is reused only when, additionally, the live covering set derived from the
 current per-test coverage map matches the recorded set exactly (no test
-added, dropped, or changed) and the dependency fingerprint (spec helpers,
-`spec/support`, fixtures/factories, `Gemfile.lock`, `.henitai.yml`, `.rspec`)
-is unchanged. When per-test coverage is unavailable, survivors simply
-re-execute — reuse never happens on doubt (see ADR-11).
+added, dropped, or changed). Both kinds additionally require the *reuse
+context* to be unchanged: a fingerprint of the test dependency files (spec
+helpers, `spec/support`, fixtures/factories, `Gemfile.lock`, `.henitai.yml`,
+`.rspec`), the henitai version, the integration, the operator set,
+`test_excludes` and `coverage_criteria`. Verdicts recorded without a reuse
+context are never reused. When per-test coverage is unavailable, survivors
+simply re-execute — reuse never happens on doubt (see ADR-11).
 Reused mutants stay visible in the report (`fromCache: true` beside
 `stableId`) and count toward MS/MSI; the terminal prints
 `N of M verdicts reused from history (K killed, S survived)` plus an
@@ -186,7 +255,8 @@ results.
 Generated mutants temporarily include `legacyStableId` so scoped runs replace
 canonical entries written before site-offset IDs were introduced instead of
 duplicating them.
-Timeouts and errors always re-execute. `--force` bypasses reuse.
+Timeouts and errors always re-execute. `--force` bypasses reuse, including
+the reuse applied to `--survivors-from` reruns.
 `henitai run --dry-run` lists the post-filter mutant set without executing
 mutants and always exits `0`. Gate 0 may still run the configured test suite to
 refresh baseline coverage.
@@ -201,9 +271,20 @@ authoritative, and the file may be the only artifact a dry run creates.
 
 `henitai run --survivors-from ...` performs a partial rerun: it reports only
 the selected survivors, skips threshold-based exit checks, and does not update
-the run trend history. Dirty worktree changes are included, so you can edit
+the run trend history. The selected survivors go through the same reuse rules
+as `--incremental`, always, not only with that flag: a survivor is skipped
+(reported with `fromCache: true`) only when its subject source, its covering
+test set and the reuse context are unchanged, so new or edited tests and
+helpers invalidate it. Dirty worktree changes are included, so you can edit
 tests locally without committing first; if source files under `includes` are
-dirty, Henitai reruns the matched survivors conservatively.
+dirty, the activation-recipe fast path is not used and the survivors are
+re-matched against freshly generated mutants. Survivors restored from
+activation recipes have no source range to fingerprint and are always
+re-executed. When `--survivors-from` names a canonical report, Henitai uses the
+matching session snapshot only if every file entry carries that report's
+`sessionId`; a report merged from several runs is used as is.
+Only authoritative runs (no `--since`, no subject patterns, no survivor rerun)
+add a row to the trend history.
 
 ### Skipping mutations inline
 
@@ -226,8 +307,11 @@ standalone comment in the contiguous comment block directly above a `def`
 (a blank line breaks the association). Trailing text is allowed
 (`# henitai:disable -- reviewed defensive branch`). Skipped mutants are
 reported as `Ignored`, so they stay visible in the report instead of silently
-vanishing. Use `mutation.ignore_patterns` for repo-wide policy and
-`# henitai:disable` for one-off, reviewed exclusions.
+vanishing. `mutation.ignore_patterns` is matched against the source line where
+each mutant's node starts, so only mutants on a matching line are reported as
+`Ignored`; an enclosing `if` or block whose body matches stays mutated. Use
+`mutation.ignore_patterns` for repo-wide policy and `# henitai:disable` for
+one-off, reviewed exclusions.
 
 Directives can also target specific operators, carry a reason (serialized as
 `statusReason`, visible in the HTML report), and cover regions:
@@ -307,7 +391,8 @@ dashboard:
 Set `STRYKER_DASHBOARD_API_KEY` in your CI environment to publish reports. When
 the key, project, and version are present, the `dashboard` reporter uploads the
 Stryker-schema report to the dashboard REST API (default
-`https://dashboard.stryker-mutator.io`); otherwise it is skipped silently. The
+`https://dashboard.stryker-mutator.io`); otherwise it is skipped silently.
+Scoped runs upload the merged canonical report rather than their partial one. The
 project defaults to the git remote and the version to the current branch or CI
 ref (`GITHUB_REF_NAME`/`GITHUB_REF`/`GITHUB_SHA`).
 
@@ -323,6 +408,8 @@ bundle install
 bundle exec rspec        # run tests
 bundle exec ruby bin/verify-process-free-specs # verify self-mutation-safe specs
 bundle exec rake smoke:integration:all # run rspec/minitest integration smoke projects
+bundle exec rake oracle # measure false kills/survivors on the oracle corpus
+bundle exec rake oracle:reuse # check --incremental verdicts equal fresh runs
 bundle exec rubocop      # lint
 bundle exec henitai clean # remove stale generated report artifacts
 bundle exec henitai run  # dogfood

data/assets/schema/henitai.schema.json

@@ -65,6 +65,21 @@
           "type": "number",
           "exclusiveMinimum": 0
         },
+        "flaky_detection": {
+          "type": "boolean",
+          "default": false,
+          "description": "Run the baseline suite twice and mark test files whose outcome differs between runs as flaky. Only killed mutants whose killing tests are all flaky are re-checked, up to max_flaky_retries times."
+        },
+        "fork_server": {
+          "type": "boolean",
+          "default": false,
+          "description": "Opt-in. Boot the test environment once in a long-lived fork server and fork each mutant run from it instead of re-booting per mutant. Supported for RSpec and Minitest with any jobs value; unsupported integrations and a server that fails to boot fall back to per-mutant boot with a warning."
+        },
+        "control_runs": {
+          "type": "boolean",
+          "default": true,
+          "description": "After execution, re-run each subject that has detected mutants with its unmutated method injected; if its tests fail, the subject's detections are reclassified as CompileError."
+        },
         "ignore_patterns": {
           "type": "array",
           "items": {
@@ -83,6 +98,11 @@
             },
             "strategy": {
               "enum": ["stratified"]
+            },
+            "seed": {
+              "type": "integer",
+              "minimum": 0,
+              "default": 0
             }
           }
         }

data/lib/henitai/arid_node_filter.rb

@@ -10,32 +10,17 @@ module Henitai
     INVARIANT_METHODS = %i[is_a? respond_to? kind_of?].freeze
     DSL_METHODS = %i[let subject before after].freeze
 
-    def suppressed?(node, config)
-      custom_pattern_match?(node, config) || catalog_match?(node)
+    def suppressed?(node)
+      catalog_match?(node)
     end
 
     private
 
-    def custom_pattern_match?(node, config)
-      source = node.location&.expression&.source
-      return false unless source
-
-      compiled_ignore_patterns(config).any? do |pattern|
-        pattern.match?(source)
-      end
-    end
-
-    def compiled_ignore_patterns(config)
-      patterns = Array(config&.ignore_patterns).dup.freeze
-      @compiled_ignore_patterns ||= {}
-      @compiled_ignore_patterns[patterns] ||= patterns.map { |pattern| Regexp.new(pattern) }
-    end
-
     def catalog_match?(node)
       case node.type
       when :send
         send_match?(node)
-      when :block
+      when :block, :numblock
         block_match?(node)
       when :or_asgn
         # Memoization-style ||= is treated as arid on purpose. UpdateOperator
@@ -64,7 +49,7 @@ module Henitai
       return false unless send_node&.type == :send
 
       receiver, method_name, = send_node.children
-      receiver.nil? && DSL_METHODS.include?(method_name.to_sym)
+      (receiver.nil? && DSL_METHODS.include?(method_name.to_sym)) || send_match?(send_node)
     end
 
     def direct_output_call?(receiver, method_name)

data/lib/henitai/bootstrap_error_message.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Explains a failed baseline suite run, pointing at its log when one exists.
+  module BootstrapErrorMessage
+    GENERIC = "Configured test suite failed while generating coverage"
+
+    module_function
+
+    def build(result)
+      return GENERIC unless result.respond_to?(:log_path)
+
+      tail = result.tail(12).strip
+      message = +GENERIC
+      message << " (see #{result.log_path})"
+      message << "\n#{tail}" unless tail.empty?
+      message
+    end
+  end
+end

data/lib/henitai/canonical_report_merger.rb

@@ -11,6 +11,11 @@ module Henitai
   # falls back to the current run's schema by itself -- structurally never
   # worse than the unconditional overwrite this replaces.
   #
+  # Files the current run lists under `completeFiles` (it mutated every subject
+  # of them) are the exception: their prior entry is replaced wholesale, or
+  # removed when the run produced no mutants for them, so stale mutants of
+  # changed or deleted code cannot linger next to the new ones.
+  #
   # Merges at mutant granularity, keyed by `stableId`, not file granularity:
   # a `--survivors-from` rerun's schema only contains the re-verified
   # survivors for a file, so replacing that file's whole entry would drop
@@ -37,10 +42,12 @@ module Henitai
     end
 
     def self.merge_files(current, prior, prune_missing:)
-      merged_files = overlay_current_mutants(deep_dup(prior["files"]), current)
+      prior_files = deep_dup(prior["files"])
+      Array(current["completeFiles"]).each { |file| prior_files.delete(file) }
+      merged_files = overlay_current_mutants(prior_files, current)
       merged_files.reject! { |_, file| file["mutants"].empty? }
       prune_missing_source_files(merged_files) if prune_missing
-      current.merge("files" => merged_files)
+      current.except("completeFiles").merge("files" => merged_files)
     end
     private_class_method :merge_files
 
@@ -68,11 +75,25 @@ module Henitai
     def self.append_current_mutants(merged_files, current)
       current.fetch("files", {}).each do |file, entry|
         target = merged_files[file] ||= { "mutants" => [] }
+        merge_provenance(target, entry)
         target["source"] = entry["source"]
         target["language"] = entry["language"]
         target["mutants"] += entry["mutants"]
       end
     end
+
+    # A file merged from several sessions has no single snapshot holding all
+    # its mutants, so its provenance is dropped unless both sides agree.
+    def self.merge_provenance(target, entry)
+      provenance = entry.slice("sessionId", "gitSha")
+      # A fresh run with no prior mutants left in this file: the current
+      # entry's provenance covers every mutant in it.
+      fresh = target["mutants"].empty?
+      agree = fresh || target["sessionId"] == entry["sessionId"]
+      %w[sessionId gitSha].each { |key| target.delete(key) }
+      target.merge!(provenance) if agree
+    end
+    private_class_method :merge_provenance
     private_class_method :append_current_mutants
 
     def self.mutant_ids(schema)