diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index 19a723a8..4db03707 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -202,9 +202,6 @@ uv run python -m emrg     # launch TUI
 uv run python -c "from emrg.client.app import run_client"   # import check
 uv run python -m emrg --help
 uv run --no-sync python3 scripts/check-rant-citations.py    # every citation names its public record
-uv run --no-sync python3 scripts/run-mutation-arm.py \
-    --file <file> --old <text> --new <text> \
-    --node <pytest node id> --expect <the assertion text>   # one judged mutation arm
 ```
 
 `scripts/check-rant-citations.py` answers one question about the instruction prose
@@ -220,41 +217,6 @@ are swept like every other file's and the frozen-debt list is empty (the mechani
 hold a site out of the rule are exercised by synthetic tests rather than by a real
 entry). `--measure` prints the whole inventory.
 
-`scripts/run-mutation-arm.py` runs **one mutation arm and judges it** — the evidence that a test depends
-on the line it claims to test. Break the line and the test must die; a test that survives it is not
-testing what it says. It exists because "the run failed, so the mutation was caught" is wrong in ways
-that look identical to success: a node id that does not resolve — a class method named without its
-class — makes pytest exit **4** having run *nothing*, and a mutation that breaks the module's syntax
-makes pytest *error* rather than fail, with a code that depends on **how the target was named**:
-**1** when a fixture imports the module at run time (the same code as a failing test), **2** when
-collection imports it and the target was named as a **path**, and **4** when it was named as a **node
-id** (pytest reports an uncollectable node as a usage error, so on that form the parse failure and a
-mistyped target are one code). The tool compiles the mutated text and names the syntax error it finds,
-so the report says which of the two it was. The judgement
-is three-valued rather than pass/fail — `KILLED`
-(the target failed on the `--expect` text), `SURVIVED` (it still passed), `UNJUDGEABLE` (the run
-separates neither; the reason is named and the assertion lines the run really echoed are printed, so the
-retry is one step). Exit `0`/`1`/`2` are those three; `3` TARGET-BROKEN (the target did not collect or
-pass *before* the mutation — the report names which cause it read: a target that does not resolve, an
-interpreter that cannot import pytest, or another module the run could not import, named from the run's
-own `No module named <name>` line — because that sentence names a missing *plugin* as readily as a
-missing pytest, and reading it as pytest made the report assert a cause nobody measured — and it also
-prints the nodes the pre-flight failed on, because those names settle the cause before the node id does:
-a list naming files other than the target's own is a tree that was already red before the arm ran, and
-the node-id remedy is then wrong — so withholding them left the reader with a remedy aimed at a cause
-that was not the cause), `4`
-NO-MUTATION (the anchor does not occur exactly once), `5`
-RESTORE-MISMATCH. It snapshots the file, pre-flights the target unmutated, pins `HOME`/`TMPDIR` for the
-child only, and restores **byte for byte** on every path, including its own failure — so an arm cannot
-leave a mutated tree behind. The interpreter the arm is judged under is resolved the same way
-`check-merge-plan-suite.py` resolves the suite's — the invoking interpreter, or the checkout's own
-`.venv` when that one cannot import pytest at all — and the report prints it, so the evidence names its
-environment instead of implying it. A gate that will not load is UNJUDGEABLE as well (exit `2`), naming
-the gate rather than raising a traceback: an arm whose interpreter could not be resolved has measured
-nothing, and a crash's exit code would be read as one of the verdicts it never reached. `--expect` is the failing assertion's own source line, not the test's
-message: pytest echoes that line, and a fragment copied from a message can be missed when an earlier
-assertion in the same test fires first.
-
 ### Electron GUI
 
 ```bash
@@ -402,44 +364,6 @@ than a corner of it: a loop whose bound cannot be read is exactly where the guar
 not answer `OK`, and it prints the header and its line so the reader can rewrite the loop
 or teach the reader the spelling.
 
-**The host-side counterpart of the install step.** The daemon renders a built-in task
-template from its own `__file__`, and on a running install that is
-`~/.emrg/install/source/` — a directory the installer wrote, which an upgrade replaces
-**whole**. It is not a git clone, so a file edited there lives in no commit: the edit looks
-like it took effect (it is what renders) and the next install destroys it silently. Ask
-before an upgrade, or whenever a prompt edit seems not to stick:
-
-```bash
-uv run --no-sync python3 scripts/check-install-drift.py
-# a different install tree or checkout:
-#   uv run --no-sync python3 scripts/check-install-drift.py --install-dir <tree> --root <checkout>
-```
-
-It asks one question per file the two trees share — is this content *anywhere* in the
-checkout's history? — and reads no version file at all, because membership is the whole
-question and the release an install happens to be never has to be established. The id it
-compares is `git hash-object --path=<repo-relative path>`'s, i.e. git's own convention:
-line-ending cleaning (`core.autocrlf`, and this repository's `*.cmd`/`*.bat`/`*.ps1
-text eol=crlf` rule) is applied on both sides, so a line-ending-only difference is not
-reported as an edit. Exit `0` =
-every shared file's content is in history; `1` = at least one is not, printed with its path
-and byte count and with what happens to it; `2` = could not measure (no install tree, no
-git checkout, `git` failed, or the two trees share no path at all) — **never a pass**. The
-`1` remedy is the point of the reading: move the change into the checkout and ship it, or
-it is lost.
-
-Measured 2026-10-07 on this host: exactly one shared file is flagged, and it is
-`emrg/server/competition_prompt.md` — the install copy is the `v0.3.7` bytes **plus** a
-hand-appended block that no ref of the repository carries (every other prompt file in the
-tree is byte-identical to `v0.3.7`, so the tree is that release with one hand-edit). The
-block records a host mandate, and the tag the release chain is part-way through (`v0.3.8`)
-contains none of it — so upgrading does not merely fail to ship that rule, it deletes it.
-The competition task hit the same wall from the other side on 2026-10-07: its rants record
-prompt edits refused by its sandbox (the install tree is outside the competition
-workspace), with the correct but incomplete conclusion that "the install tree copy is the
-one that takes effect" — true, and the reason such an edit has to reach the source
-checkout and ship.
-
 **The readable path to a failed run's cause.** `gh run view <id> --log` and `--log-failed` answer
 **0 bytes with exit 0** on a current host for every run, green or red (measured 2026-10-04 on `gh`
 2.58.0: v0.3.8's failed build `36956685533`, v0.3.7's green build `36658495939`, and a recent `Test`
@@ -483,13 +407,12 @@ so per job instead of reporting no cause.
 
 **A crash is a measurement error, not a verdict.** A tool that dies on an unhandled exception exits
 **`1`**, and `1` is a *verdict* in these tools' own tables — `check-merge-freshness.py` reads it as
-**STALE** (whose documented remedy is a re-merge and a push that voids every standing vote),
-`run-mutation-arm.py` as `EXIT_SURVIVED` ("the target still passed with the mutation in place"), and
+**STALE** (whose documented remedy is a re-merge and a push that voids every standing vote), and
 `review-queue.py` does not define `1` at all. Measured 2026-10-06 with a sibling left unparsable: those
-three exited `1` with no verdict-shaped line, so a caller reading the code read a verdict that was never
+two exited `1` with no verdict-shaped line, so a caller reading the code read a verdict that was never
 reached. So a crash has to leave as the tool's own "could not measure" answer, and the family pinned by
-`tests/test_a_crash_is_a_measurement_error.py` — **the gates that load a sibling by file path**, plus
-`run-mutation-arm.py`, which asks a gate as a subprocess and whose crash class is the same one — does it
+`tests/test_a_crash_is_a_measurement_error.py` — **the gates that load a sibling by file path**, and
+the ones that answer by running another tool as a subprocess — does it
 in one place: each ends its `__main__` block in `_entry()`, which runs `main()` and, if it raises, prints
 the traceback with a `<tool>: could not measure - <Type>: <message>` line and answers **`2`**. A gate
 that loads no sibling reaches the same rule by its own route and says so where it does —
@@ -502,23 +425,6 @@ pins the entry point identical across the family (one rule, not a copy per tool
 derives the family from the source (a `spec_from_file_location` call in code), so a gate that loads a
 sibling and is not in that list fails the module instead of sitting silently outside it.
 
-**The reading that reports a stacked head.** `check-stacked-prs.py` asks whether an open PR would
-land another open PR's commits — the state a reviewer found by hand on #1879, where the branch had
-been cut from #1877's branch and the head carried its commits under a declaration naming neither.
-The tool landed 2026-10-06 (PR #1885) and was then named in **no tracked document**: its own
-docstring, its test, and the private `.emrg/` records were its only carriers, so the reviewer it
-exists for had no way to learn it exists — and it is the reading whose absence is *why it exists*.
-Its list would be `Agent.md`'s merge gates, and that file is **at its prompt cap** (the cap is
-`PROJECT_CONTEXT_MAX_CHARS`, imported and measured by `tests/test_check_stacked_prs.py`, not written
-here), so naming it there needs space freed from something else first: a content decision, not a
-line to squeeze in. This paragraph is therefore its home until that decision is made, and the test
-named above fails the day the cap stops blocking it, so the temporary home cannot outlive its
-reason:
-
-```bash
-uv run --no-sync python3 scripts/check-stacked-prs.py   # 0 clean · 1 a head carrying another open PR's commits · 2 the queue could not be read
-```
-
 CI runs tests and checks for conflict markers automatically via GitHub Actions (`.github/workflows/test.yml`).
 
 > **Self-evolution from source**: the evolution workspace expects the repo at `~/.emrg/evolution/emrg`. Packaged installs self-heal (clone on demand + auto-bootstrap projects/tasks); source installs should clone there explicitly if you want the evolution daemon to work on this repo.
@@ -619,50 +525,6 @@ daemon's own action, not a command a human has to be present to run: a guard who
 only exit is manual strands the tree, which is the shape of the measured 33-cycle
 loss above. Nothing is asked of the host.
 
-The same action is available from a shell, for a tree no cycle is about to touch:
-
-```bash
-uv run --no-sync python3 scripts/recover-worktree.py --repo <task-source-dir>
-uv run --no-sync python3 scripts/recover-worktree.py --repo <task-source-dir> --apply
-```
-
-The script owns no policy — it calls the daemon's implementation of both the
-criterion and the action, so a diagnosis you run by hand and the tier decision the
-daemon makes cannot drift apart. Without `--apply` it only reports. It asks the
-same question the guard asks, and then:
-
-- **refuses, naming the paths, when the work exists nowhere else.** Nothing is
-  written, and no stash is made. That is the guard working; commit, stash or copy
-  that content out deliberately and re-run.
-- **stashes it when it is reconstructible** (`git stash push --include-untracked`),
-  leaving the worktree clean and every byte in the stash. It never moves `HEAD`, so
-  it cannot orphan a commit, and the stash is what makes the action undoable —
-  which is why an agent is allowed to take it. Undo it with the spelling the
-  receipt names, `git stash apply --index stash@{N}` with the `N` that `git stash
-  list` prints for the named message: `--index` is what restores the staged side, and
-  a *bare* `git stash pop` is **not** the inverse of this action. It takes the newest
-  stash (this one only until the next is made), it brings a staged change back
-  unstaged, and it consumes the stash — so the exact spelling is gone with it. The
-  selector is the list's ordinal because no `@{…}` form names a stash **by message**
-  (`gitrevisions(7)` allows ordinals, dates, upstream and push): `stash^{/<message>}`
-  searches commit ancestry and stops resolving as soon as a later stash exists
-  (`apply` rc=1), while `stash@{/<message>}` resolves to the newest entry whatever
-  message it is given and so applies the **wrong** stash successfully — measured, both
-  (issue #1284, re-measured by
-  `tests/test_recover_worktree.py::test_the_advertised_selector_survives_a_later_stash`
-  after `::test_the_advertised_reversal_is_the_measured_one`).
-- **writes a receipt** into the git state dir (`emrg-recovery-receipt.json`), as
-  every release of a safety rule requires. Deliberately not beside the tree: a
-  receipt at `<repo>/.emrg/…` re-dirties the tree it just cleaned in any repository
-  that does not ignore `.emrg/`, which would re-arm the guard on the next cycle.
-  It is best-effort, so the report **says so** when one could not be written
-  (the action's detail and its log line, and `scripts/recover-worktree.py`'s
-  `receipt:` line) rather than naming a path for a file that does not exist
-  (issue #1284). The path is **normalised** before it is joined with the file name:
-  Windows git prints an absolute git dir with forward slashes (`C:/…/.git`), so a
-  verbatim answer made the reported path mixed-separator and unequal to
-  `str(Path(state) / name)` — green locally, red on the windows-2025 leg (#1292).
-
 Read-only blocks the destructive shapes the guard recognises: redirects to
 anything but `/dev/null`, `rm` / `rmdir`, `mv` / `cp` destinations, `truncate` /
 `tee` / `shred`, `sed -i`, `find -delete`, `git ... --output=<f>`, and every git
@@ -674,7 +536,7 @@ outside that shape list (`mkdir`, `touch`, an interpreter writing a file) still
 runs and a downgraded cycle can leave scratch files behind. The decision is per
 command string, not per statement: one blocked shape anywhere in the call refuses
 the whole call. Reads are unaffected — including the read-only git verbs the
-recovery tool's diagnosis uses — so the problem can still be diagnosed from inside
+daemon's own diagnosis uses — so the problem can still be diagnosed from inside
 a downgraded cycle; only the repair needs a writable tier.
 
 #### Diagnose before you repair
@@ -701,10 +563,9 @@ git merge-base --is-ancestor HEAD FETCH_HEAD \
 That is the common case in a workspace whose change was merged upstream after
 the local checkout: the working tree holds master's content while the index
 still matches the older HEAD, and the "uncommitted work" is already published.
-`scripts/recover-worktree.py --apply` clears the dirty state reversibly without
+The daemon's own recovery action clears the dirty state reversibly without
 moving `HEAD`; the sequence below is for when you also want to move the branch
-onto upstream, which is a decision the tool deliberately leaves to you. Recover
-with:
+onto upstream. Recover with:
 
 ```bash
 git fetch origin master
diff --git a/scripts/check-install-drift.py b/scripts/check-install-drift.py
deleted file mode 100644
index 5059963d..00000000
--- a/scripts/check-install-drift.py
+++ /dev/null
@@ -1,903 +0,0 @@
-#!/usr/bin/env python3
-"""Content in the live install tree that the history a release is built from never held.
-
-The reading
------------
-The daemon runs the **installed** package, not this checkout: `_resolve_task_template`
-(`emrg/server/scheduler.py`) returns `Path(__file__).parent / <template>`, and that
-`__file__` is under `~/.emrg/install/source/`. So for every built-in task type the file
-that actually renders is the install tree's copy, and the install tree is not a git
-clone - it is a directory an installer wrote and an upgrade overwrites whole.
-
-That makes "a file in the install tree whose content exists in no commit" a precise and
-load-bearing reading: it is content somebody edited **in place**, outside version
-control, that the next install/upgrade replaces with the release. Nothing measured this,
-and the cost is measured too.
-
-The incident (2026-10-07, cycle `cyc20261007-130240`)
------------------------------------------------------
-The host had asked, by name, for a rule to be written in `emrg/server/competition_prompt.md`
-(host, 2026-10-06T10:40:46; quotable with `scripts/find-host-message.py`). Measured on
-this host: the tracked file has no such rule, `git log --all -S` finds the rule's wording
-in no ref, and the rule exists as a hand-appended `### 0.0` block in the install tree's
-copy - the only home it ever had. Re-measured against the tag the install reports (`v0.3.7`)
-by the convention below (`cyc20261007-230326`), **2** of the 372 shared files differ from it
-- `emrg/server/competition_prompt.md` and `emrg/server/prompts/vibe_check.j2`. This paragraph
-said "exactly one hand-edit" when it was written, and the undercount is the defect: the second
-file is the half the **judge** reads, so the reading that hid it left the host's mandate
-enforceable in the round but not in the verdict (#1898). No count is restated here to be
-trusted - the tool derives it, and the numbers above are what it answered.
-
-Two independent confirmations that this is not a one-off:
-
-* the tag `v0.3.8` (cut 2026-10-02, the release the tag chain is part-way through) carries
-  **0** occurrences of the rule - so the upgrade that installs it does not merely fail to
-  ship the host's mandate, it **deletes** it;
-* the competition task's own rants of 2026-10-07 (`2026-10-07T09:44:31`, and
-  `2026-10-07T12:10:07` for the same file) record that it tried to make its prompt edits
-  in that tree and was refused, ending "the install tree copy is the one that takes
-  effect, not the evolution-tree copy" - which is true, and is why the edit has to reach
-  the source checkout and ship.
-
-The question this answers
--------------------------
-Per file the install tree and this checkout both carry, is the file's content in the history
-a **release is built from**? If it is not, the next install/upgrade destroys it: the file was
-written by hand, or its only other home is a snapshot no release ships.
-
-**Which convention "the content" means is asked of git, not decided here.** Git stores a
-file's *cleaned* bytes, and cleaning is a property of the path: this repository pins
-`*.cmd`/`*.bat`/`*.ps1` to LF blobs with a CRLF checkout (`.gitattributes`
-`text eol=crlf`), and a host with `core.autocrlf=true` normalizes every text file. So the
-id this tool compares is `git hash-object --path=<relative path> <file>`'s, which is the
-same convention that produced the blobs in it. Hashing the raw bytes instead answers a
-different question and calls a line-ending difference an edit - measured 2026-10-07
-against both `core.autocrlf=true` and a `eol=crlf` attribute, and caught by `test-windows`
-on this tool's first version (run `37588646750`).
-
-That is also why the comparison is not a shortcut computed in-process: a raw
-`sha1("blob <len>\\0" + bytes)` is faster (measured: 1.2s for this host's 372 shared files,
-one subprocess each) but it is the wrong function.
-
-Membership is asked of the objects reachable from the refs a **release is built from** -
-`refs/heads/*`, `refs/remotes/*`, `refs/tags/*` - rather than of a tag or of `HEAD`, because
-the edit is the thing being detected and the version the install happens to be is not: an
-install one release behind is ordinary and every one of its files still matches the commit
-that shipped it. It is deliberately **not** `--all`, which is a different question with a
-different answer. That namespace also holds this machinery's own bookkeeping refs, and
-`refs/emrg/rescue/*` above all: `scripts/recover-worktree.py` writes a snapshot there exactly
-because a dirty tree held work that exists nowhere else. Content reaching only such a ref is
-not history any release ships - which is the point, not a technicality - so counting it made
-the reading silently weaker in the one case that matters. Measured: the install tree's
-`emrg/server/prompts/vibe_check.j2` holds bytes pinned into
-`refs/emrg/rescue/20261006T035349Z` and reachable from no branch or tag, and the tool
-answered "1 file(s)" where the tag comparison finds 2, so the file whose live copy the next
-upgrade really does destroy was the one it stayed silent about. Drift whose bytes survive
-only in such a ref is therefore reported - and the report **names the ref**, because that is
-where the edit is still recoverable from.
-
-**Which release that is gets its own reading, because the one above cannot see it.** Everything
-above is true of a tree five releases old - its files match the commits that shipped them - so
-the green verdict is silent about the daemon rendering that release's rules rather than the
-newest ones. Measured 2026-10-20: this host's install tree carries
-`emrg/server/evolution_prompt.md`'s pre-narrowing blob (the one `v0.3.14`-`v0.3.16` ship), five
-releases past the host's 2026-10-16 ruling that narrowed the abstention clause, and the reading
-above answered `0`. Every evolution cycle that day read the superseded rule out of the prompt
-the daemon rendered, and none of them could see it: nothing measured it. So a `behind:` line is
-printed under **both** verdicts - which release this tree is, which release is newest, and the
-paths that differ. Being behind is not drift (nothing is lost) and not clean (it is what runs),
-so it is stated rather than scored, and the exit code stays the drift reading's alone.
-
-The walk itself is asked with `--missing=print` and read for the objects it does list. A
-clone can hold a ref whose history it cannot fully read: measured on this host 2026-10-08
-(`cyc20261008-001036`), where `git rev-list --all --objects` exits 128 on `bad tree object
-219ff46e...` and so does every narrower walk, `HEAD` alone included - the hole is in the
-history, and every membership question here is about history. Left intolerant that is exit
-`2` on the very host this tool exists for. Tolerating it can only *remove* a candidate, so a
-file whose content sits under a missing tree reads as drift: the same false-positive
-direction, and the same safe one, as content that was committed and then orphaned. The count
-of absent objects is printed so that a narrowed set is never read as the whole one.
-
-Exit codes
-----------
-``0``  every shared file's content is in this repository's history.
-``1``  at least one is not; each is printed, with the path to edit instead.
-``2``  the question could not be answered - no install tree to read, no checkout, `git`
-failed, or **not one file was checked**, which would make a green verdict a reading over
-an empty set.
-
-Named limits
-------------
-* Only files the checkout **tracks** are checked: a file the repository has moved or
-  deleted since the install was built is not drift by content, because its absence is a
-  version difference rather than an edit. It is **not** removed by the upgrade, though, and
-  this docstring said it was until the claim was measured: on 2026-10-17 a tree reporting
-  `0.3.16` still carried `emrg/gui/renderer/js/` - 11 files deleted from the source on
-  2026-08-27 and absent from that tag's own tree. So they are **named as leftovers**, with a
-  count and their paths, and they stay out of the exit code: the verdict is about content no
-  commit holds, and a leftover is a different fact - a stale tree that a reader (a cycle, an
-  audit, a session) can still be answered from.
-* The membership test is over objects reachable from the refs a release is built from, so
-  content that was committed and then orphaned - a deleted branch, a rewritten commit -
-  reads as an edit. That is a false positive in the strict sense and the safe direction:
-  both cases mean "this content is not in the history you can see".
-* A file whose content reaches **only** a bookkeeping ref (`refs/emrg/rescue/*`,
-  `refs/stash`, `refs/emrg-tmp/*`, `refs/emrg-check/*`) is drift like any other, and its
-  line names the ref it is still recoverable from - because "an upgrade will delete this"
-  is true of it, and that ref is the only place the bytes are kept.
-* Objects absent from this clone are not walked, and the count is printed when it is not
-  zero. The set is therefore the history this clone can see, which is the only history it
-  can promise a file is safe in.
-* **A release tag this clone cannot read is skipped and counted, never fatal.** Two tags on a
-  peer host answer `fatal: not a tree object`; raising on the first made the whole reading
-  `2`, which took the drift verdict down with the release question. `tags:` counts what was
-  skipped, the same way `membership:` counts what was not walked.
-* **"Newest" is the newest release tag *this clone carries***, and the line says so. A tag
-  list that stops short is ordinary - a checkout nobody has fetched lately - and a sentence
-  about releases may not stand on a reading of tags. The install tree's own `__version__`
-  names the tag to confirm first, so a stale list cannot make the tree's release unnameable.
-* **The direction is measured before a remedy is written.** An upgrade is recommended only
-  when the tree is demonstrably older than the newest readable tag; when the tree is newer
-  the line says the *tags* lag and names no upgrade, and when neither side could be ordered
-  it says the direction was not established and names no remedy at all.
-* The fallback walk stops after `TAGS_EXAMINED` tags and says when it stopped, so a bounded
-  search is never read as "this tree matches no release".
-* It compares **content, under git's own line-ending convention**: a file whose only
-  difference from the committed blob is CRLF versus LF reads as *no* drift, because
-  `hash-object --path=<rel>` cleans it exactly as `git add` did. That is deliberate - such
-  a file holds nothing a human added, and reporting it would flood the reading on any host
-  whose attributes or `autocrlf` transform line endings.
-* An edit that happens to reproduce a committed blob exactly is not drift - by
-  construction, since the committed copy is then a home for it.
-"""
-
-from __future__ import annotations
-
-import argparse
-import re
-import subprocess
-import sys
-import traceback
-from dataclasses import dataclass, field
-from pathlib import Path
-
-
-#: Where the running daemon's package and prompt templates live. Not a git clone: the
-#: installer writes it and an upgrade replaces it whole.
-DEFAULT_INSTALL_DIR = "~/.emrg/install/source"
-
-
-def _git_stored_id(root: Path, path: Path, relative: str) -> str:
-    """The blob id git assigns to `path`'s content **at this path in this checkout**.
-
-    Asked of git rather than computed here, and the `--path` is the load-bearing half: it
-    is what makes the answer the one the committed blobs were created with. Git stores a
-    file's *cleaned* bytes, and what "cleaned" means is a property of the path - this
-    repository pins `*.cmd`/`*.bat`/`*.ps1` to LF blobs with a CRLF checkout
-    (`.gitattributes` `text eol=crlf`, because a LF-only `.cmd` is misparsed by cmd.exe),
-    and a host with `core.autocrlf=true` normalizes every text file. Hashing the raw bytes
-    instead would report every such file as drift on such a host - noise, which is how a
-    reading stops being read.
-
-    Measured 2026-10-07 (cycle `cyc20261007-182502`) on synthetic repositories: a CRLF file
-    whose committed blob is LF answers the committed id through `hash-object
-    --path=<rel>` under **both** `core.autocrlf=true` and `*.cmd text eol=crlf`, while the
-    raw construction answers a different id under both. The first version of this tool used
-    the raw construction and `test-windows` caught it (run `37588646750`).
-    """
-    proc = subprocess.run(
-        ["git", "-C", str(root), "hash-object", f"--path={relative}", str(path)],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    if proc.returncode != 0:
-        detail = (proc.stderr or proc.stdout or "").strip().splitlines()
-        raise RuntimeError(
-            detail[0] if detail else f"git hash-object failed for {relative}"
-        )
-    return proc.stdout.strip()
-
-
-def _git(root: Path, *argv: str) -> str:
-    """Run `git -C <root> ...`, raising `RuntimeError` with git's own words."""
-    proc = subprocess.run(
-        ["git", "-C", str(root), *argv],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    if proc.returncode != 0:
-        detail = (proc.stderr or proc.stdout or "").strip().splitlines()
-        raise RuntimeError(detail[0] if detail else f"git {' '.join(argv)} failed")
-    return proc.stdout
-
-
-def tracked_files(root: Path) -> set[str]:
-    """Every path this checkout tracks, as posix-relative text."""
-    return {name for name in _git(root, "ls-files", "-z").split("\0") if name}
-
-
-#: The spelling the release workflow gives a published version, and the only refs the
-#: "which release is this install tree" question may be answered from.
-RELEASE_TAG_RE = re.compile(r"^v\d+\.\d+\.\d+$")
-
-#: How many release tags the fallback walk may read before it stops and says so. The walk is
-#: a fallback, not the only source (see `behind_release`), and a clone carrying a hundred tags
-#: is a hundred `ls-tree -r` calls on a run where nothing matches - measured 2026-10-20 on a
-#: peer host where the walk reached tag 12 of 118 before dying on an unreadable one.
-TAGS_EXAMINED = 20
-
-#: Where the install tree states its own version. A **local** fact, and the reason it matters
-#: is that it does not depend on this clone's tag list being complete or readable - the one
-#: input a stale or holed tag walk gets wrong (see `behind_release`).
-INSTALL_VERSION_PATH = "emrg/__init__.py"
-
-_VERSION_ASSIGNMENT_RE = re.compile(r"""__version__\s*=\s*["']([^"']+)["']""")
-_VERSION_PARTS_RE = re.compile(r"^v?(\d+)\.(\d+)\.(\d+)$")
-
-
-def install_version(install_dir: Path) -> str | None:
-    """The version the install tree says it is, or `None` when it does not say.
-
-    A claim about itself, not a reading of history: the file is `emrg/__init__.py`, which an
-    install carries and an upgrade replaces. `behind_release` uses it to pick the tag to
-    confirm, and names a release from it only when that tag's tree agrees on every shared
-    path, so a stale hand edit cannot borrow a release's name.
-    """
-    path = install_dir / INSTALL_VERSION_PATH
-    try:
-        text = path.read_text(encoding="utf-8", errors="replace")
-    except OSError:
-        return None
-    match = _VERSION_ASSIGNMENT_RE.search(text)
-    return match.group(1) if match else None
-
-
-def version_parts(text: str | None) -> tuple[int, int, int] | None:
-    """`"0.3.21"` → `(0, 3, 21)`, and `"v0.3.21"` → the same; `None` otherwise.
-
-    Only used to order two versions, which a string comparison gets wrong at `0.3.10` against
-    `0.3.9` - the same defect the tag sort is `--sort=-v:refname` to avoid, one layer down.
-    """
-    if not text:
-        return None
-    match = _VERSION_PARTS_RE.match(text.strip())
-    return tuple(int(part) for part in match.groups()) if match else None
-
-
-
-def release_tags(root: Path) -> list[str]:
-    """Every release tag this clone carries, newest first.
-
-    Version order, not creation order: `--sort=-v:refname` is git's own version sort, which
-    puts `v0.3.10` above `v0.3.9` where a lexical sort would put it below - the wrong sort does
-    not crash, it names a real release that is simply not the newest. A tag this clone does not
-    have cannot be named, and that is reported rather than guessed (see `behind_release`).
-    """
-    listing = _git(root, "tag", "--sort=-v:refname", "--list", "v*")
-    return [name for name in (line.strip() for line in listing.splitlines()) if RELEASE_TAG_RE.match(name)]
-
-
-def release_tree(root: Path, ref: str) -> dict[str, str] | None:
-    """`{path: blob id}` for one release ref, or `None` when this clone cannot read it.
-
-    One call for the whole tree rather than a `rev-parse` per path: the question compares
-    every shared file at once, and this host's install tree shares ~380 of them, which at one
-    process each is a second of subprocesses per release examined.
-
-    `None` rather than an exception, because **a tag this clone cannot read is one release it
-    cannot name, not a reason to answer nothing**. Measured 2026-10-20 on a peer host
-    (`cyc20261020-100652`): two tags answered `fatal: not a tree object` - their trees are
-    absent from that clone, the same clone whose `membership:` line already reports 40 absent
-    objects - the walk raised on the first of them, and `main`'s `could not measure` took the
-    **drift verdict** down with it: `rc 2` where the reading before this one answered `0`. The
-    tolerance here is the one the membership walk already has, for the same reason: a narrowed
-    set is printed with its count, never traded for no reading at all.
-    """
-    try:
-        listing = _git(root, "ls-tree", "-r", ref)
-    except RuntimeError:
-        return None
-    blobs: dict[str, str] = {}
-    for line in listing.splitlines():
-        if "\t" not in line:
-            continue
-        meta, path = line.split("\t", 1)
-        parts = meta.split()
-        if len(parts) >= 3 and parts[1] == "blob":
-            blobs[path] = parts[2]
-    return blobs
-
-
-@dataclass(frozen=True)
-class ReleaseReading:
-    """What "which release is this tree, and is a newer one out" answered.
-
-    `newest` is the newest release **tag this clone carries** - worded as a tag because that
-    is what was read, and a sentence about *releases* may not stand on a reading of tags
-    (measured 2026-10-20: a peer host's clone stops three releases short, so the newest tag
-    was `v0.3.18` while the tree was `0.3.21`). `tree_version` is the install tree's own
-    claim, `direction` orders the two so the remedy cannot point backwards, and
-    `unreadable` / `truncated` say how much of the tag list could be read at all.
-    """
-
-    newest: str | None = None
-    install_release: str | None = None
-    differing: list[str] = field(default_factory=list)
-    compared: int = 0
-    tree_version: str | None = None
-    direction: str = "unknown"
-    unreadable: tuple[str, ...] = ()
-    truncated: bool = False
-
-
-
-def behind_release(
-    install_dir: Path, root: Path, shared: list[tuple[Path, str]]
-) -> ReleaseReading:
-    """`(newest tag, the tag this tree is, paths that differ from the newest, shared count)`.
-
-    The question the rest of this tool cannot answer, and the reason it is here: `scan` asks
-    whether a file's content is reachable from *any* ref a release is built from. An install
-    tree several releases old passes that test with a green verdict, because the old bytes are
-    in an older release's history - which is a release ref. Measured 2026-10-20 on this host:
-    the install tree carries `evolution_prompt.md`'s pre-narrowing blob (`af6e4ae5`, the one
-    `v0.3.14`-`v0.3.16` ship) while master and the five releases since carry the narrowed rule,
-    and the other reading answered `0` - "every file ... holds content the refs a release is
-    built from still reach". The daemon renders that file into every evolution cycle, so the
-    reading that said "shipped" said it about a superseded rule.
-
-    So the second question is: **which release is this tree, and is a newer one out?** It is
-    answered for the tree as a whole rather than file by file, and that distinction is
-    measured: attributing each file to "the newest release that still carries these bytes"
-    names a *later* tag for every file the next release did not touch, so a v0.3.16 tree
-    reported `v0.3.16` for one path and `v0.3.18` for another and named no version at all. The
-    tree's version is the newest tag whose content it matches on every shared path, which is
-    one fact about one directory.
-
-    Three things the tag walk alone gets wrong, all measured 2026-10-20 on a peer host
-    (`cyc20261020-100652`) and each answered here:
-
-    - **A tag this clone cannot read is skipped and counted**, never fatal - `release_tree`
-      returns `None` and the list lands in `unreadable`, which `main` prints. The drift verdict
-      is not collateral damage of the second question.
-    - **The tree's own version file names the tag to confirm first.** A tag list that stops
-      short of the install tree is ordinary on any checkout that has not fetched lately, and
-      walking it as the only source answers "no single release" about a tree that is exactly a
-      release - or, worse, names one *older* than the tree. `INSTALL_VERSION_PATH` is a local
-      fact, so it survives a stale list; the walk below is the fallback for an install that
-      does not carry the file.
-    - **The order of the two is established before a remedy is written.** `direction` is
-      `ahead` when the tree's own version is newer than the newest readable tag, and then no
-      upgrade is recommended: the tags are what lag.
-
-    A tree matching no tag is `None` and is not this reading's fault to explain: content in no
-    tag is the *other* reading's subject (a hand edit, which destroys on upgrade), and mixing
-    the two in one line leaves a reader unable to tell "an upgrade brings the rest" from "an
-    upgrade destroys this".
-
-    Absent files are out of scope: this compares the paths both trees carry, so a file the
-    newest release added is something an upgrade creates, not a lag in what this tree has.
-
-    `None` for the newest tag is "this clone carries no release tag it could read", which the
-    caller must report as unmeasurable rather than as currency - an empty `differing` with a
-    tag is "measured, nothing lags".
-    """
-    if not shared:
-        return ReleaseReading(compared=0)
-    tags = release_tags(root)
-    if not tags:
-        return ReleaseReading(compared=len(shared))
-
-    ids = {relative: _git_stored_id(root, path, relative) for path, relative in shared}
-    tree_version = install_version(install_dir)
-    unreadable: list[str] = []
-    trees: dict[str, dict[str, str]] = {}
-    failed: set[str] = set()
-
-    def tree_of(tag: str) -> dict[str, str] | None:
-        """One tag's blobs, read once; `None` for a tag this clone cannot read.
-
-        A failure is remembered as well as a success: the list below reads some tags twice
-        (once to find the newest readable one, once as the fallback walk), and a skipped tag
-        that is retried is counted twice in the note that reports it - measured on the arm
-        below before this cache existed, which read `2 release tag(s) ... (v0.3.9, v0.3.9)`.
-        """
-        if tag in trees:
-            return trees[tag]
-        if tag in failed:
-            return None
-        blobs = release_tree(root, tag)
-        if blobs is None:
-            failed.add(tag)
-            unreadable.append(tag)
-            return None
-        trees[tag] = blobs
-        return blobs
-
-    def matches(tag: str) -> bool:
-        blobs = tree_of(tag)
-        return blobs is not None and all(
-            blobs.get(relative) == blob for relative, blob in ids.items()
-        )
-
-    # The newest tag this clone can actually read: the first readable one in version order,
-    # since `release_tags` sorted them. An unreadable newest tag is a release this reading
-    # cannot name, so it is skipped and counted rather than reported as the answer.
-    newest: str | None = None
-    for tag in tags:
-        if tree_of(tag) is not None:
-            newest = tag
-            break
-    if newest is None:
-        return ReleaseReading(
-            compared=len(shared),
-            tree_version=tree_version,
-            unreadable=tuple(unreadable),
-            truncated=len(tags) > TAGS_EXAMINED,
-        )
-
-    # The tree's own version names the tag to confirm first - one `ls-tree` - and the bounded
-    # walk is the fallback, so a stale list cannot decide what the tree is.
-    install_release: str | None = None
-    candidate = f"v{tree_version}" if tree_version else None
-    if candidate and candidate in tags and matches(candidate):
-        install_release = candidate
-    else:
-        for tag in tags[:TAGS_EXAMINED]:
-            if matches(tag):
-                install_release = tag
-                break
-
-    newest_blobs = tree_of(newest) or {}
-    differing = sorted(
-        relative
-        for relative, blob in ids.items()
-        if newest_blobs.get(relative) != blob
-    )
-
-    direction = "current"
-    if differing:
-        tree_parts = version_parts(tree_version) or version_parts(install_release)
-        newest_parts = version_parts(newest)
-        if tree_parts and newest_parts and tree_parts > newest_parts:
-            direction = "ahead"
-        elif tree_parts and newest_parts and tree_parts < newest_parts:
-            direction = "behind"
-        else:
-            # No version on either side to order: the difference is real and the direction is
-            # not measured, which is what the report says rather than naming a release.
-            direction = "unknown"
-
-    return ReleaseReading(
-        newest=newest,
-        install_release=install_release,
-        differing=differing,
-        compared=len(shared),
-        tree_version=tree_version,
-        direction=direction,
-        unreadable=tuple(unreadable),
-        truncated=install_release is None and len(tags) > TAGS_EXAMINED,
-    )
-
-
-
-#: The ref namespaces a release is built from. Everything else a ref can live in
-#: (`refs/emrg/rescue/*`, `refs/stash`, `refs/emrg-tmp/*`, `refs/emrg-check/*`, ...) is this
-#: machinery's own bookkeeping, and a recovery snapshot above all: `scripts/recover-worktree.py`
-#: writes one precisely where a dirty tree holds work that exists nowhere else, so nothing
-#: there is history a release ships. Counting it as history is how a live hand-edit went
-#: unreported (#1898).
-SHIPPING_REF_PREFIXES = ("refs/heads/", "refs/remotes/", "refs/tags/")
-
-
-def _tolerant_objects(root: Path, *revisions: str) -> tuple[set[str], int]:
-    """`(objects, missing)` reachable from `revisions`, tolerating objects this clone lacks.
-
-    `<id> <path>` per line, but only the id is needed: the question is whether the blob
-    exists in the history, not where it sat in it.
-
-    `--missing=print` is what lets the walk finish. An object a clone does not have is
-    printed as `?<id>` and stepped over, where the default (`--missing=error`) aborts the
-    whole walk with exit 128 - measured 2026-10-08 (`cyc20261008-001036`) on this host, where
-    `git rev-list --all --objects` dies on `bad tree object 219ff46e...` and so does every
-    narrower walk including `HEAD` alone, because the hole is in the *history* and every
-    membership question here is about history. Intolerant, that is exit `2` on the very host
-    the tool serves, and a reading that can only say "could not measure" here measures
-    nothing. `allow-any` finishes too but reports nothing, which is why the count is returned
-    and printed: a reading that covers less than history must say so rather than leave a
-    narrowed set to read as the whole one.
-    """
-    out = _git(root, "rev-list", *revisions, "--objects", "--missing=print")
-    objects: set[str] = set()
-    missing = 0
-    for line in out.splitlines():
-        line = line.strip()
-        if not line:
-            continue
-        if line.startswith("?"):
-            missing += 1
-            continue
-        objects.add(line.split(" ", 1)[0])
-    return objects, missing
-
-
-def shipping_objects(root: Path) -> tuple[set[str], int]:
-    """The objects reachable from the refs a release is built from, and how many are absent."""
-    return _tolerant_objects(root, "--branches", "--tags", "--remotes")
-
-
-def non_shipping_refs(root: Path) -> list[str]:
-    """Every ref a release is **not** built from, in git's own order."""
-    names = (line.strip() for line in _git(root, "for-each-ref", "--format=%(refname)").splitlines())
-    return [name for name in names if name and not name.startswith(SHIPPING_REF_PREFIXES)]
-
-
-def refs_holding(root: Path, refs: list[str], blobs: set[str]) -> dict[str, list[str]]:
-    """Which of `refs` reach each of `blobs`, stopping as soon as every blob is named.
-
-    This is the half that makes the report actionable: "the next upgrade deletes this" is
-    only useful with somewhere to recover the bytes from, and a bookkeeping ref is where
-    they survive. A ref that cannot be walked at all is skipped rather than failing the
-    reading, since it can only make a report less specific, never a verdict wrong.
-    """
-    found: dict[str, list[str]] = {}
-    remaining = set(blobs)
-    for ref in refs:
-        if not remaining:
-            break
-        try:
-            objects, _ = _tolerant_objects(root, ref)
-        except RuntimeError:
-            continue
-        for blob in sorted(remaining):
-            if blob in objects:
-                found.setdefault(blob, []).append(ref)
-                remaining.discard(blob)
-    return found
-
-
-def shared_paths(install_dir: Path, root: Path) -> tuple[list[tuple[Path, str]], list[str]]:
-    """`(install path, install-relative path)` for the paths both trees carry, and the rest.
-
-    The walk both readings start from: a path is comparable only when this checkout tracks it,
-    because the id of the other side is asked of git at *that* path.
-    """
-    tracked = tracked_files(root)
-    shared: list[tuple[Path, str]] = []
-    skipped: list[str] = []
-    for path in sorted(install_dir.rglob("*")):
-        if not path.is_file():
-            continue
-        relative = path.relative_to(install_dir).as_posix()
-        if relative not in tracked:
-            skipped.append(relative)
-            continue
-        shared.append((path, relative))
-    return shared, skipped
-
-
-#: How many lagging paths a `behind:` line names before counting the rest, matching the
-#: leftovers section's shape: enough to recognise the family, not a wall of paths.
-BEHIND_SHOWN = 10
-
-
-def _report_release(install_dir: Path, reading: ReleaseReading) -> None:
-    """Print which release this tree is, and whether a newer one exists.
-
-    Printed under **both** verdicts, because it is a second question and not a verdict: a tree
-    that lags is not drift (nothing here is lost) and is not clean either (the daemon renders
-    it). Leaving it out of the green branch is the defect this function exists to fix - the
-    green line said "a release's refs still reach this content", which is true of any older
-    release and therefore said nothing about being current.
-
-    **The remedy follows the direction, or there is none.** "An upgrade to X brings these" is
-    true only when X is newer than the tree, and measured 2026-10-20 on a peer host it was
-    printed for a tree three releases *newer* than X - advice to downgrade, from a reading that
-    had never established which side was ahead. So the direction is stated, and when it was not
-    measured the line says that instead of naming a release.
-    """
-    if reading.newest is None:
-        if reading.unreadable:
-            shown = ", ".join(reading.unreadable[:5])
-            more = (
-                f" and {len(reading.unreadable) - 5} more"
-                if len(reading.unreadable) > 5
-                else ""
-            )
-            print(
-                f"behind: could not measure which release {install_dir} is - this checkout "
-                f"carries {len(reading.unreadable)} release tag(s) and none of them can be "
-                f"read here ({shown}{more})"
-            )
-            return
-        print(
-            f"behind: could not measure which release {install_dir} is - this checkout "
-            "carries no release tag, and the refs a release is built from cannot answer it "
-            "(an older release's bytes are in them too)"
-        )
-        return
-    if not reading.differing:
-        print(
-            f"behind: none - {install_dir} carries what {reading.newest} ships "
-            f"({reading.compared} shared file(s) compared)"
-        )
-        return
-
-    version = reading.install_release or "no single release"
-    print(
-        f"behind: {install_dir} is the {version} copy and the newest release tag this "
-        f"clone carries is {reading.newest}; {len(reading.differing)} of {reading.compared} "
-        "shared file(s) differ, so whatever the daemon renders from this tree is that "
-        "release's copy"
-    )
-    for relative in reading.differing[:BEHIND_SHOWN]:
-        print(f"    {relative}")
-    if len(reading.differing) > BEHIND_SHOWN:
-        print(f"    ... and {len(reading.differing) - BEHIND_SHOWN} more")
-    if reading.direction == "ahead":
-        print(
-            f"    direction: this tree reports {reading.tree_version or 'no version'}, which "
-            f"is newer than {reading.newest} - so nothing here is behind; the tags this "
-            f"clone carries are. An upgrade to {reading.newest} would move this tree "
-            "backwards."
-        )
-        print(
-            "    remedy: fetch the tags in the source checkout (`git fetch --tags`), so the "
-            "release this tree is can be named and an upgrade can be compared against it."
-        )
-        return
-    if reading.direction == "behind":
-        print(
-            f"    remedy: an upgrade to {reading.newest} brings these. Until then a rule read "
-            "from this tree is the installed release's rule, not the newest one's."
-        )
-        return
-    print(
-        "    direction: not established - neither this tree's own version nor a tag it "
-        "matches could be read, so whether an upgrade to "
-        f"{reading.newest} moves it forward or backwards is not measured, and no remedy is "
-        "named."
-    )
-
-
-
-def scan(
-    install_dir: Path, root: Path
-) -> tuple[list[tuple[str, int, str]], list[str], int, int, list[tuple[Path, str]]]:
-    """Return `(drifted, skipped, checked, missing, shared)` for the paths the trees share.
-
-    `shared` is returned rather than recomputed: the release reading starts from the same
-    walk, and calling `shared_paths` twice walked the whole install tree twice on every run
-    (`cyc20261020-092940`'s nit on this branch).
-
-    `drifted` is `(path, size, note)` for a shared file whose content no shipped object
-    holds - the note saying why, and naming the bookkeeping ref it is still recoverable
-    from when one holds it; `skipped` is the install-relative paths this checkout no longer
-    tracks; `checked` is how many files the question was actually asked about, which `main`
-    refuses to report a green verdict over when it is 0; `missing` is how many objects the
-    membership walk found absent from this clone, which `main` prints when it is not zero.
-    """
-    shared, skipped = shared_paths(install_dir, root)
-    shipped, missing = shipping_objects(root)
-
-    drifted: list[tuple[str, int, str]] = []
-    for path, relative in shared:
-        blob = _git_stored_id(root, path, relative)
-        if blob not in shipped:
-            drifted.append((relative, path.stat().st_size, blob))
-
-    holders = (
-        refs_holding(root, non_shipping_refs(root), {blob for _, _, blob in drifted})
-        if drifted
-        else {}
-    )
-    reported: list[tuple[str, int, str]] = []
-    for relative, size, blob in drifted:
-        refs = holders.get(blob, [])
-        if refs:
-            note = (
-                "held only by "
-                + ", ".join(refs)
-                + ", which no release builds from - the bytes are still there, in a "
-                "snapshot of uncommitted work"
-            )
-        else:
-            note = "no commit of this checkout holds this content"
-        reported.append((relative, size, note))
-    return reported, skipped, len(shared), missing, shared
-
-
-def _entry() -> int:
-    """`main`, with an unexpected failure reported as this tool's unmeasurable answer.
-
-    Python exits `1` for an unhandled exception, and `1` is a **verdict** in this tool's
-    exit table, while `2` is the code for "the question could not be answered". A caller
-    that checks the code - which is how this family composes, one gate running another or
-    reading its `rc` - would otherwise read a crash as a verdict. Byte-identical in every
-    tool of the family, and `tests/test_a_crash_is_a_measurement_error.py` pins that.
-    """
-    try:
-        return main()
-    except Exception as exc:  # noqa: BLE001 - reported as unmeasurable, never swallowed
-        traceback.print_exc()
-        print(
-            f"{Path(__file__).name}: could not measure - {type(exc).__name__}: {exc}",
-            file=sys.stderr,
-        )
-        return 2  # cause: tool-failed
-
-
-def main(argv: list[str] | None = None) -> int:
-    """Report the install tree's files whose content no shipped commit of the checkout holds.
-
-    :param argv: the command line, defaults to `sys.argv[1:]`.
-    :returns: the exit code the docstring states.
-    """
-    # The `tree:`/`install:` lines must reach a merged reader before any verdict, and
-    # stdout is block-buffered through a pipe while stderr is not - the family rule,
-    # pinned by `tests/test_guard_report.py`.
-    try:
-        sys.stdout.reconfigure(line_buffering=True)
-    except (AttributeError, ValueError):
-        pass
-
-    parser = argparse.ArgumentParser(
-        description=(
-            "Files in the live install tree whose content the refs a release is built from "
-            "do not hold (content an upgrade replaces), and which release that tree is "
-            "(content an upgrade brings)."
-        )
-    )
-    parser.add_argument(
-        "--install-dir",
-        default=DEFAULT_INSTALL_DIR,
-        help=(
-            "the installed tree the daemon runs from "
-            f"(default: {DEFAULT_INSTALL_DIR})"
-        ),
-    )
-    parser.add_argument(
-        "--root",
-        default=None,
-        help="the checkout to ask (default: this script's own)",
-    )
-    args = parser.parse_args(argv)
-
-    install_dir = Path(args.install_dir).expanduser()
-    root = Path(args.root).expanduser().resolve() if args.root else Path(__file__).resolve().parent.parent
-
-    # Both trees are named before any verdict: this tool answers about a pair, and a
-    # reader who cannot see which pair was read cannot tell a clean install tree from a
-    # checkout the caller was not in.
-    print(f"tree: {root}")
-    print(f"install: {install_dir}")
-
-    if not install_dir.is_dir():
-        print(
-            f"could not measure: no install tree at {install_dir} - the question is about "
-            "the installed copy, so there is nothing to compare",
-            file=sys.stderr,
-        )
-        return 2
-    if not (root / ".git").exists():
-        print(
-            f"could not measure: {root} is not a git checkout, so no history can say "
-            "whether a file's content was ever committed",
-            file=sys.stderr,
-        )
-        return 2
-    try:
-        drifted, skipped, checked, missing, shared = scan(install_dir, root)
-        reading = behind_release(install_dir, root, shared)
-    except RuntimeError as exc:
-        print(f"could not measure: {exc}", file=sys.stderr)
-        return 2
-
-    if missing:
-        # A property of the reading and not of the files, so it is printed whatever the
-        # verdict: the membership set is the history this clone can see, which is smaller
-        # than the history its refs name whenever an object is absent.
-        print(
-            f"membership: {missing} object(s) reachable from the refs a release is built "
-            "from are absent from this checkout and were not walked; content under a "
-            "missing tree reads as drift"
-        )
-
-    if reading.unreadable:
-        # Same rule one layer over: a tag whose objects are absent names no tree here, so it
-        # is one release this reading cannot name - and the count is what stops the named
-        # ones being read as the whole list. Printed under both verdicts because it is a
-        # property of the reading, not of the files.
-        shown = ", ".join(reading.unreadable[:5])
-        more = (
-            f" and {len(reading.unreadable) - 5} more"
-            if len(reading.unreadable) > 5
-            else ""
-        )
-        print(
-            f"tags: {len(reading.unreadable)} release tag(s) this checkout carries cannot be "
-            f"read here ({shown}{more}) and were skipped; each is one release this reading "
-            "cannot name"
-        )
-    if reading.truncated:
-        print(
-            f"tags: the walk stopped after {TAGS_EXAMINED} release tag(s), so this tree "
-            "matched none of those - that is a bounded search, not a measurement that it "
-            "matches no release"
-        )
-
-    if checked == 0:
-        # The family's empty-set refusal (2026-10-06, `cyc20261006-165503`): a verdict of
-        # `0` says the files were checked, and a tree sharing no path with this checkout
-        # was not checked at all. Measured on an empty directory before the branch was
-        # written: the green line, rc 0.
-        print(
-            f"could not measure: {install_dir} and {root} share no tracked path "
-            f"({len(skipped)} install file(s) skipped as untracked here), so there was "
-            "nothing to ask the question of - `0` says the files were checked, and none "
-            "was.",
-            file=sys.stderr,
-        )
-        return 2
-
-    caches = [path for path in skipped if "__pycache__/" in path]
-    leftover = [path for path in skipped if "__pycache__/" not in path]
-    if leftover:
-        # The limit this tool used to state as a rationale ("its absence is a version
-        # difference rather than an edit, and it is removed by the upgrade either way") was
-        # measured false on 2026-10-17: a tree reporting `0.3.16` still carried
-        # `emrg/gui/renderer/js/` — 11 files deleted from the source on 2026-08-27 and
-        # absent from that tag's own tree. An upgrade copies a release in and removes
-        # nothing, so what it leaves behind is exactly the class a reader of this tree keeps
-        # finding, and silence about it is the defect.
-        shown = leftover[:10]
-        print(
-            f"leftovers: {len(leftover)} file(s) under {install_dir} are paths this checkout "
-            "no longer tracks. An install/upgrade copies a release in and removes nothing, so "
-            "a file a later release dropped stays here and anything that reads this tree can "
-            "still read it."
-        )
-        for relative in shown:
-            print(f"    {relative}")
-        if len(leftover) > len(shown):
-            print(f"    ... and {len(leftover) - len(shown)} more")
-        if caches:
-            print(
-                f"    ({len(caches)} interpreter cache file(s) under __pycache__ are not "
-                "listed: no reader executes them as source)"
-            )
-        print(
-            "    remedy: reinstall from the release, or delete these, so no reader (a cycle, "
-            "an audit, a session) is answering a question about code no build ships. An "
-            "upgrade alone will not do it."
-        )
-
-    if not drifted:
-        print(
-            f"every file the install tree shares with this checkout holds content the "
-            f"refs a release is built from still reach ({checked} file(s) checked, "
-            f"{len(leftover)} named as leftovers above, "
-            f"{len(caches)} interpreter cache file(s) not listed)"
-        )
-        _report_release(install_dir, reading)
-        return 0
-
-
-    for relative, size, note in drifted:
-        print(f"{relative} ({size} bytes) - {note}")
-    print(f"{len(drifted)} file(s) hold content no shipped commit has; {checked} checked")
-    print(
-        "    this was edited in place. The install tree is not a git clone and an "
-        "install/upgrade replaces it whole, so the next one destroys it: move the change "
-        "into the source checkout and ship it, or it is lost."
-    )
-    _report_release(install_dir, reading)
-    return 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(_entry())
diff --git a/scripts/check-stacked-prs.py b/scripts/check-stacked-prs.py
deleted file mode 100644
index 5f6e7d66..00000000
--- a/scripts/check-stacked-prs.py
+++ /dev/null
@@ -1,362 +0,0 @@
-#!/usr/bin/env python3
-"""Which open PRs would land another open PR's commits?
-
-The class this exists for
--------------------------
-Measured 2026-10-06: PR #1879's head carried #1877's head commit, because the branch
-was cut from that PR's branch. `pulls/1879/commits` returned four commits, the first of
-them `b1e50447` - "emrg: grep counts only the files it really read", which is #1877's
-work and its own PR's declaration.
-
-    b1e50447  emrg: grep counts only the files it really read      <- #1877's head
-    ff847a52  emrg: the empty-tree leg holds every pointable guard <- #1879's own
-    ...
-
-A reviewer found it by reading the API by hand and vetoed the PR (2026-10-06T16:09:37Z,
-cycle `cyc20261006-215800`): "merging this head as it stands lands #1876's fix under a
-PR that declares only `Closes #1878`". **No reading in this repository caught it**, and
-the harm is the chain R5 exists for - the fix for one issue lands on a PR that does not
-declare it, leaving the second claim on an issue that is already finished.
-
-What the harm is measured to be, in both states
------------------------------------------------
-The same head, landable at two different bases. Before #1877 landed, master was
-`2e1a6e44`:
-
-    git merge-tree --write-tree --merge-base=2e1a6e44 2e1a6e44 c8b5bb5c  -> bb7d6d750872
-      emrg/tools/grep_tool.py                            44 ++++-
-      tests/test_a_tree_reading_guard_names_its_tree.py 141 ++++++++++   <- this PR's own
-      tests/test_grep_tool.py                            82 ++++++-
-
-Three paths, two of them #1876's fix riding under #1879's declaration. After #1877
-landed (master `65df80ac`) the same head was re-measured:
-
-    git merge-tree --write-tree --merge-base=65df80ac 65df80ac c8b5bb5c  -> bb7d6d750872
-      tests/test_a_tree_reading_guard_names_its_tree.py 141 ++++++++++   <- only its own
-
-One path. So the state this tool reports is a state of **the queue at the moment it is
-read**, and it decays by itself when the carried PR lands - which is why the condition
-below is "another PR is still open" rather than "the commit is not on master".
-
-Why the condition is "open", and what a SHA can and cannot say
--------------------------------------------------------------
-Measured 2026-10-07 (cycle `cyc20261007-045148`), asking the compare endpoint about
-three heads, the two landings being indistinguishable by SHA:
-
-    compare/master...b1e50447  --jq '{status,ahead_by,behind_by}' -> diverged, ahead 1
-    compare/master...65df80ac  (the same work, squash-landed as #1877) -> behind, ahead 0
-    compare/master...a7f3b03c  (master's tip)                          -> identical
-
-`b1e50447`'s content **is** on master and the compare endpoint says `diverged, ahead_by 1`
-- a squash landing leaves no commit behind, so no ancestor test can see it. A guard that
-read "the carried commit is not an ancestor of master" as "that work is not landed" would
-therefore report #1879's post-#1877 state - a state in which the landing changes one path -
-as a fault, forever. That is why the fault condition is the *queue* (the carried commit is
-the head of a PR that is still open) and not the graph.
-
-The compare endpoint is still used, in the one direction it can be trusted: it can prove a
-carried commit **is** landed (`behind`/`identical` - the commit is an ancestor of master)
-and never that it is not.
-
-What this tool does not answer
-------------------------------
-Whether the carrier's merge would change the carried PR's paths. On the two states above
-that is the whole difference (3 paths against 1), and it is
-`scripts/check-merge-landing-diff.py`'s question - it diffs the tree the merge produces.
-This tool reports the fact and the two remedies, and the landing instrument prices them.
-
-Exit codes: `0` every open PR carries only its own commits, `1` at least one carries
-another open PR's head, `2` the queue could not be read. A `2` is never a pass.
-
-Usage: scripts/check-stacked-prs.py [--repo owner/name]
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import subprocess
-import sys
-import traceback
-from dataclasses import dataclass, field
-from pathlib import Path
-
-REPO_DEFAULT = "argszero/emrg"
-
-#: How this file's python tools are invoked (`Agent.md`, "Test Commands"). Printed
-#: remedies carry it, for the reason `review-queue.py`'s constant gives: a bare
-#: `scripts/<name>.py` is mode 644 here and exits 126.
-RUNNER = "uv run --no-sync python3"
-
-#: The states in which a carried commit is provably already on master. Read from the
-#: compare endpoint (measured 2026-10-07): `behind` is an ancestor of master, `identical`
-#: is master's tip. Everything else - `ahead`, `diverged` - is *unknown*, and a squash
-#: landing answers `diverged` while its content is on master, so no other state may be
-#: read as landed.
-LANDED_STATES = ("behind", "identical")
-
-
-class MeasurementError(RuntimeError):
-    """A reading this tool could not take - never a verdict.
-
-    Raised rather than returned so `main` answers `2` with the cause, the code the family
-    uses for "could not measure": an unhandled exception here would exit `1`, which in
-    this family's tables is a *fault*.
-    """
-
-
-def _gh_json(args: list[str]) -> object:
-    """Run `gh` and parse JSON, failing loud rather than guessing.
-
-    The program name is prepended here so a call site cannot forget it (the mistake
-    `check-merge-freshness.py` records: a helper that omitted it ran the POSIX `pr`
-    utility instead).
-    """
-    proc = subprocess.run(
-        ["gh", *args], capture_output=True, text=True, encoding="utf-8", errors="replace"
-    )
-    if proc.returncode != 0:
-        raise MeasurementError(
-            f"gh failed (rc={proc.returncode}): gh {' '.join(args)}\n{proc.stderr.strip()}"
-        )
-    try:
-        return json.loads(proc.stdout)
-    except json.JSONDecodeError as exc:
-        raise MeasurementError(f"gh answered with something that is not JSON: {exc}") from exc
-
-
-def _gh_lines(args: list[str]) -> list[dict]:
-    """Every page of a list endpoint, as one list, through a caller-owned `--jq` filter.
-
-    `--paginate` with a `.[] | {...}` filter emits one JSON object per line across pages,
-    parsed per line because concatenated page arrays are not valid JSON. The filter belongs
-    to the caller, so a call site cannot end up with two `--jq` flags and a projection that
-    silently did not apply (`check-vote-count.py`'s measured incident).
-    """
-    proc = subprocess.run(
-        ["gh", *args, "--paginate"],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    if proc.returncode != 0:
-        raise MeasurementError(
-            f"gh failed (rc={proc.returncode}): gh {' '.join(args)} --paginate\n"
-            f"{proc.stderr.strip()}"
-        )
-    out: list[dict] = []
-    for line in proc.stdout.splitlines():
-        if not line.strip():
-            continue
-        try:
-            row = json.loads(line)
-        except json.JSONDecodeError as exc:
-            raise MeasurementError(f"gh answered with a line that is not JSON: {exc}") from exc
-        if not isinstance(row, dict):
-            raise MeasurementError(f"gh answered a list endpoint with {type(row).__name__}")
-        out.append(row)
-    return out
-
-
-def _open_pulls(repo: str) -> list[dict]:
-    """Every open PR, as the fields this tool reads.
-
-    The projection must have applied: without it the fields arrive under their raw names
-    and `head.sha` reads as empty, which would make every PR look like it carries nothing -
-    a clean report from a broken read.
-    """
-    rows = _gh_lines(
-        [
-            "api",
-            f"repos/{repo}/pulls?state=open&per_page=100",
-            "--jq",
-            ".[] | {number, title, head_sha: .head.sha, head_ref: .head.ref, "
-            "base_ref: .base.ref}",
-        ]
-    )
-    for row in rows:
-        if not row.get("number") or not row.get("head_sha"):
-            raise MeasurementError(
-                "the open-PR projection did not apply: a row came back without a number "
-                f"or a head sha ({row!r}) - this is not a queue with no carriers"
-            )
-    return rows
-
-
-def _commits_of(repo: str, number: int) -> list[dict]:
-    """The commits a PR adds, as `pulls/<N>/commits` reports them (merge base relative)."""
-    return _gh_lines(
-        [
-            "api",
-            f"repos/{repo}/pulls/{number}/commits?per_page=100",
-            "--jq",
-            ".[] | {sha, subject: (.commit.message | split(\"\\n\")[0])}",
-        ]
-    )
-
-
-def _commit_state(repo: str, sha: str) -> str:
-    """The compare endpoint's status for master against this commit, or `""`.
-
-    Asked only about a commit that is another open PR's head, and only to let the one
-    provable answer through (`LANDED_STATES`). A failure here is not a failure of the
-    reading: the row keeps its fault and says the state was not read.
-    """
-    payload = _gh_json(
-        ["api", f"repos/{repo}/compare/master...{sha}", "--jq", "{status: .status}"]
-    )
-    if not isinstance(payload, dict):
-        raise MeasurementError(f"the compare endpoint answered {type(payload).__name__}")
-    return str(payload.get("status") or "")
-
-
-@dataclass
-class Row:
-    """One open PR, and which other open PRs' commits it would land."""
-
-    number: int
-    title: str
-    head_sha: str
-    #: `(other PR's number, its head sha, its subject, its compare state or "")` per
-    #: carried head - the other PR's *own* head, never an arbitrary shared commit.
-    carried: list[tuple[int, str, str, str]] = field(default_factory=list)
-    #: Carried heads whose PR is open but whose commit is provably on master, so landing
-    #: them cannot carry that work again. Kept apart from `carried` rather than dropped:
-    #: a row that silently lost a finding would read the same as one that never had it.
-    already_landed: list[tuple[int, str, str]] = field(default_factory=list)
-
-    @property
-    def clean(self) -> bool:
-        return not self.carried
-
-
-def judge(repo: str, pulls: list[dict], commits_by_pr: dict[int, list[dict]]) -> list[Row]:
-    """One row per open PR: whose head commits it carries, and whether that PR is open.
-
-    The subject is the *head* of another open PR, not any commit shared between two
-    branches. Two branches cut from the same stale master share commits, and neither is
-    landing the other's work - the harm this reports needs the carried commit to be the
-    other PR's **head**, i.e. work that PR is still holding.
-    """
-    head_owner: dict[str, dict] = {}
-    for pull in pulls:
-        head_owner[str(pull["head_sha"])] = pull
-
-    rows: list[Row] = []
-    for pull in pulls:
-        number = int(pull["number"])
-        row = Row(
-            number=number,
-            title=str(pull.get("title") or ""),
-            head_sha=str(pull["head_sha"]),
-        )
-        for commit in commits_by_pr.get(number, []):
-            sha = str(commit.get("sha") or "")
-            owner = head_owner.get(sha)
-            if owner is None or int(owner["number"]) == number:
-                continue
-            subject = str(commit.get("subject") or "")
-            state = _commit_state(repo, sha)
-            if state in LANDED_STATES:
-                row.already_landed.append((int(owner["number"]), sha, subject))
-            else:
-                row.carried.append((int(owner["number"]), sha, subject, state))
-        rows.append(row)
-    return rows
-
-
-def _remedy(repo: str, row: Row) -> str:
-    """What the reader can do, built from the row rather than from a template."""
-    parts = []
-    for other, sha, subject, state in row.carried:
-        parts.append(
-            f"#{row.number} carries #{other}'s head {sha[:8]} (\"{subject}\"): merging it "
-            f"would land #{other}'s work under #{row.number}'s declaration, so land #{other} "
-            "first - then merge master into this branch (`git fetch origin master`, "
-            "`git merge FETCH_HEAD`, `git push origin <branch>`), which is what makes this "
-            f"PR's landing its own again. Measured on the shape this tool was written from: "
-            "three paths changed while the carried PR was open, one after it landed. The "
-            f"merge that changes what, for #{row.number}, is "
-            f"`{RUNNER} scripts/check-merge-landing-diff.py {row.number}` "
-            f"(compare state read: {state or 'not read'})"
-        )
-    return "\n".join(parts)
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(
-        prog="check-stacked-prs.py",
-        description=(
-            "Report every open PR whose branch carries another open PR's head commit, so "
-            "its merge would land work whose PR is still open."
-        ),
-    )
-    parser.add_argument("--repo", default=REPO_DEFAULT, help="owner/name")
-    args = parser.parse_args(argv)
-
-    try:
-        pulls = _open_pulls(args.repo)
-        commits_by_pr = {int(p["number"]): _commits_of(args.repo, int(p["number"])) for p in pulls}
-        rows = judge(args.repo, pulls, commits_by_pr)
-    except MeasurementError as exc:
-        print(f"cannot determine the stacked PRs: {exc}", file=sys.stderr)
-        return 2
-
-    print(f"repo: {args.repo}, {len(rows)} open PR(s)")
-    for row in rows:
-        mark = "stacked" if row.carried else "ok"
-        print(f"#{row.number} {mark} - {row.title}")
-        for other, sha, subject, state in row.carried:
-            print(f"    carries #{other} head {sha[:8]} (\"{subject}\") - compare {state or 'unread'}")
-        for other, sha, subject in row.already_landed:
-            print(
-                f"    carries #{other} head {sha[:8]}, whose work is already on master "
-                f"(\"{subject}\") - nothing to land twice, reported and not counted"
-            )
-
-    bad = [row for row in rows if not row.clean]
-    if not bad:
-        print(
-            f"OK: {len(rows)} open PR(s), none carries another open PR's head commit"
-        )
-        return 0
-
-    for row in bad:
-        print(_remedy(args.repo, row), file=sys.stderr)
-    print(
-        f"{len(bad)} of {len(rows)} open PR(s) would land another open PR's work",
-        file=sys.stderr,
-    )
-    return 1
-
-
-def _entry() -> int:
-    """`main`, with an unexpected failure reported as this tool's unmeasurable answer.
-
-    Python exits `1` for an unhandled exception, and `1` is a **verdict** in this tool's
-    exit table (a stacked PR), while `2` is the code for "the question could not be
-    answered" - so a caller that reads the code, or a cycle that reads this report, would
-    read a crash as a finding. Measured 2026-10-07 while arming this file: with the
-    open-PR projection check disabled, a row without `head_sha` reaches `judge` and raises
-    `KeyError`, and without this wrapper the tool exits `1` - "there is a stacked PR" - for
-    a queue it never read.
-
-    This file loads no sibling by file path, so it is not in the list
-    `tests/test_a_crash_is_a_measurement_error.py` pins to byte-identical entry points;
-    `DEVELOPMENT.md` says a gate like this "reaches the same rule by its own route and says
-    so where it does", and the rule is pinned here for this tool by its own suite
-    (`tests/test_check_stacked_prs.py::test_a_crash_answers_could_not_measure`).
-    """
-    try:
-        return main()
-    except Exception as exc:  # noqa: BLE001 - reported as unmeasurable, never swallowed
-        traceback.print_exc()
-        print(
-            f"{Path(__file__).name}: could not measure - {type(exc).__name__}: {exc}",
-            file=sys.stderr,
-        )
-        return 2  # cause: tool-failed
-
-
-if __name__ == "__main__":
-    sys.exit(_entry())
diff --git a/scripts/check-suite-durations.py b/scripts/check-suite-durations.py
deleted file mode 100644
index 17101816..00000000
--- a/scripts/check-suite-durations.py
+++ /dev/null
@@ -1,333 +0,0 @@
-#!/usr/bin/env python3
-"""Check that every CI leg's Python-suite step finishes inside the budget.
-
-The rule, and where it came from
---------------------------------
-Rant 2026-10-15T11:08:07 (issue #2296, requirement R4). The same serial
-`uv run pytest tests/ -v` ran on all six legs and took **16m55s on the Windows leg**
-against 4m12s on Linux; the host's ruling was that "macOS cannot produce Windows
-numbers" is not an excuse for leaving it unmeasured, and that the final check belongs
-to CI. So the number this guard reads has to *be* CI's, and the only place CI's number
-exists is the run's own record.
-
-What it reads, and what it may never read
------------------------------------------
-The duration comes from the GitHub API's own step records: each job carries
-`steps[]`, and each step carries `started_at` / `completed_at`. The number is
-therefore the runner's own, not one copied into this file — the defect class this
-repository calls "a derived number written where a guard can measure it". The single
-duration written down here is `BUDGET_SECONDS`, and that is the *rule* the rant
-states, not a measurement.
-
-Nothing is parsed out of the log text. Line timestamps would work, but the log for a
-four-platform matrix is megabytes per run and the API already hands over the two
-instants, so the reading is the platform's own arithmetic rather than this file's
-reconstruction of it.
-
-Three states, the family's contract
------------------------------------
-* **0** — every suite step found is within the budget, and every declared workflow
-  contributed a run this guard could read.
-* **1** — at least one leg is over budget. The offending legs are named with their
-  measured seconds.
-* **2** — could not measure, with the reason. A workflow whose latest run contributes
-  no readable suite step lands here rather than passing: a leg nobody could read is
-  not a leg that passed, and reporting it as one is the failure this whole family
-  exists to prevent.
-
-Usage
------
-    uv run --no-sync python3 scripts/check-suite-durations.py
-    uv run --no-sync python3 scripts/check-suite-durations.py --run 38679700467
-    uv run --no-sync python3 scripts/check-suite-durations.py --json
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import subprocess
-import sys
-from datetime import datetime
-
-#: The repository whose runs are read, when none is named.
-DEFAULT_REPO = "argszero/emrg"
-
-#: The rule, in seconds: the rant asks for the whole suite inside three minutes on
-#: every leg. This is the one duration this file is allowed to state — every figure in
-#: the *reading* below comes from the API.
-BUDGET_SECONDS = 180
-
-#: The workflows whose suite steps the rule covers. `test.yml` runs on every pull
-#: request and on master (ubuntu + windows, two legs); `build-release.yml` runs on a
-#: tag and carries the four-platform matrix, so between them they are the six legs the
-#: rant measured. Named rather than discovered, because a workflow that quietly left
-#: this tuple would leave the rule without a subject — and that is exactly what the
-#: per-workflow "contributed nothing" refusal below turns into rc 2.
-WORKFLOWS = ("test.yml", "build-release.yml")
-
-#: How a suite step is recognised in the API's step list. A step's API `name` is its
-#: `name:` when the workflow gave it one, and the run command when it did not — which is
-#: why the spellings differ across the six legs and why this is a list rather than one
-#: word. Read off the two workflows: the ubuntu step is unnamed (`uv run pytest tests/
-#: -v -n auto --dist loadfile`), and the two named ones are `Python tests (Windows)` and
-#: `Python tests (regression gate)`.
-#:
-#: A rename that hid a step from this list would turn that workflow's reading into
-#: "contributed nothing" (rc 2, never a pass), and
-#: `tests/test_check_suite_durations.py::test_every_declared_workflow_carries_a_step_this_guard_can_see`
-#: fails at the tree level before CI is ever asked.
-SUITE_STEP_MARKERS = ("pytest", "python tests")
-
-
-class Unmeasurable(Exception):
-    """The reading could not be taken. Carries the reason the refusals print."""
-
-
-def _gh_json(args: list[str]) -> object:
-    """Run `gh` and parse JSON, failing loud rather than guessing.
-
-    `args` excludes the program name, which is prepended here so no call site can omit
-    it. The failure is raised as `Unmeasurable` rather than returned as an empty
-    document: an unreadable answer must reach the caller as "could not measure", and a
-    `{}` a caller could mistake for "no runs" would print a pass.
-    """
-    try:
-        proc = subprocess.run(
-            ["gh", *args],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=120,
-        )
-    except FileNotFoundError:
-        raise Unmeasurable(
-            "gh is not available, so no CI run can be read "
-            "(install it, or run this where gh is on PATH)"
-        ) from None
-    except subprocess.TimeoutExpired:
-        raise Unmeasurable(f"gh timed out reading: gh {' '.join(args)}") from None
-    if proc.returncode != 0:
-        # `gh api` exits 1 for a 404 as well as for a real failure, so the status is
-        # read out of the message: a 404 means the run is not there, which is a
-        # different sentence from "the network refused".
-        raise Unmeasurable(
-            f"gh failed (rc={proc.returncode}) reading `gh {' '.join(args)}`: "
-            f"{proc.stderr.strip()}"
-        )
-    try:
-        return json.loads(proc.stdout)
-    except json.JSONDecodeError as exc:
-        raise Unmeasurable(f"gh returned no JSON reading `gh {' '.join(args)}`: {exc}") from None
-
-
-def parse_stamp(value: object) -> datetime | None:
-    """An ISO-8601 instant from the API, or `None` when it cannot be read.
-
-    GitHub sends `...Z`; `fromisoformat` takes it from 3.11 on, and the explicit
-    replacement keeps the reading identical on a build that does not.
-    """
-    if not isinstance(value, str) or not value:
-        return None
-    try:
-        return datetime.fromisoformat(value.replace("Z", "+00:00"))
-    except ValueError:
-        return None
-
-
-def step_seconds(step: dict) -> float | None:
-    """How long a step took, or `None` when the artefact does not say.
-
-    A step that has not finished carries `completed_at: null`, and one that was
-    skipped carries no instants at all. Both are unreadable rather than zero: a step
-    that did not run has no duration, and reporting 0.0s for it would be this guard
-    inventing the very number it exists to measure.
-    """
-    started = parse_stamp(step.get("started_at"))
-    completed = parse_stamp(step.get("completed_at"))
-    if started is None or completed is None:
-        return None
-    seconds = (completed - started).total_seconds()
-    return seconds if seconds >= 0 else None
-
-
-def is_suite_step(step: dict) -> bool:
-    """Whether this step is one that runs the Python suite."""
-    name = step.get("name")
-    if not isinstance(name, str):
-        return False
-    lowered = name.lower()
-    return any(marker in lowered for marker in SUITE_STEP_MARKERS)
-
-
-def latest_completed_run(repo: str, workflow: str) -> dict:
-    """The most recent finished run of `workflow`, newest first.
-
-    Deliberately **not** filtered by branch. `build-release.yml` is triggered by a tag
-    rather than by a branch, so a `branch=master` filter would silently return nothing
-    for that workflow and the four matrix legs would leave the reading without anyone
-    noticing — the failure mode is an empty list, which reads as success. Which run was
-    read is printed before the verdict instead, so the subject is always nameable.
-    """
-    payload = _gh_json([
-        "api",
-        f"repos/{repo}/actions/workflows/{workflow}/runs?status=completed&per_page=1",
-    ])
-    if not isinstance(payload, dict):
-        raise Unmeasurable(f"{workflow}: the runs list was not an object")
-    runs = payload.get("workflow_runs")
-    if not isinstance(runs, list) or not runs:
-        raise Unmeasurable(f"{workflow}: no completed run to read")
-    run = runs[0]
-    if not isinstance(run, dict) or "id" not in run:
-        raise Unmeasurable(f"{workflow}: the newest run carries no id")
-    return run
-
-
-def run_jobs(repo: str, run_id: object) -> list[dict]:
-    """Every job of a run, in the order the API returned them."""
-    payload = _gh_json(["api", f"repos/{repo}/actions/runs/{run_id}/jobs?per_page=100"])
-    if not isinstance(payload, dict):
-        raise Unmeasurable(f"run {run_id}: the jobs list was not an object")
-    jobs = payload.get("jobs")
-    if not isinstance(jobs, list):
-        raise Unmeasurable(f"run {run_id}: the jobs list was not a list")
-    return [job for job in jobs if isinstance(job, dict)]
-
-
-def read_legs(repo: str, run: dict) -> list[dict]:
-    """The suite steps of one run, each with its leg's job name and its duration."""
-    legs = []
-    for job in run_jobs(repo, run.get("id")):
-        for step in job.get("steps") or []:
-            if not isinstance(step, dict) or not is_suite_step(step):
-                continue
-            legs.append({
-                "job": job.get("name") or "(unnamed job)",
-                "step": step.get("name") or "",
-                "seconds": step_seconds(step),
-                # Carried raw so a reader can check this file's arithmetic against the
-                # platform's own two instants, and so a PR can quote them without
-                # re-asking the API.
-                "started_at": step.get("started_at"),
-                "completed_at": step.get("completed_at"),
-                "conclusion": job.get("conclusion"),
-            })
-    return legs
-
-
-def collect(repo: str, label: str, run: dict) -> tuple[dict, list[dict]]:
-    """One run's suite-step readings, with `label` naming the workflow it came from."""
-    legs = read_legs(repo, run)
-    if not legs:
-        raise Unmeasurable(
-            f"{label} run {run.get('id')}: no step this guard can recognise as the "
-            f"Python suite (markers: {', '.join(SUITE_STEP_MARKERS)}) — a leg nobody "
-            "could read is not a leg that passed"
-        )
-    return run, legs
-
-
-def subjects(repo: str, workflows: tuple[str, ...], run_id: str | None) -> list[tuple[str, dict]]:
-    """The `(label, run)` pairs to read.
-
-    With `--run` the subject is that one run, read **once**: a run belongs to exactly
-    one workflow, so looping the declared workflows would read the same jobs once per
-    workflow and report every leg as many times as the tuple has entries.
-    """
-    if run_id is not None:
-        payload = _gh_json(["api", f"repos/{repo}/actions/runs/{run_id}"])
-        if not isinstance(payload, dict) or "id" not in payload:
-            raise Unmeasurable(f"run {run_id}: no such run")
-        label = payload.get("path") or payload.get("name") or f"run {run_id}"
-        return [(str(label), payload)]
-    return [(workflow, latest_completed_run(repo, workflow)) for workflow in workflows]
-
-
-def main(argv: list[str]) -> int:
-    parser = argparse.ArgumentParser(
-        description=(
-            "Read each CI leg's Python-suite step duration from the GitHub API and "
-            f"assert it is within {BUDGET_SECONDS}s."
-        )
-    )
-    parser.add_argument("--repo", default=DEFAULT_REPO, help="owner/name")
-    parser.add_argument(
-        "--run",
-        default=None,
-        help="read this run id instead of the newest completed run of each workflow",
-    )
-    parser.add_argument(
-        "--budget",
-        type=int,
-        default=BUDGET_SECONDS,
-        help=f"the per-step budget in seconds (default {BUDGET_SECONDS})",
-    )
-    parser.add_argument(
-        "--workflow",
-        action="append",
-        default=None,
-        help="restrict to this workflow file (repeatable; default: all declared ones)",
-    )
-    parser.add_argument("--json", action="store_true", help="emit the reading as JSON")
-    args = parser.parse_args(argv)
-
-    workflows = tuple(args.workflow) if args.workflow else WORKFLOWS
-
-    print(f"repo: {args.repo}")
-    print(f"budget: {args.budget}s per Python-suite step")
-
-    reading: list[dict] = []
-    over: list[dict] = []
-    try:
-        for label, run in subjects(args.repo, workflows, args.run):
-            _run, legs = collect(args.repo, label, run)
-            print(
-                f"{label} run {run.get('id')} "
-                f"({run.get('head_branch') or '(no branch)'}, "
-                f"{run.get('created_at') or '(no timestamp)'})"
-            )
-            for leg in legs:
-                seconds = leg["seconds"]
-                if seconds is None:
-                    print(f"  {leg['job']}: could not measure (no step instants)")
-                    raise Unmeasurable(
-                        f"{label}: job {leg['job']!r} ran the suite but the step "
-                        "carries no started_at/completed_at, so its time is unknown"
-                    )
-                verdict = "OVER" if seconds > args.budget else "ok"
-                print(
-                    f"  {leg['job']}: {seconds:.1f}s "
-                    f"({leg['started_at']} -> {leg['completed_at']}) - {verdict}"
-                )
-                row = {
-                    **leg,
-                    "workflow": label,
-                    "run": run.get("id"),
-                    "seconds": seconds,
-                }
-                reading.append(row)
-                if seconds > args.budget:
-                    over.append(row)
-    except Unmeasurable as exc:
-        if args.json:
-            print(json.dumps({"ok": None, "reason": str(exc), "legs": reading}, indent=2))
-        print(f"could not measure: {exc}", file=sys.stderr)
-        return 2
-
-    if args.json:
-        print(json.dumps({"ok": not over, "budget": args.budget, "legs": reading}, indent=2))
-
-    if over:
-        print(
-            f"OVER: {len(over)} of {len(reading)} suite step(s) exceed "
-            f"{args.budget}s - {', '.join(sorted({row['job'] for row in over}))}"
-        )
-        return 1
-
-    print(f"OK: every Python-suite step is within {args.budget}s ({len(reading)} leg(s) read)")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))
diff --git a/scripts/llm-cost-report.py b/scripts/llm-cost-report.py
deleted file mode 100644
index 877fd3a3..00000000
--- a/scripts/llm-cost-report.py
+++ /dev/null
@@ -1,292 +0,0 @@
-#!/usr/bin/env python3
-"""Estimate LLM API spend from session llm.jsonl usage records.
-
-Comparable-tool inspiration: Claude Code v2.1.247 added `/claude-api
-cost-optimize` (API cost profiling). EMRG already persists real token usage
-per request — emrg/session.py ``append_llm`` writes every exchange to
-``llm.jsonl`` with ``type: request`` (carrying ``model``) followed by
-``type: response`` (carrying the ``usage`` dict: prompt_tokens /
-completion_tokens / reasoning_tokens / cache_hit_tokens). The missing piece
-was only an aggregator + pricing table, which this script provides.
-
-Behavior:
-
-  * Scans session directories (default: every session in
-    ``~/.emrg/sessions_index.json``; ``--root`` for one ``.emrg/sessions``
-    dir; ``--session-id`` for a single indexed session).
-  * Reads ``llm.jsonl`` plus rotated ``.N`` backups in chronological order
-    (``.3`` oldest → ``llm.jsonl`` newest) so a response in an old backup is
-    still paired with its request.
-  * Pairs each response's usage with the model of the nearest preceding
-    request record; a response with no preceding request (truncated log) is
-    reported under ``(unknown)``.
-  * Applies a per-model pricing table ($ per 1M tokens, prompt/completion).
-    Prices are public-list approximations — output is an ESTIMATE, not an
-    invoice.
-  * Prompt-cache semantics: if ``prompt_tokens_details.cached_tokens`` is
-    present (OpenAI style, prompt_tokens excludes cache), it is billed at 10%
-    of the prompt price. Otherwise ``cache_hit_tokens`` is assumed to be
-    included in prompt_tokens (DeepSeek style) and billed at 10% of the
-    prompt price.
-  * Unknown models are listed separately at $0 with a warning; add or
-    override prices with ``--pricing model:prompt_ppm:completion_ppm``.
-
-Exit code is always 0 for a successful report (broken lines are skipped with
-a warning on stderr — a report tool must not fail on one corrupt record).
-
-Usage examples::
-
-    scripts/llm-cost-report.py                          # all indexed sessions
-    scripts/llm-cost-report.py --session-id emrg-task
-    scripts/llm-cost-report.py --root ~/.emrg/.emrg/sessions --json
-    scripts/llm-cost-report.py --pricing my-model:0.5:1.5
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import sys
-from collections import OrderedDict
-from pathlib import Path
-from typing import Iterator
-
-# ($ per 1,000,000 tokens: prompt, completion) — public-list approximations.
-PPM_DEFAULTS: dict[str, tuple[float, float]] = OrderedDict(
-    [
-        ("deepseek-v4-flash", (0.20, 1.20)),
-        ("deepseek-v4", (1.00, 3.00)),
-        ("deepseek-reasoner", (0.55, 2.19)),
-        ("deepseek-chat", (0.27, 1.10)),
-        ("claude-sonnet-4-5", (3.00, 15.00)),
-        ("claude-opus-4-5", (5.00, 25.00)),
-        ("claude-3-5-sonnet", (3.00, 15.00)),
-        ("gpt-5", (1.25, 10.00)),
-        ("gpt-5-mini", (0.25, 2.00)),
-        ("gpt-4o", (2.50, 10.00)),
-        ("qwen-max", (1.60, 6.40)),
-        ("qwen-plus", (0.40, 1.20)),
-    ]
-)
-
-CACHE_PRICE_FRACTION = 0.10  # prompt-cache hits are typically ~10% of prompt price
-
-UNKNOWN = "(unknown)"
-
-
-def default_index_path() -> Path:
-    return Path.home() / ".emrg" / "sessions_index.json"
-
-
-def session_dirs(
-    root: str | None = None,
-    session_id: str | None = None,
-    index_path: Path | None = None,
-) -> list[Path]:
-    """Resolve the session directories to scan."""
-    if root:
-        base = Path(root).expanduser()
-        if not base.is_dir():
-            sys.stderr.write(f"warning: --root {root} is not a directory\n")
-            return []
-        return sorted(p for p in base.iterdir() if p.is_dir())
-    index = index_path or default_index_path()
-    try:
-        mapping = json.loads(index.read_text(encoding="utf-8"))
-    except (OSError, ValueError) as exc:
-        sys.stderr.write(f"warning: cannot read {index}: {exc}\n")
-        return []
-    if session_id:
-        path = mapping.get(session_id)
-        if not path:
-            sys.stderr.write(f"warning: session {session_id!r} not in {index}\n")
-            return []
-        return [Path(path)]
-    return [Path(p) for p in mapping.values() if Path(p).is_dir()]
-
-
-def _llm_log_files(session_dir: Path) -> list[Path]:
-    """llm.jsonl + rotated backups, oldest first (chronological)."""
-
-    def key(f: Path) -> int:
-        suffix = f.name[len("llm.jsonl"):]  # "" or ".1", ".2", ...
-        # Rotation shifts main -> .1 -> .2 -> .3, so .3 is the OLDEST backup
-        # and the main file is the newest. Read chronologically: .3 first.
-        return -int(suffix[1:]) if suffix else 10**9
-
-    files = sorted(session_dir.glob("llm.jsonl*"), key=key)
-    return files
-
-
-def iter_llm_records(session_dir: Path) -> Iterator[tuple[str, dict]]:
-    """Yield (model, usage) for every response record that carries usage.
-
-    ``model`` is taken from the nearest preceding request record in
-    chronological order (across rotation files); ``(unknown)`` when none.
-    Corrupt lines are skipped with a warning.
-    """
-    last_model: str | None = None
-    for path in _llm_log_files(session_dir):
-        try:
-            fh = path.open(encoding="utf-8", errors="replace")
-        except OSError as exc:
-            sys.stderr.write(f"warning: cannot open {path}: {exc}\n")
-            continue
-        with fh:
-            for lineno, line in enumerate(fh, 1):
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    rec = json.loads(line)
-                except ValueError:
-                    sys.stderr.write(
-                        f"warning: {path.name}:{lineno}: corrupt line skipped\n"
-                    )
-                    continue
-                if not isinstance(rec, dict):
-                    continue
-                if rec.get("type") == "request":
-                    if isinstance(rec.get("model"), str):
-                        last_model = rec["model"]
-                    continue
-                if rec.get("type") == "response" and isinstance(rec.get("usage"), dict):
-                    yield (last_model or UNKNOWN, rec["usage"])
-
-
-def estimate_cost(usage: dict, prompt_ppm: float, completion_ppm: float) -> float:
-    """Dollar estimate for one response, honoring prompt-cache pricing."""
-    prompt = usage.get("prompt_tokens") or 0
-    completion = usage.get("completion_tokens") or 0
-    details = usage.get("prompt_tokens_details")
-    cache = 0
-    if isinstance(details, dict) and isinstance(details.get("cached_tokens"), int):
-        # OpenAI style: prompt_tokens excludes the cache; bill cache separately.
-        cache = details["cached_tokens"]
-        billed_prompt = prompt
-    else:
-        # DeepSeek style: cache_hit_tokens ⊂ prompt_tokens.
-        cache = usage.get("cache_hit_tokens") or 0
-        billed_prompt = max(prompt - cache, 0)
-    return (
-        prompt_ppm * billed_prompt / 1e6
-        + completion_ppm * completion / 1e6
-        + CACHE_PRICE_FRACTION * prompt_ppm * cache / 1e6
-    )
-
-
-def report(session_dirs_: list[Path], pricing: dict[str, tuple[float, float]]) -> dict:
-    """Aggregate usage+cost across sessions. Returns per-model rows + totals."""
-    agg: dict[str, dict] = {}
-    unknown_models: set[str] = set()
-    for sd in session_dirs_:
-        for model, usage in iter_llm_records(sd):
-            row = agg.setdefault(
-                model,
-                {
-                    "requests": 0,
-                    "prompt_tokens": 0,
-                    "cache_hit_tokens": 0,
-                    "completion_tokens": 0,
-                    "cost": 0.0,
-                    "priced": False,
-                },
-            )
-            row["requests"] += 1
-            row["prompt_tokens"] += usage.get("prompt_tokens") or 0
-            row["cache_hit_tokens"] += usage.get("cache_hit_tokens") or 0
-            row["completion_tokens"] += usage.get("completion_tokens") or 0
-            pp, cp = pricing.get(model, (0.0, 0.0))
-            row["cost"] += estimate_cost(usage, pp, cp)
-            if model in pricing:
-                row["priced"] = True
-            else:
-                unknown_models.add(model)
-    totals = {
-        "requests": sum(r["requests"] for r in agg.values()),
-        "prompt_tokens": sum(r["prompt_tokens"] for r in agg.values()),
-        "cache_hit_tokens": sum(r["cache_hit_tokens"] for r in agg.values()),
-        "completion_tokens": sum(r["completion_tokens"] for r in agg.values()),
-        "cost": sum(r["cost"] for r in agg.values()),
-    }
-    return {"models": agg, "totals": totals, "unknown_models": sorted(unknown_models)}
-
-
-def render_human(result: dict) -> str:
-    models = result["models"]
-    if not models:
-        return "No usage records found in the given sessions.\n"
-    rows = sorted(models.items(), key=lambda kv: -kv[1]["cost"])
-    lines = [
-        f"{'Model':<22}{'Requests':>9}{'Prompt tok':>13}{'Cache tok':>11}"
-        f"{'Compl tok':>12}{'Est cost':>14}"
-    ]
-    lines.append("-" * len(lines[0]))
-    for name, r in rows:
-        priced = " *" if not r["priced"] else ""
-        cost = f"${r['cost']:,.4f}"
-        lines.append(
-            f"{name:<22}{r['requests']:>9,}{r['prompt_tokens']:>13,}"
-            f"{r['cache_hit_tokens']:>11,}{r['completion_tokens']:>12,}"
-            f"{cost:>14}{priced}"
-        )
-    t = result["totals"]
-    lines.append("-" * len(lines[0]))
-    cost = f"${t['cost']:,.4f}"
-    lines.append(
-        f"{'TOTAL':<22}{t['requests']:>9,}{t['prompt_tokens']:>13,}"
-        f"{t['cache_hit_tokens']:>11,}{t['completion_tokens']:>12,}"
-        f"{cost:>14}"
-    )
-    lines.append("")
-    if result["unknown_models"]:
-        lines.append(
-            "(*) no price — add with --pricing model:prompt_ppm:completion_ppm: "
-            + ", ".join(result["unknown_models"])
-        )
-    else:
-        lines.append("Estimated cost — public-list approximations, not an invoice.")
-    return "\n".join(lines)
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(
-        description="Estimate LLM API spend from session llm.jsonl usage records."
-    )
-    parser.add_argument("--root", help="scan this .emrg/sessions directory")
-    parser.add_argument("--session-id", help="scan one indexed session by id")
-    parser.add_argument(
-        "--json", action="store_true", help="emit machine-readable JSON instead of a table"
-    )
-    parser.add_argument(
-        "--pricing",
-        action="append",
-        default=[],
-        metavar="MODEL:PROMPT_PPM:COMPLETION_PPM",
-        help="add/override a model price ($ per 1M tokens); repeatable",
-    )
-    args = parser.parse_args(argv)
-
-    pricing = dict(PPM_DEFAULTS)
-    for spec in args.pricing:
-        parts = spec.split(":")
-        if len(parts) != 3:
-            parser.error(f"--pricing expects MODEL:PROMPT_PPM:COMPLETION_PPM, got {spec!r}")
-        model, prompt_ppm, completion_ppm = parts
-        pricing[model] = (float(prompt_ppm), float(completion_ppm))
-
-    dirs = session_dirs(root=args.root, session_id=args.session_id)
-    if not dirs:
-        sys.stderr.write("No session directories to scan.\n")
-        return 1
-    result = report(dirs, pricing)
-    if args.json:
-        print(json.dumps(result, ensure_ascii=False, indent=2))
-    else:
-        print(render_human(result))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
diff --git a/scripts/recover-worktree.py b/scripts/recover-worktree.py
deleted file mode 100644
index 0f2f0e9e..00000000
--- a/scripts/recover-worktree.py
+++ /dev/null
@@ -1,230 +0,0 @@
-#!/usr/bin/env python3
-"""Recover a working tree whose dirt is **reconstructible** (issue #1237).
-
-Why this exists
----------------
-`scheduler._effective_sandbox` forces a cycle whose source tree is dirty down to
-`read-only`, and `read-only` refuses every git verb that could clean it: measured
-`checkout`/`reset`/`restore`/`switch`/`merge`/`stash`/`update-ref`/`symbolic-ref`/
-`commit`/`push` = **10/10 BLOCK**. The state that triggered the downgrade therefore
-disabled the only exit from it, and the cost was measured: **33 consecutive
-zero-commit cycles**, with 40+ verified patches stranded outside the repository.
-
-The criterion that makes acting decidable is *"would anything be lost?"*, not *"is
-the tree dirty?"* — the two differ, and they differed expensively: of the dirt in
-that stretch, git reported 2 modified files and **both were byte-identical to
-upstream's own blobs**, so discarding them lost nothing at all.
-`scheduler._dirty_tree_would_lose_work_sync` answers that question, and
-`scheduler._recover_dirty_tree_sync` acts on it: a reconstructible tree is now
-converged by the daemon itself at the start of a cycle, so the deadlock is not
-something a human has to be present to break. This command is the **manual** route
-— the same action, from a shell, for a tree no cycle is about to touch.
-
-What it does
-------------
-Diagnose, then — only with `--apply` — converge, through the one implementation the
-daemon also uses (this script owns no policy; if it disagreed with the guard about
-what "reconstructible" means, the deadlock would come back through the script):
-
-* the tree is already clean -> nothing to do;
-* the dirt holds work that exists nowhere else -> **pin it, then converge**. `HEAD` and
-  the stash commit are recorded under `refs/emrg/rescue/`, which is what "exists nowhere
-  else" was about, so the claim stops being true and the tree can be converged without
-  discarding anything. Nothing is destroyed by this and nothing is left for a human to
-  unblock: the state this rule used to produce — a `read-only` tier that refuses the git
-  verbs needed to converge the tree — is the absorbing state of issue #1465, and pinning
-  is its exit. Undone with `git stash apply --index refs/emrg/rescue/<stamp>`, which
-  survives `git stash clear`;
-* the dirt is reconstructible -> `git stash push -u` it, which leaves the worktree
-  clean *and* keeps every byte in the stash, so the action is undoable — with
-  `git stash apply --index stash@{N}`, the spelling the receipt names, `N` being the
-  ordinal `git stash list` prints for the message the receipt carries; and *not*
-  with a bare `git stash pop` (it takes the newest stash, brings a staged change
-  back unstaged, and consumes the stash; issue #1284). The ordinal is the selector
-  because no `@{…}` form names a stash **by message**: `stash^{/<message>}` searches
-  commit ancestry (rc=1 once a later stash exists) and `stash@{/<message>}` resolves
-  to the newest entry whatever message it is given, i.e. it applies the wrong stash
-  successfully — both measured. **No branch is reset and no commit is dropped** —
-  this never moves `HEAD`.
-
-Every `--apply` writes a receipt into the **git state dir** (see
-`scheduler._git_state_dir` — a location that cannot dirty the tree it just cleaned),
-as the structural guard's contract requires of every release of a safety rule. It is
-best-effort, so the stdout and the action's detail *say so* when one could not be
-written rather than naming a path for a file that does not exist (issue #1284).
-
-Exit codes
-----------
-``0``  nothing to do, or the tree was converged and verified (also: a dry run of a
-       tree that *would* converge). ``1``  diagnosed but not acted on: the tree holds
-       work found nowhere else and `--apply` was **not** given, so nothing was
-       written — `--apply` would pin it and converge, discarding nothing. ``2``  the
-       question could not be answered (not a git repo, an unreadable state) — never
-       reported as a pass.
-
-Usage
------
-    uv run --no-sync python scripts/recover-worktree.py --repo <dir>
-    uv run --no-sync python scripts/recover-worktree.py --repo <dir> --apply
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from emrg.server.scheduler import TaskHandler, recovery_recipe  # noqa: E402  (needs the path above)
-
-
-def _git(repo: Path, *args: str, timeout: int = 30):
-    """Run git in `repo`. `-C` rather than chdir so the caller's cwd is untouched."""
-    return subprocess.run(
-        ["git", "-C", str(repo), *args],
-        capture_output=True, text=True, timeout=timeout,
-        encoding="utf-8", errors="replace",
-    )
-
-
-def _status_lines(repo: Path) -> list[str] | None:
-    """`git status --porcelain` lines, or None when it could not be read."""
-    out = _git(repo, "status", "--porcelain", "--untracked-files=normal")
-    if out.returncode != 0:
-        return None
-    return [line for line in out.stdout.splitlines() if line.strip()]
-
-
-def _rev(repo: Path, ref: str) -> str | None:
-    out = _git(repo, "rev-parse", "--verify", "--quiet", ref)
-    if out.returncode != 0 or not out.stdout.strip():
-        return None
-    return out.stdout.strip()
-
-
-def _receipt_path(repo: Path) -> str | None:
-    """Where the daemon's own recovery writes its receipt, or None."""
-    state = TaskHandler._git_state_dir(str(repo))
-    return None if state is None else os.path.join(state, "emrg-recovery-receipt.json")
-
-
-def _receipt_recipe(receipt: str | None, detail: str) -> str | None:
-    """This run's reversal recipe, read from the receipt it wrote; None if unusable.
-
-    The recipe is not restated here — it is the action's own string, so the manual
-    route and the daemon cannot drift apart about how to undo the move (issue #1284).
-
-    `detail` is what makes "this run's" checkable rather than assumed: the receipt's
-    own `stash_message` has to appear in the detail the action just returned. A
-    receipt left over from an earlier recovery names a *different* stash, and a reader
-    who follows it would apply the wrong one — worse than the paraphrase this replaced.
-    """
-    if not receipt or not os.path.isfile(receipt):
-        return None
-    try:
-        with open(receipt, encoding="utf-8") as handle:
-            data = json.load(handle)
-    except (OSError, ValueError):
-        return None
-    if not isinstance(data, dict):
-        return None
-    message = data.get("stash_message")
-    recipe = data.get("reversible_with")
-    if not message or not isinstance(recipe, str) or message not in detail:
-        return None
-    return recipe
-
-
-def recover(repo: Path, apply: bool) -> int:
-    """Diagnose `repo`, and converge it when `apply` and it is safe. Returns an exit code."""
-    if _rev(repo, "HEAD") is None:
-        print(f"could not measure: {repo} is not a git repository with a commit")
-        return 2
-
-    entries = _status_lines(repo)
-    if entries is None:
-        print(f"could not measure: `git status` failed in {repo}")
-        return 2
-    if not entries:
-        print(f"clean: {repo} has no uncommitted changes; nothing to recover")
-        return 0
-
-    # One owner for the criterion: the same question the guard asks, so the tool
-    # and the tier decision can never disagree about what "reconstructible" means.
-    loses, why = TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    if loses and not apply:
-        # A dry run does not act anywhere, so this is a report rather than a refusal to
-        # rescue. Since the fix for #1465 the daemon pins work found nowhere else under
-        # `refs/emrg/rescue/` and converges, and `--apply` here runs that exact function —
-        # so exit 1 now means "diagnosed, and nothing was done about it", which is one
-        # flag away from being resolved rather than the terminal state it used to be.
-        print(f"unique: {repo} holds work that exists nowhere else: {why}")
-        print(f"{len(entries)} entr(y|ies) would be PINNED under refs/emrg/rescue/ and "
-              "stashed; nothing is discarded; re-run with --apply")
-        return 1
-
-    if not apply:
-        print(f"recoverable: {why}")
-        print(f"{len(entries)} entr(y|ies) would be stashed (reversible); re-run with --apply")
-        return 0
-
-    # One owner for the action too: the daemon runs this exact function at the start
-    # of a cycle, so what a human runs here and what the guard does cannot drift. It
-    # accepts no verdict from a caller and re-measures the criterion itself, so a tree
-    # that changed between the diagnosis above and this line is judged on its current
-    # state rather than on the earlier answer.
-    status, detail = TaskHandler._recover_dirty_tree_sync(str(repo))
-    if status == "error":
-        print(f"could not measure: {detail}")
-        return 2
-    if status == "clean":
-        print(f"clean: {repo} has no uncommitted changes; nothing to recover")
-        return 0
-
-    receipt = _receipt_path(repo)
-    print(f"recovered: {repo} converged to a clean tree; {detail}")
-    # One owner for the spelling too (issue #1284): the receipt's `reversible_with` is
-    # the recipe, so it is *printed* rather than paraphrased. The two used to disagree
-    # — the receipt said `apply --index`, this line said a bare `git stash pop` — and
-    # the spelling a reader saw here is the one that costs them the staged side and the
-    # stash itself. `None` means the receipt is unreadable or belongs to an earlier
-    # recovery, and there is then no *this run's* message to name, so the fallback
-    # prints the same recipe with the placeholder the reader substitutes from
-    # `git stash list` — the same function, not a third copy of it.
-    recipe = _receipt_recipe(receipt, detail)
-    if recipe:
-        print(f"reversible: {recipe}")
-    else:
-        print(f"reversible: {recovery_recipe('<message>')}")
-    # The path is not the receipt (issue #1284): `_receipt_path` computes where one
-    # *would* be written, so the branch below used to be unreachable — it printed a
-    # path for a file that an `OSError` had kept from existing. Ask the file — and ask
-    # whether it is a *file*, because "something exists at this path" is also true of
-    # the directory that the write failed against (the forced failure in the test).
-    if receipt and os.path.isfile(receipt):
-        print(f"receipt: {receipt}")
-    else:
-        print("receipt: could not be written")
-    return 0
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(
-        description="Converge a working tree whose uncommitted changes are "
-                    "reconstructible, reversibly, with a receipt.",
-    )
-    parser.add_argument("--repo", default=".", help="repository to inspect (default: .)")
-    parser.add_argument(
-        "--apply", action="store_true",
-        help="perform the recovery; without it the tool only reports",
-    )
-    args = parser.parse_args(argv)
-    return recover(Path(args.repo).resolve(), args.apply)
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/scripts/run-mutation-arm.py b/scripts/run-mutation-arm.py
deleted file mode 100644
index b0a71397..00000000
--- a/scripts/run-mutation-arm.py
+++ /dev/null
@@ -1,880 +0,0 @@
-#!/usr/bin/env python3
-"""Run one mutation arm and judge it, separating "the test failed" from "nothing ran".
-
-The class this exists for
--------------------------
-A mutation arm is the only evidence that a test *depends on* the line it claims to
-test: break the line, and the test must die. Every cycle here writes a few, by hand,
-in a throwaway script under the session's `tmp/` - and the same three mistakes have
-been made by hand, repeatedly, because the judgement "the run failed, so the arm is
-killed" is wrong in ways that *look identical* to success:
-
-* **nothing ran.** A node id that does not resolve - most often a class method named
-  without its class, so `tests/test_x.py::test_y` instead of
-  `tests/test_x.py::TestC::test_y` - makes pytest exit **4** (measured 2026-09-26:
-  `USAGE_ERROR`). A harness that judges by `rc != 0` reports KILLED for an arm that
-  executed no test at all. This is not hypothetical: a cycle recorded five of five
-  arms "killed" while none had run, and this tool's first own use reproduced it three
-  times in one sitting.
-* **the mutation did not parse.** A source edit that produces invalid Python makes
-  pytest *error* rather than fail - and which code it returns depends on **how the
-  target is named**, not on the error (all three rows driven through this tool
-  2026-10-03, `cyc20261003-202837`): a fixture that imports the module at run time
-  gives **1**, the same code as a failing test; a collection-time import gives **2**
-  for a path target (`tests/test_x.py`) and **4** for a node-id target
-  (`tests/test_x.py::test_y` - the form this tool's own usage example passes), because
-  pytest reports an uncollectable node as a usage error. So an error is
-  indistinguishable from a real kill to a harness that only asks "did it fail?", and
-  on the node-id form it is also indistinguishable, by exit code alone, from a
-  *mistyped* target - which is why the mutated text is compiled here and the syntax
-  error it names is what the report gives, instead of a guess read off the code.
-* **the restore is not a snapshot.** Restoring a mutated file with `git checkout --`
-  silently reverts *uncommitted* work: an arm run inside a cycle, whose change is not
-  committed yet, deletes the very change the next arm mutates.
-
-Measured exit codes, on this repository's pytest (2026-09-26), which is what the
-judgement below is built on:
-
-    passing target                                 0
-    a test that failed                             1
-    an *error* - a fixture that blew up loading   1   (measured: mutating a file the
-      a module that cannot parse                       `mod` fixture imports)
-    a collection-time error - a syntax error       2   (INTERRUPTED; a *path* target.
-      in a file pytest imports while collecting          A node-id target gives 4 here
-                                                          instead - pytest reports an
-                                                          uncollectable node as a usage
-                                                          error. This tool compiles the
-                                                          mutated text, so it names the
-                                                          syntax error either way.)
-    a node id that does not resolve                4   (USAGE_ERROR)
-    nothing collected (`-k` matching nothing)      5
-
-The row that matters most is the third: **an error is exit 1, the same code as a
-failure.** So `--expect` is not a nicety - without it, a mutation that breaks the
-loading of the module under test is indistinguishable from a mutation a test
-actually caught, and that is the whole failure mode this tool exists to remove.
-
-The judgement therefore has three states, not two:
-
-    rc 0                                  -> SURVIVED   (the mutation is not covered)
-    rc 1 and the expected assertion text  -> KILLED     (the arm is evidence)
-    anything else                         -> UNJUDGEABLE, with the reason named
-
-The pre-flight is the other half of it: the target is run **before** the mutation, and
-an arm whose target does not collect and pass then is refused outright. That is what
-makes a later exit 4 attributable to the mutation rather than to a mistyped node id.
-
-Naming the reason is not enough when the reason is "your `--expect` text is not in the
-output": that verdict costs the caller a second pytest run typed by hand to find a
-fragment that *is*. So an UNJUDGEABLE report also prints the assertion lines the run
-echoed - pytest's `>` source line and its `E` explanation, marker stripped, capped at
-`_ASSERTION_CANDIDATES` - and any of them can be handed straight back as `--expect`.
-Measured 2026-09-26 (`cyc20260926-140150`), the shape that costs the round: an arm whose
-`--expect` was copied from the test's *message*, which pytest never prints because an
-earlier assertion on the same test fires first (it echoed `assert 1 < 0`; that fragment
-killed the arm in one step). The block is printed for this verdict only - for KILLED the
-expectation already matched, and for the refusals there is nothing to search for.
-
-A refused pre-flight prints the nodes that failed *before* the mutation, capped at
-`_PREFLIGHT_FAILURES_PRINTED`, under the `preflight:` line. Same reasoning one state
-earlier: the refusal's remedy has to name a cause, and "check the node id" is one of
-three - a node-id cause and a tree that was already red both reach it. The failing nodes
-are the datum that tells them apart, pytest prints them unasked, and measured
-2026-10-09 (`cyc20261009-133913`) a refusal with twenty failures printed none of them.
-
-What it does, in order
-----------------------
-1. snapshot the named file and resolve the mutation anchor (exactly one occurrence);
-2. pre-flight: run the target unmutated - it must collect and pass (`--no-preflight`
-   is the escape hatch for an arm whose target is already red, and says so in the
-   verdict, because the attribution is then the reader's);
-3. apply the replacement and assert the file really changed;
-4. run the target, under the interpreter `_pytest_interpreter` resolves once for both
-   runs (the invoking one, or the checkout's own `.venv` when that one cannot import
-   pytest - the rule is asked of `scripts/check-merge-plan-suite.py`, which owns it):
-   `HOME`/`TMPDIR`/`TMP`/`TEMP` are pinned to a fresh temporary
-   directory **for the child only** (`emrg/server/evolution_prompt.md` states the
-   rule: a temp-root home is itself a writable zone, so a *process-wide* pinned `HOME`
-   turns a sandbox test red - a false red, not a regression), bytecode writing is
-   switched off and the mutated file's own `__pycache__` is purged, because a `.pyc`
-   whose `(mtime, size)` header still matches can answer for the mutation
-   (`scripts/check-merge-plan-suite.py` carries that measurement);
-5. restore from the snapshot and assert it came back **byte for byte**.
-
-Why this is not in the `check*.py` family
------------------------------------------
-That family's rule is "a guard that reads a working tree names the tree it read before
-it gives a verdict". This tool *modifies* the tree it names, so it is not a health
-reading of one - but the convention's substance still applies and the cost is one
-line, so the tree is printed first anyway.
-
-Usage
------
-    uv run --no-sync python3 scripts/run-mutation-arm.py \
-        --file scripts/check-pr-base.py \
-        --old 'where = "named" if args.prs else "open"' \
-        --new 'where = "open"' \
-        --node 'tests/test_check_pr_base.py::TestTheSummaryCountsTheSelectionNotTheRepository::test_a_named_list_is_not_reported_as_the_open_set' \
-        --expect '1 of the 1 named PR(s)'
-
-`--node` is repeatable. `--json` prints one object instead of the prose report.
-
-Exit codes
-----------
-    0  KILLED           the mutation made the target fail on the expected assertion
-    1  SURVIVED         the target still passed with the mutation in place
-    2  UNJUDGEABLE      the run does not separate the two (wrong node id, a mutation
-                        that does not parse, nothing collected, an unrelated failure)
-    3  TARGET-BROKEN    before mutating, the target did not collect or did not pass
-    4  NO-MUTATION      the replacement left the file byte-identical, or the anchor
-                        does not occur exactly once
-    5  RESTORE-MISMATCH the file did not come back byte for byte
-
-The file is restored on every path, including a failure inside this tool.
-"""
-
-from __future__ import annotations
-
-import argparse
-import importlib.util
-import json
-import os
-import re
-import shutil
-import subprocess
-import sys
-import traceback
-import tempfile
-from pathlib import Path
-
-#: pytest's exit codes, named where the judgement reads them, each measured on this
-#: repository's pytest (2026-09-26). `PYTEST_TEST_FAILED` is also what pytest returns
-#: for an *error* - a fixture that blew up loading a module that cannot parse - which
-#: is why `--expect` is required rather than optional.
-PYTEST_OK = 0
-PYTEST_TEST_FAILED = 1
-PYTEST_INTERRUPTED = 2
-PYTEST_USAGE_ERROR = 4
-PYTEST_NO_TESTS = 5
-
-KILLED = "KILLED"
-SURVIVED = "SURVIVED"
-UNJUDGEABLE = "UNJUDGEABLE"
-TARGET_BROKEN = "TARGET-BROKEN"
-NO_MUTATION = "NO-MUTATION"
-RESTORE_MISMATCH = "RESTORE-MISMATCH"
-
-EXIT_KILLED = 0
-EXIT_SURVIVED = 1
-EXIT_UNJUDGEABLE = 2
-EXIT_TARGET_BROKEN = 3
-EXIT_NO_MUTATION = 4
-EXIT_RESTORE_MISMATCH = 5
-
-#: `1 passed in 0.02s`, `3 passed, 1 warning in 0.10s` - the count pytest prints.
-_PASSED = re.compile(r"(\d+) passed")
-
-#: pytest's own words when the interpreter the target was run with cannot import it.
-#: Both spellings, because the two ways that happens print differently: `-m pytest` with
-#: the module absent prints `<python>: No module named pytest` (measured 2026-10-05 on
-#: this host's python3.13), and an ImportError raised while collecting prints the quoted
-#: `ModuleNotFoundError: No module named 'pytest'`. A matcher for one of the two would
-#: miss half the readings it exists for, which is what the `identity imported` /
-#: `3 identities imported` lesson in `emrg/server/evolution_prompt.md` §1.1 records.
-#:
-#: The module is **captured and compared**, not spelled into the pattern, because this
-#: sentence names every module a run could not import: `No module named 'pytest_asyncio'`
-#: is a missing *plugin* - pytest imports and a plugin does not - and a literal `pytest`
-#: with no right boundary read it as "the interpreter cannot import pytest", which is a
-#: cause nobody measured (veto, measured 2026-10-06 by `cyc20261006-131455`; the three
-#: plugin names it listed all fired). Reading the name out is what makes the third cause
-#: separable at all - `_missing_module` is the reader, and its callers decide what the
-#: name means.
-_NO_MODULE = re.compile(r"No module named '?([A-Za-z_][\w.]*)'?")
-
-
-def _missing_module(out: str) -> str:
-    """The module this run's output says it could not import, or `""` if it named none.
-
-    A trailing `.` is stripped: `No module named pytest.` is the same reading as
-    `No module named pytest` (the period belongs to the sentence around it, not to the
-    name), while `pytest.core` keeps its dot and is therefore *not* pytest itself - the
-    distinction the veto turned on, where an unanchored matcher could not tell them apart.
-    """
-    match = _NO_MODULE.search(out)
-    return match.group(1).rstrip(".") if match else ""
-
-#: pytest's two echoed forms of the assertion that failed: the source line it writes
-#: with `>`, and its explanation, written with `E` - which carries the values
-#: substituted (`E   assert 0 == 1`). Both are text the run really printed, so either
-#: can be handed straight back as `--expect`.
-#:
-#: This exists for one verdict. UNJUDGEABLE means the `--expect` fragment did not
-#: appear in the output, and the caller's next move is to find one that does - which,
-#: without this, is a second pytest run typed by hand. Measured 2026-09-26
-#: (`cyc20260926-140150`): two arms in one cycle came back UNJUDGEABLE on a fragment
-#: copied from the test's *message*, and both were re-run by hand to find the assertion
-#: that fires first.
-#:
-#: The `assert` keyword is required so the explanation lines pytest writes *about* a
-#: failure (`+  where 0 = ...`, `AttributeError: ...`) are not offered as candidates:
-#: they are not assertions, and a caller who pasted one would get UNJUDGEABLE again.
-_ECHOED_ASSERTION = re.compile(r"^[>E]\s+(?P<text>.*\bassert\b.*)$")
-
-#: How many candidates the report prints, and how long each may be: the report is read
-#: from a terminal, and the first few lines of a failure are where its assertion is.
-_ASSERTION_CANDIDATES = 5
-_ASSERTION_MAX_CHARS = 200
-
-#: How many of a refused pre-flight's failing nodes the report prints by name. Capped for
-#: the same reason as the candidates above, and the count it leaves out is printed rather
-#: than dropped: a reader who has to know whether the list named one file or twenty can
-#: see it, and the names are the evidence the verdict turns on.
-_PREFLIGHT_FAILURES_PRINTED = 5
-
-
-def _purge_bytecode(target: Path) -> list[str]:
-    """Delete the bytecode caches that could answer for the mutated file.
-
-    Mirrors `scripts/check-merge-plan-suite.py::_purge_bytecode`, in the one place an
-    arm needs it, and for the reason measured there: CPython prefers a `.pyc` whose
-    header `(mtime, size)` pair still matches, so an edit that keeps the file's length
-    and lands in the same second can be invisible to the run that judges the arm.
-    """
-    removed: list[str] = []
-    for parent in [target.parent, *target.parents[:3]]:
-        cache = parent / "__pycache__"
-        if cache.is_dir():
-            shutil.rmtree(cache, ignore_errors=True)
-            removed.append(str(cache))
-    return removed
-
-
-def _run_target(
-    node: list[str], cwd: Path, home: Path, python: str
-) -> subprocess.CompletedProcess[str]:
-    """Run the named pytest target, with the child-only environment pinning.
-
-    `python` is the interpreter the arm is judged under, resolved by
-    `_pytest_interpreter` - not `sys.executable` unconditionally. The two differ only
-    when the interpreter this tool was invoked with cannot import pytest at all, which
-    is never a deliberate choice: an arm cannot be judged by an interpreter that has no
-    runner, so that case is a refusal today and is the wrong answer to the question the
-    caller asked (see `_pytest_interpreter` for the measurement).
-
-    `HOME`/`TMPDIR`/`TMP`/`TEMP` are the *arm's* temp root and are passed to this child
-    only - pinning them for the whole tool (or worse, for the whole suite) is the
-    false-red `emrg/server/evolution_prompt.md` records.
-    """
-    env = dict(os.environ)
-    env.update(
-        HOME=str(home),
-        TMPDIR=str(home),
-        TMP=str(home),
-        TEMP=str(home),
-        PYTHONDONTWRITEBYTECODE="1",
-    )
-    return subprocess.run(
-        [python, "-m", "pytest", *node, "-q", "-p", "no:cacheprovider"],
-        cwd=str(cwd),
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        env=env,
-    )
-
-
-def _combined(proc: subprocess.CompletedProcess[str]) -> str:
-    return (proc.stdout or "") + (proc.stderr or "")
-
-
-def _failed_nodes(out: str) -> list[str]:
-    """Every `FAILED <node>` line pytest printed, in order - evidence, not a count.
-
-    All of them rather than the first, because which nodes failed is the datum that
-    separates the two situations one verdict covers: a target that is wrong fails on
-    its own nodes, while a tree that was already red fails on files the arm never
-    touched. Measured 2026-10-09 (`cyc20261009-133913`): a refused pre-flight on a
-    tree whose every failure was in another file printed `failed node: -`, and the
-    remedy sent the reader to the node id - which was not wrong.
-    """
-    found: list[str] = []
-    for line in out.splitlines():
-        stripped = line.strip()
-        if stripped.startswith("FAILED "):
-            found.append(stripped[len("FAILED ") :].split(" - ")[0].strip())
-    return found
-
-
-def _failed_node(out: str) -> str:
-    """The first `FAILED <node>` line pytest printed, or empty - evidence, not a count."""
-    nodes = _failed_nodes(out)
-    return nodes[0] if nodes else ""
-
-
-def _passed_count(out: str) -> int:
-    """How many tests passed, read from pytest's own summary line (0 when it says none)."""
-    found = _PASSED.findall(out)
-    return int(found[-1]) if found else 0
-
-
-def _assertion_lines(out: str) -> list[str]:
-    """The assertion lines pytest echoed, marker stripped - candidates for `--expect`.
-
-    Order is the run's, duplicates are collapsed (a failure reports each assertion
-    once, but a parametrised id can repeat a line in the summary), and the list is
-    capped: this is offered as a fragment to retype, not as a copy of the report.
-
-    Empty is a real answer and is not an error: a run that failed without echoing an
-    assertion - a collection error, a fixture that raised - has nothing to offer, and
-    saying so by printing nothing is better than inventing a candidate.
-    """
-    seen: list[str] = []
-    for line in out.splitlines():
-        match = _ECHOED_ASSERTION.match(line)
-        if match is None:
-            continue
-        text = match.group("text").strip()[:_ASSERTION_MAX_CHARS]
-        if text and text not in seen:
-            seen.append(text)
-        if len(seen) >= _ASSERTION_CANDIDATES:
-            break
-    return seen
-
-
-def _syntax_error(text: str, name: str) -> str:
-    """Why `text` is not Python, or "" when it parses.
-
-    Measured 2026-10-03 (`cyc20261003-202837`): a mutation that breaks the syntax makes
-    pytest fail to collect the target, and the code it returns depends on the target
-    form - **4** for a node id (`tests/test_x.py::test_y`, the form this tool's usage
-    example passes), **2** for a path. The exit-4 branch used to read that as "the
-    target no longer resolves" and send the caller to re-check a node id the pre-flight
-    had already proved good. Compiling the mutated text is the determinate answer, it
-    costs one call, and it is available *before* the run rather than inferred from a
-    code that means two things.
-    """
-    try:
-        compile(text, name, "exec")
-    except SyntaxError as exc:
-        where = f"line {exc.lineno}" if exc.lineno else "an unknown line"
-        return f"{exc.msg} at {where}"
-    except ValueError as exc:
-        # NUL bytes and the like: not a SyntaxError, still not importable.
-        return str(exc)
-    return ""
-
-
-def _why_unjudgeable(rc: int, expect: str, out: str, syntax_error: str = "") -> str:
-    if syntax_error:
-        # Determinate, and it comes first: the mutated text does not parse, which is
-        # *this arm's* doing, so no code the run returned needs interpreting.
-        return (
-            f"the mutated file no longer parses - {syntax_error}. pytest exited {rc} "
-            "because the target could not be imported, not because a test failed on the "
-            "line this arm breaks; no test ran, so this is not a kill"
-        )
-    if rc == PYTEST_USAGE_ERROR:
-        return (
-            "pytest exited 4 (usage error) AFTER a pre-flight that collected and passed, "
-            "and the mutated file still parses - check the target spelling (a class "
-            "method needs its class: tests/test_x.py::TestC::test_y). No test ran, so "
-            "this is not a kill"
-        )
-    if rc == PYTEST_INTERRUPTED:
-        return (
-            "pytest exited 2 (interrupted): collection itself failed, so no test ran "
-            "against the mutation - the usual cause is that the mutated file is imported "
-            "while tests are collected and no longer parses. Not a kill"
-        )
-    if rc == PYTEST_NO_TESTS:
-        return "pytest exited 5: no test was collected, so nothing judged the mutation"
-    if rc == PYTEST_TEST_FAILED:
-        return (
-            f"the target failed (or errored), but not on the assertion this arm names: "
-            f"{expect!r} does not appear in the output. pytest returns 1 for a failed "
-            "test and for a fixture that cannot load the mutated module alike, so a "
-            "harness that only asks whether the run failed calls both of them kills"
-        )
-    return f"pytest exited {rc}, which separates neither outcome"
-
-
-def _apply(text: str, old: str, new: str) -> str | None:
-    """The mutated text, or None when the anchor is not uniquely present."""
-    if text.count(old) != 1:
-        return None
-    return text.replace(old, new, 1)
-
-
-#: The gate that already owns the answer to *which interpreter runs pytest here*.
-#: Loaded from its file rather than copied, the same way `check-merge-plan-suite.py`
-#: loads `check-merge-sequence.py` and both load `merge_tree.py`: a rule with two
-#: implementations is a rule free to drift apart, and this one has already been answered
-#: twice on one host. Measured 2026-10-05 (`cyc20261005-212445`), under a bare `python3`
-#: (this host's resolves to the *installed* interpreter, which has no pytest):
-#:
-#:     check-merge-plan-suite._suite_interpreter() -> <checkout>/.venv/bin/python
-#:     run-mutation-arm: TARGET-BROKEN, "check the node id"
-#:
-#: One question, two answers - the gate resolved an interpreter that can run the thing it
-#: measures, and this tool refused the arm while naming a cause that was not the cause.
-_GATE = Path(__file__).resolve().parent / "check-merge-plan-suite.py"
-
-
-#: The answer, once loaded: the gate is asked per run, and re-executing its module on
-#: every call would be both wasteful and wrong for a reader who needs to see that this
-#: tool has one source for the rule (`_pytest_interpreter`'s callers include the tests
-#: that pin the delegation).
-_GATE_MODULE: object | None = None
-
-
-def _load_gate():
-    """The gate module, loaded from its file once and kept.
-
-    No failure is handled *here*, on purpose: a gate that is missing, unreadable or will
-    not compile raises out of `exec_module`, and `main` turns that into the UNJUDGEABLE
-    verdict (`_why_no_interpreter`) rather than a traceback. The `if spec is None or
-    spec.loader is None` guard that used to sit here was **unreachable for exactly that
-    case**, which made it a refusal that could never fire: `spec_from_file_location`
-    returns a spec *and* a `SourceFileLoader` for a path that does not exist (measured
-    2026-10-06, `cyc20261006-020931`: `ModuleSpec(name='x', loader=<SourceFileLoader …>,
-    origin='/definitely/not/here.py')`), so the `RuntimeError` was dead code and the live
-    path was an uncaught `FileNotFoundError`.
-    """
-    global _GATE_MODULE
-    if _GATE_MODULE is not None:
-        return _GATE_MODULE
-    spec = importlib.util.spec_from_file_location("check_merge_plan_suite", _GATE)
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    _GATE_MODULE = module
-    return module
-
-
-def _pytest_interpreter(own: str | None = None, root: Path | None = None) -> str:
-    """The interpreter the arm is judged under: the caller's, or one that can import pytest.
-
-    Asked of the gate, never re-implemented here. The gate's rule is "this interpreter if
-    it can import pytest, else the checkout's own `.venv`", and it is the right rule for an
-    arm for the same reason it is right for the suite: an arm judged by an interpreter with
-    no runner has measured nothing, and refusing is not more honest than using the
-    interpreter the checkout ships. The resolved path is reported, so the evidence names
-    the environment it came from rather than leaving it implied.
-    """
-    return _load_gate()._suite_interpreter(own, root)
-
-
-def _why_no_interpreter(exc: BaseException) -> str:
-    """Why the arm could not be judged at all, because the rule could not be asked.
-
-    The interpreter is not resolved here: it is *asked of* `_GATE`, a file beside this
-    tool (`_pytest_interpreter`). A gate that is missing, unreadable or will not compile
-    therefore leaves the question unanswered - and an arm whose interpreter is unknown has
-    measured nothing, which is what this verdict means rather than a refusal about the
-    target. Nothing has been run and nothing has been written when this is printed.
-
-    This exists because the alternative was measured, not imagined (2026-10-06,
-    `cyc20261006-020931`): with the gate unloadable the tool exited **1** - which this file
-    defines as `EXIT_SURVIVED` - after a traceback and with no `verdict:` line, so a caller
-    reading the exit code read "the target still passed with the mutation in place" out of
-    a run that never started.
-    """
-    return (
-        f"the interpreter to judge the arm under could not be resolved: "
-        f"{type(exc).__name__}: {exc}. This tool asks {_GATE.name}, beside it, for the rule, "
-        "so that gate has to be present and loadable; nothing has been run and nothing has "
-        "been mutated. An arm whose interpreter could not be resolved has measured nothing, "
-        "which is what this verdict means - check the gate first "
-        "(uv run --no-sync python3 scripts/check-merge-plan-suite.py --help)"
-    )
-
-
-def _names_the_failing_nodes(out: str) -> str:
-    """One sentence for the refusal whose pre-flight failed on named nodes, or "".
-
-    Present only when the run named some, because the sentence points at evidence that
-    is then in the report: the node-id reading is one of three causes and it is the one
-    that is wrong whenever the failures are in files this arm never touched. Measured
-    2026-10-09 (`cyc20261009-133913`): a full-suite arm on PR #1978's head was refused
-    with 20 failures, every one of them in an unrelated file, and the verdict sent the
-    reader to the node id and the interpreter instead of showing them.
-    """
-    if not _failed_nodes(out):
-        return ""
-    return (
-        " The nodes that failed before any mutation are named under the pre-flight line, "
-        "and their names settle the cause before the node id does: a list naming files "
-        "other than the target's own is a tree that was already red before this arm ran, "
-        "and then no node id was wrong"
-    )
-
-
-def _why_target_broken(rc: int, passed: int, out: str, interpreter: str) -> str:
-    """Why the pre-flight refused, read from the run's own output.
-
-    Three causes reach this refusal with different remedies, so the reason is read rather
-    than assumed. Measured 2026-10-05 (`cyc20261005-191637`), on this host: running this
-    tool with an interpreter that cannot import pytest - a bare `python3` here resolves
-    to the *installed* interpreter, not the checkout's - gave `rc=1, 0 passed`, and the
-    message sent the caller to re-check a node id that the same tool, under the
-    checkout's runner, runs green (`uv run --no-sync pytest <node>` -> `1 passed`). The
-    output said which of the two it was all along, and this function reads it.
-
-    The third is the same sentence naming a different module, and it was the veto's
-    subject (2026-10-06, `cyc20261006-131455`): a run whose output says
-    `No module named 'pytest_asyncio'` had measurable pytest and one missing plugin, and
-    the two-cause reader called it "the interpreter cannot import pytest". A report that
-    names a cause has to have read it, so the module is named and only `pytest` itself
-    takes the interpreter branch.
-
-    `interpreter` is the one the run *actually used*, so the message is about the thing
-    that ran: it must not name `sys.executable` when the resolver substituted a different
-    one. Every branch names it, so the causes stay separable from the report even when the
-    detector does not fire.
-    """
-    missing = _missing_module(out)
-    if missing == "pytest":
-        line = next(text for text in out.splitlines() if _NO_MODULE.search(text)).strip()
-        return (
-            f"before any mutation the target exited {rc} with {passed} passed, because "
-            f"the interpreter this tool ran it with cannot import pytest: {line}. This "
-            f"tool runs the target with the interpreter it resolved ({interpreter}), so "
-            "the node id is not the cause - and because the resolver already fell back to "
-            "the checkout's own `.venv`, more than one interpreter has been tried: "
-            "install pytest (`uv sync`) or run the arm through the checkout's runner "
-            "(uv run --no-sync python3)"
-        )
-    if missing:
-        line = next(text for text in out.splitlines() if _NO_MODULE.search(text)).strip()
-        return (
-            f"before any mutation the target exited {rc} with {passed} passed, because "
-            f"the run could not import a module: {line}. The target never collected, so "
-            f"the node id is not the cause; the module named there is, and it is not "
-            f"pytest itself - the run named {missing!r}, which is read apart from "
-            f"pytest because a module that will not import is not an interpreter that "
-            f"lacks pytest. Install it in the environment this tool runs with "
-            f"({interpreter}), or run the arm through the checkout's runner "
-            "(uv run --no-sync python3)"
-        )
-    return (
-        f"before any mutation the target exited {rc} with {passed} passed. An arm can "
-        "only attribute a failure to its mutation if the target collected and passed "
-        "first - check the node id (a class method needs its class: "
-        "tests/test_x.py::TestC::test_y). The run was made with the interpreter this "
-        f"tool resolved ({interpreter}); if that is not the one you meant, run the arm "
-        "through the checkout's runner(s) rather than a bare python3, which can resolve "
-        f"to the installed interpreter.{_names_the_failing_nodes(out)}"
-    )
-
-
-class Arm:
-    """One arm's state, so the verdict is computed before anything is printed."""
-
-    def __init__(self, args: argparse.Namespace, cwd: Path, target: Path, original: str):
-        self.args = args
-        self.cwd = cwd
-        self.target = target
-        self.original = original
-        self.preflight = "skipped" if args.no_preflight else "pending"
-        self.failed_node = ""
-        #: the nodes the *pre-flight* failed on, in pytest's own order. Printed on a
-        #: refusal because their names are the only datum that separates "this arm's
-        #: target is wrong" from "this tree was already red before the arm ran" - and
-        #: the verdict's prose names the node id either way. Measured 2026-10-09
-        #: (`cyc20261009-133913`): a refusal whose 20 failures were all in files the
-        #: arm never touched printed `failed node: -`.
-        self.preflight_failures: list[str] = []
-        self.restored: bool | None = None
-        self.verdict = ""
-        self.why = ""
-        self.code = EXIT_UNJUDGEABLE
-        #: the observed rc of the post-mutation run, and how many tests passed in it -
-        #: the evidence behind the verdict, printed so a reader can check it rather
-        #: than trust it.
-        self.mutated_rc: int | None = None
-        self.mutated_passed: int | None = None
-        #: the assertion lines the post-mutation run echoed, as candidates for
-        #: `--expect` - printed when the verdict is UNJUDGEABLE, which is the one
-        #: state where the caller has to retype the fragment.
-        self.assertions: list[str] = []
-        #: why the mutated text is not Python, or "" - read before the run, so the
-        #: verdict never has to infer the cause from an exit code that means two
-        #: different things depending on how the target was named.
-        self.syntax_error = ""
-        #: the interpreter both runs used, resolved before either of them. Printed
-        #: because the resolver can substitute the checkout's `.venv` for the caller's
-        #: interpreter, and evidence that does not name its environment is evidence a
-        #: reader has to guess about.
-        self.interpreter = ""
-
-    def decide(self, verdict: str, why: str, code: int) -> None:
-        self.verdict, self.why, self.code = verdict, why, code
-
-    def as_dict(self) -> dict[str, object]:
-        return {
-            "tree": str(self.cwd),
-            "file": str(self.target),
-            "label": self.args.label,
-            "node": list(self.args.node),
-            "expect": self.args.expect,
-            "interpreter": self.interpreter,
-            "preflight": self.preflight,
-            "preflight_failures": list(self.preflight_failures),
-            "failed_node": self.failed_node,
-            "mutated_rc": self.mutated_rc,
-            "mutated_passed": self.mutated_passed,
-            "assertions": list(self.assertions),
-            "syntax_error": self.syntax_error,
-            "restored": self.restored,
-            "verdict": self.verdict,
-            "why": self.why,
-            "exit": self.code,
-        }
-
-
-def _report(arm: Arm, as_json: bool) -> None:
-    if as_json:
-        print(json.dumps(arm.as_dict(), indent=2, sort_keys=True))
-        return
-    if arm.args.label:
-        print(f"arm: {arm.args.label}")
-    # The tree first, before any verdict: this tool writes to the tree it names, and
-    # a reader has to be able to tell which checkout was modified.
-    print(f"tree: {arm.cwd}")
-    print(f"file: {arm.target}")
-    print(f"target: {', '.join(arm.args.node)}")
-    print(f"interpreter: {arm.interpreter or '(not resolved - the arm stopped first)'}")
-    print(f"preflight: {arm.preflight}")
-    if arm.verdict == TARGET_BROKEN and arm.preflight_failures:
-        # The refusal's own evidence, and the reason it is here rather than in the
-        # verdict's prose: which nodes failed is what tells the reader whether the arm's
-        # target is wrong or the whole tree was already red, and both shapes reach this
-        # verdict. Measured 2026-10-09 (`cyc20261009-133913`), where that list was the
-        # only thing separating a broken full-suite arm from a broken tree.
-        print("the pre-flight failed before any mutation, on:")
-        for node in arm.preflight_failures[:_PREFLIGHT_FAILURES_PRINTED]:
-            print(f"  {node}")
-        hidden = len(arm.preflight_failures) - _PREFLIGHT_FAILURES_PRINTED
-        if hidden > 0:
-            print(f"  ... and {hidden} more")
-    print(f"mutated run: rc={arm.mutated_rc} passed={arm.mutated_passed}")
-    print(f"failed node: {arm.failed_node or '-'}")
-    print(f"restored byte-for-byte: {arm.restored}")
-    print(f"verdict: {arm.verdict} - {arm.why}")
-    if arm.verdict == UNJUDGEABLE and arm.assertions:
-        # Printed only for the verdict whose reader has to retype the fragment. For
-        # KILLED the expectation already matched, and for the other states the reason
-        # is a refusal rather than a search - so this stays out of the common report.
-        print("the run did echo these assertion lines, any of which can be --expect:")
-        for text in arm.assertions:
-            print(f"  {text}")
-
-
-def main(argv: list[str] | None = None) -> int:
-    # `_report` says "the tree first, before any verdict", and every other tool
-    # in this family carries this call to make that order survive a pipe (stdout
-    # is block-buffered when it is not a tty while stderr is not). This script's
-    # own stderr write is `_entry`'s crash handler, which runs *after* the
-    # report's first line. Behaviour and pin: tests/test_guard_report.py.
-    try:
-        sys.stdout.reconfigure(line_buffering=True)
-    except (AttributeError, ValueError):
-        pass
-
-    parser = argparse.ArgumentParser(
-        prog="run-mutation-arm.py",
-        description=(
-            "Run one mutation arm and judge it: KILLED only when the named target "
-            "really failed on the expected assertion"
-        ),
-    )
-    parser.add_argument("--file", required=True, help="the file to mutate")
-    parser.add_argument("--old", required=True, help="the text to replace (must occur once)")
-    parser.add_argument("--new", required=True, help="what to replace it with")
-    parser.add_argument(
-        "--node",
-        required=True,
-        action="append",
-        help="pytest target (node id or path); repeatable",
-    )
-    parser.add_argument(
-        "--expect",
-        required=True,
-        help=(
-            "text that only THIS arm's failure prints; a failure without it is not this "
-            "arm's. The failing assertion's own source line is the most reliable choice, "
-            "because pytest always echoes it (e.g. 'assert 2 == 3', or "
-            "'assert (tree / \"subject.py\").read_text'). A fragment copied from the "
-            "test's *message* can be missed when an earlier assertion in the same test "
-            "fails first - and when that happens the verdict is UNJUDGEABLE and the "
-            "report prints the assertion lines the run did echo, so the retry is one "
-            "step rather than a second run typed by hand"
-        ),
-    )
-    parser.add_argument("--label", default="", help="what this arm breaks, for the report")
-    parser.add_argument("--cwd", default="", help="the tree to run in (default: this checkout)")
-    parser.add_argument(
-        "--no-preflight",
-        action="store_true",
-        help="skip the pre-mutation run (for an arm whose target is already red)",
-    )
-    parser.add_argument("--json", action="store_true", help="emit one JSON object instead")
-    args = parser.parse_args(argv)
-
-    cwd = Path(args.cwd).resolve() if args.cwd else Path(__file__).resolve().parent.parent
-    target = Path(args.file)
-    if not target.is_absolute():
-        target = cwd / target
-
-    original = target.read_text(encoding="utf-8") if target.is_file() else None
-    arm = Arm(args, cwd, target, original or "")
-    if original is None:
-        # Every verdict leaves through `_report`, including this one: an exit code with
-        # no prose is the failure this family keeps naming.
-        arm.decide(UNJUDGEABLE, f"no such file: {target}", EXIT_UNJUDGEABLE)
-        _report(arm, args.json)
-        return arm.code
-
-    mutated = _apply(original, args.old, args.new)
-    if mutated is None:
-        occurrences = original.count(args.old)
-        arm.decide(
-            NO_MUTATION,
-            f"the anchor occurs {occurrences} time(s) in {target.name}; a replacement "
-            "needs exactly one site, or the arm mutates something other than what it "
-            "names",
-            EXIT_NO_MUTATION,
-        )
-        _report(arm, args.json)
-        return arm.code
-    if mutated == original:
-        arm.decide(NO_MUTATION, "the replacement left the file byte-identical", EXIT_NO_MUTATION)
-        _report(arm, args.json)
-        return arm.code
-
-    # Read from the mutated text, before anything runs: a mutation that breaks the
-    # syntax is this arm's own doing, and it is the one cause whose exit code varies
-    # with how the target was named (`_syntax_error` records that measurement).
-    if target.suffix == ".py":
-        arm.syntax_error = _syntax_error(mutated, target.name)
-
-    home = Path(tempfile.mkdtemp(prefix="emrg-arm-"))
-    mutated_on_disk = False
-    # Resolved once, before either run, so the pre-flight and the judged run cannot be
-    # about two different interpreters - and reported, because the evidence has to name
-    # the environment it came from when the resolver substitutes one.
-    #
-    # A resolver that cannot answer is a **verdict**, not a traceback. The gate is a file
-    # loaded from disk, so it can be missing, unreadable or not compiling - a parallel
-    # cycle mid-edit on it is enough - and an uncaught exception here exits 1, which this
-    # file defines as `EXIT_SURVIVED` (measured 2026-10-06, `cyc20261006-020931`: a gate
-    # with one broken line appended, and a tool standing alone without one, each exited 1
-    # with no `verdict:` line). Every other outcome in this tool leaves through `_report`;
-    # so does this one, and the verdict is UNJUDGEABLE because an arm whose interpreter is
-    # unknown has measured nothing.
-    try:
-        python = _pytest_interpreter()
-    except Exception as exc:  # noqa: BLE001 - the cause is named, not swallowed
-        arm.decide(UNJUDGEABLE, _why_no_interpreter(exc), EXIT_UNJUDGEABLE)
-        shutil.rmtree(home, ignore_errors=True)
-        _report(arm, args.json)
-        return arm.code
-    arm.interpreter = python
-    try:
-        if not args.no_preflight:
-            proc = _run_target(args.node, cwd, home, python)
-            passed = _passed_count(_combined(proc))
-            if proc.returncode != PYTEST_OK or passed < 1:
-                # A refusal is a verdict like any other, so it goes through the same
-                # report path: an unattributed non-zero exit is the failure this tool
-                # exists to prevent, and that includes this tool's own. Which of the
-                # causes it was is read from the output, not assumed - see
-                # `_why_target_broken`.
-                arm.preflight = f"refused (rc={proc.returncode}, {passed} passed)"
-                arm.preflight_failures = _failed_nodes(_combined(proc))
-                arm.decide(
-                    TARGET_BROKEN,
-                    _why_target_broken(
-                        proc.returncode, passed, _combined(proc), python
-                    ),
-                    EXIT_TARGET_BROKEN,
-                )
-            else:
-                arm.preflight = f"{passed} passed"
-
-        if not arm.verdict:
-            try:
-                target.write_text(mutated, encoding="utf-8")
-                mutated_on_disk = True
-                _purge_bytecode(target)
-                proc = _run_target(args.node, cwd, home, python)
-                out = _combined(proc)
-                arm.mutated_rc = proc.returncode
-                arm.mutated_passed = _passed_count(out)
-                arm.failed_node = _failed_node(out)
-                arm.assertions = _assertion_lines(out)
-                if proc.returncode == PYTEST_OK:
-                    arm.decide(
-                        SURVIVED,
-                        "the target still passed with the mutation in place, so it does "
-                        "not depend on the line this arm breaks",
-                        EXIT_SURVIVED,
-                    )
-                elif proc.returncode == PYTEST_TEST_FAILED and args.expect in out:
-                    arm.decide(
-                        KILLED,
-                        f"the target failed on the expected assertion ({args.expect!r})",
-                        EXIT_KILLED,
-                    )
-                else:
-                    arm.decide(
-                        UNJUDGEABLE,
-                        _why_unjudgeable(
-                            proc.returncode, args.expect, out, arm.syntax_error
-                        ),
-                        EXIT_UNJUDGEABLE,
-                    )
-            finally:
-                if mutated_on_disk:
-                    target.write_text(original, encoding="utf-8")
-                    arm.restored = target.read_text(encoding="utf-8") == original
-                else:
-                    arm.restored = target.read_text(encoding="utf-8") == original
-    finally:
-        shutil.rmtree(home, ignore_errors=True)
-
-    if arm.restored is False:
-        arm.decide(
-            RESTORE_MISMATCH,
-            f"{target} did not come back byte for byte - restore it by hand before "
-            "anything else reads this tree",
-            EXIT_RESTORE_MISMATCH,
-        )
-    _report(arm, args.json)
-    return arm.code
-
-
-def _entry() -> int:
-    """`main`, with an unexpected failure reported as this tool's unmeasurable answer.
-
-    Python exits `1` for an unhandled exception, and `1` is a **verdict** in this tool's
-    exit table, while `2` is the code for "the question could not be answered". A caller
-    that checks the code - which is how this family composes, one gate running another or
-    reading its `rc` - would otherwise read a crash as a verdict. Byte-identical in every
-    tool of the family, and `tests/test_a_crash_is_a_measurement_error.py` pins that.
-    """
-    try:
-        return main()
-    except Exception as exc:  # noqa: BLE001 - reported as unmeasurable, never swallowed
-        traceback.print_exc()
-        print(
-            f"{Path(__file__).name}: could not measure - {type(exc).__name__}: {exc}",
-            file=sys.stderr,
-        )
-        return 2  # cause: tool-failed
-
-
-if __name__ == "__main__":
-    raise SystemExit(_entry())
diff --git a/tests/test_a_crash_is_a_measurement_error.py b/tests/test_a_crash_is_a_measurement_error.py
index a4586a4e..aecf8b94 100644
--- a/tests/test_a_crash_is_a_measurement_error.py
+++ b/tests/test_a_crash_is_a_measurement_error.py
@@ -19,8 +19,6 @@
     check-merge-freshness.py  -> exit 1   # the STALE verdict, whose remedy is a re-merge
                                           # and a push that voids every standing vote
     review-queue.py           -> exit 1   # a code this tool's table does not define at all
-    run-mutation-arm.py       -> exit 1   # == EXIT_SURVIVED, "the target still passed with
-                                          # the mutation in place"
 
 So this module pins the rule the family now shares: `_entry()` catches what leaves `main`,
 prints the cause, and answers `2`. The clause reads the tools the way the other family-wide
@@ -63,9 +61,7 @@
     "check-merge-pairs.py",
     "check-merge-order.py",
     "check-merge-landed.py",
-    "run-mutation-arm.py",
     "check-notary-credentials.py",
-    "check-install-drift.py",
     "check-icon-transparency.py",
     # Joined 2026-10-20 (`cyc20261020-121739`), and its shape is the reason the family
     # rule exists: it answers **1 = "a product still ships the previous prompt"**, a
@@ -212,10 +208,10 @@ def test_the_family_is_derived_from_the_source_not_listed():
     `DEVELOPMENT.md` sentence claiming the rule for "the gate family" was pinned by a module
     that could not measure the claim (measured 2026-10-06, `cyc20261006-091811`).
 
-    The set is required to be a **subset** of `TOOLS`, not equal to it: `run-mutation-arm.py`
-    is pinned here and loads nothing — it asks a gate as a subprocess — so equality would be
-    false. What is asserted is the direction that can rot: no sibling-loading gate escapes
-    the list.
+    The set is required to be a **subset** of `TOOLS`, not equal to it:
+    `check-notary-credentials.py` is pinned here and loads no sibling at all, so equality
+    would be false. What is asserted is the direction that can rot: no sibling-loading gate
+    escapes the list.
     """
     loaders = set()
     for path in sorted(SCRIPTS.glob("*.py")):
diff --git a/tests/test_a_tree_reading_guard_names_its_tree.py b/tests/test_a_tree_reading_guard_names_its_tree.py
index 8e688e87..4dd76d18 100644
--- a/tests/test_a_tree_reading_guard_names_its_tree.py
+++ b/tests/test_a_tree_reading_guard_names_its_tree.py
@@ -159,9 +159,8 @@ def _carries(subjects: tuple[str, ...]) -> bool:
 #: `ROOT_FLAG_BUT_NOT_POINTABLE` below is where naming it is a decision rather than an
 #: omission. Two members joined 2026-10-10 (`cyc20261010-132458`), found by the reading
 #: `test_every_guard_advertising_a_root_flag_is_accounted_for` — before it, the rule above
-#: was prose the table itself already broke: `check-gui-package-refs.py` AND
-#: `check-install-drift.py` both advertised `--root` and neither was listed, so nothing
-#: pointed either at a tree.
+#: was prose the table itself already broke: `check-gui-package-refs.py` advertised
+#: `--root` and was not listed, so nothing pointed it at a tree.
 POINTABLE_AT_A_TREE = {
     "check-citation-resolves.py": (),
     "check-retry-bounds.py": ("--root",),
@@ -169,7 +168,6 @@ def _carries(subjects: tuple[str, ...]) -> bool:
     "check-undefined-names.py": ("--root",),
     "check-workflows.py": ("--root",),
     "check-gui-package-refs.py": ("--root",),
-    "check-install-drift.py": ("--root",),
 }
 
 #: Guards that advertise `--root` in their own `--help` and are deliberately **not** in the
@@ -243,16 +241,6 @@ def _refusal_reason(out: str) -> str:
         "a subprocess against a `tmp_path` tree and asserts the first line, which holds "
         "with or without the binary because the tree line is printed before the search"
     ),
-    "check-install-drift.py": (
-        "its subject is the host's installed tree (`~/.emrg/install/source`), not this "
-        "checkout: the verdict is about a *pair* of trees, and a bare checkout carries no "
-        "install, so running it here would measure the host rather than the rule - and on "
-        "a host with a hand-edited install tree its honest answer is rc 1, which is that "
-        "host's drift rather than this tree's defect. It reads a working tree (this "
-        "checkout, through git) and names both halves, and that naming IS verified rather "
-        "than classified: `tests/test_check_install_drift.py::test_the_report_names_both_trees_before_the_verdict` runs it "
-        "as a subprocess against a `tmp_path` install tree and checkout and pins both lines"
-    ),
     "check-merge-landed.py": (
         "needs `gh` and the network for the review half. It was classified as a "
         "NON-tree-reader when #1618 added it, by the bucket entry that says it 'reads "
@@ -323,12 +311,6 @@ def _refusal_reason(out: str) -> str:
         "subject is the remote queue, so there is no local tree whose name would "
         "answer anything (the repo it read is printed first instead)"
     ),
-    "check-stacked-prs.py": (
-        "reads every open PR's head and commit list from the GitHub API and reports which "
-        "open PR's head commit another one would land - the subject is the remote queue, so "
-        "no local tree's name would answer anything (the repo it read is printed first "
-        "instead, as check-issue-links.py does)"
-    ),
     "check-patch-files.py": "reads the patch files it is given as arguments",
     "check-batching-share.py": (
         "reads a corpus of session history files - `history_*.jsonl` under the roots given "
@@ -361,13 +343,6 @@ def _refusal_reason(out: str) -> str:
         "would answer anything (the repo it read is printed first instead, as "
         "check-issue-links.py does)"
     ),
-    "check-suite-durations.py": (
-        "reads each CI leg's Python-suite step duration out of the GitHub API's own step "
-        "records (`started_at`/`completed_at`) - the subject is the remote run queue, and "
-        "no local tree's name would answer anything about a Windows runner's wall clock "
-        "(the repo, and each run it read, are printed first instead, as check-issue-links.py "
-        "does). Added by issue #2296 R4"
-    ),
 }
 
 
diff --git a/tests/test_abort_runs.py b/tests/test_abort_runs.py
index a210206a..f5fe135b 100644
--- a/tests/test_abort_runs.py
+++ b/tests/test_abort_runs.py
@@ -211,8 +211,8 @@ def test_the_default_path_is_under_the_daemons_log_directory(tmp_path, monkeypat
     assertion on it measures the redirect, never the resolution.
 
     This test did worse than that — it installed a lambda of its own and asserted
-    its own arithmetic back out — and it was hollow for it. Measured 2026-10-04 with
-    `scripts/run-mutation-arm.py`, moving the state off the daemon's log directory
+    its own arithmetic back out — and it was hollow for it. Measured 2026-10-04 with a
+    hand-written mutation arm moving the state off the daemon's log directory
     (`config_dir() / "state" / STATE_FILENAME`) left it **SURVIVED**: the line the
     test exists to pin was unguarded, and the file could be relocated without one
     red row.
diff --git a/tests/test_check_install_drift.py b/tests/test_check_install_drift.py
deleted file mode 100644
index a4d83257..00000000
--- a/tests/test_check_install_drift.py
+++ /dev/null
@@ -1,992 +0,0 @@
-"""`scripts/check-install-drift.py`: install-tree content no shipped commit of the checkout holds.
-
-Why this file exists
---------------------
-The daemon runs the **installed** package: `_resolve_task_template` returns
-`Path(__file__).parent / <template>`, and that `__file__` is under
-`~/.emrg/install/source/`. The install tree is not a git clone, so a file edited in place
-there lives in no history and the next install/upgrade replaces it whole.
-
-Measured 2026-10-07 (`cyc20261007-130240`, `cyc20261007-151625`) on this host: the install
-tree's `competition_prompt.md` is the `v0.3.7` bytes **plus** a hand-appended block, every
-other prompt file in the tree is byte-identical to `v0.3.7`, and the rule that block
-carries appears in no ref of the repository. The tag the release chain is part-way through
-(`v0.3.8`) carries none of it, so the upgrade would delete the host's mandate rather than
-ship it.
-
-Every case here builds its own checkout and its own install tree under `tmp_path`: the
-subject is a pair of directories, and a test that read this host's real install tree would
-be measuring the host rather than the tool. Nothing here touches `~/.emrg/install`, and
-nothing here reads `~/.emrg/install/version.txt` - that path is named by a permanent red
-line and this tool does not need it (see the docstring's "Membership is asked of the
-objects reachable from the refs a release is built from").
-
-Exit codes, at the tool's own process boundary
-----------------------------------------------
-The tool is driven as a **subprocess**, not in-process, so what is asserted is what a
-caller really reads: the code, and the text on stdout. `0` no drift, `1` drift, `2` not
-measurable.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import importlib.util
-import os
-import shutil
-import stat
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-TOOL = REPO_ROOT / "scripts" / "check-install-drift.py"
-
-#: The file both trees carry, at a path both call the same thing - the mapping is
-#: positional, which is why an install-relative path has to be a tracked path here.
-SHARED = "emrg/server/prompt.md"
-RELEASED = "released content for the prompt template\n"
-
-
-def _load(path: Path):
-    spec = importlib.util.spec_from_file_location(
-        "install_drift_" + path.stem.replace("-", "_"), path
-    )
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def _git(cwd: Path, *argv: str) -> subprocess.CompletedProcess:
-    return subprocess.run(
-        ["git", *argv],
-        cwd=str(cwd),
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        check=True,
-    )
-
-
-@pytest.fixture(autouse=True)
-def _hermetic_git_config(tmp_path_factory, monkeypatch) -> None:
-    """This module's fixtures must not inherit the **host's** git configuration.
-
-    Every case here builds a repository and asserts what git stores for a path, so a
-    setting that changes what git stores changes the expected answer - and the settings
-    that do it are exactly the ones a host varies: `core.autocrlf` is unset on this
-    development host and **true** on GitHub's `windows-2025` runner. Measured 2026-10-07
-    (`cyc20261007-203559`): with a global `autocrlf=true` injected, every line-ending
-    transformation applies to *every* path, so a fixture that relied on which paths a rule
-    matches stopped exercising what it claimed, and `test-windows` went red on run
-    `37608201387` for a test asserting exactly that. The assertion was right; the fixture
-    was reading the host.
-
-    Both the fixture's own git calls and the tool subprocess inherit this, because they
-    have to agree on what git stores - pinning only one side would compare two
-    conventions, which is the defect the tool itself was just fixed for.
-    """
-    empty = tmp_path_factory.mktemp("gitconfig") / "empty.gitconfig"
-    empty.write_text("", encoding="utf-8")
-    monkeypatch.setenv("GIT_CONFIG_GLOBAL", str(empty))
-    monkeypatch.setenv("GIT_CONFIG_NOSYSTEM", "1")
-
-
-@pytest.fixture
-def checkout(tmp_path: Path) -> Path:
-    """A one-commit repository holding `SHARED` with the released bytes."""
-    root = tmp_path / "checkout"
-    (root / "emrg" / "server").mkdir(parents=True)
-    (root / SHARED).write_text(RELEASED, encoding="utf-8")
-    (root / "README.md").write_text("# readme\n", encoding="utf-8")
-    _git(root, "init", "-q")
-    _git(root, "config", "user.email", "test@example.invalid")
-    _git(root, "config", "user.name", "test")
-    _git(root, "add", "-A")
-    _git(root, "commit", "-q", "-m", "released")
-    return root
-
-
-@pytest.fixture
-def install_dir(tmp_path: Path, checkout: Path) -> Path:
-    """An install tree holding what the release shipped, at the same paths."""
-    tree = tmp_path / "install" / "source"
-    (tree / "emrg" / "server").mkdir(parents=True)
-    shutil.copyfile(checkout / SHARED, tree / SHARED)
-    shutil.copyfile(checkout / "README.md", tree / "README.md")
-    return tree
-
-
-def _run(install: Path | str, root: Path | str, codec: str | None = None) -> subprocess.CompletedProcess:
-    env = None
-    if codec is not None:
-        import os
-
-        env = {**os.environ, "PYTHONIOENCODING": codec}
-    return subprocess.run(
-        [
-            sys.executable,
-            str(TOOL),
-            "--install-dir",
-            str(install),
-            "--root",
-            str(root),
-        ],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        env=env,
-        timeout=120,
-    )
-
-
-def test_the_id_is_the_one_git_stores_for_that_path(tmp_path: Path) -> None:
-    """The convention, pinned in both directions on real bytes.
-
-    The scan asks git for the id rather than computing one in-process, and the reason is
-    the second half of this test: a raw `sha1("blob <len>\\0" + bytes)` is a *different
-    function* from `hash-object` as soon as a filter applies, and this repository's own
-    `.gitattributes` (`*.cmd`/`*.bat`/`*.ps1 text eol=crlf`) and any host's
-    `core.autocrlf=true` both make one apply.
-
-    So both halves are asserted: for content no filter touches the two agree (the function
-    really is a content hash), and for a CRLF file under `core.autocrlf=true` they
-    deliberately do NOT - and it is git's answer, not the raw one, that the tool must use.
-    """
-    module = _load(TOOL)
-    root = tmp_path / "repo"
-    (root / "sub").mkdir(parents=True)
-    _git(root, "init", "-q")
-    _git(root, "config", "user.email", "t@example.invalid")
-    _git(root, "config", "user.name", "t")
-
-    def stored(path: Path, relative: str) -> str:
-        return module._git_stored_id(root, path, relative)
-
-    # Half one: with nothing filtering, the id is the plain content hash - including the
-    # byte that makes the construction a blob and not a bare digest.
-    for name, payload in (
-        ("plain.txt", b"abc"),
-        ("empty.txt", b""),
-        ("with-nul.txt", b"a\x00b"),
-        ("utf8.txt", "prompt \u2014 unicode\n".encode("utf-8")),
-    ):
-        path = tmp_path / name
-        path.write_bytes(payload)
-        raw = hashlib.sha1(b"blob %d\x00" % len(payload) + payload).hexdigest()
-        assert stored(path, f"sub/{name}") == raw, (
-            f"{name}: the id this tool compares is not a content hash of the file at all"
-        )
-
-    # Half two: the case the first version of this tool got wrong, deterministic on every
-    # platform because the filter is configured here rather than inherited from the host.
-    _git(root, "config", "core.autocrlf", "true")
-    committed = root / "sub" / "file.txt"
-    committed.write_bytes(b"a\nb\n")
-    _git(root, "add", "sub/file.txt")
-    _git(root, "commit", "-q", "-m", "lf blob")
-    blob = _git(root, "rev-parse", "HEAD:sub/file.txt").stdout.strip()
-
-    crlf = tmp_path / "install" / "sub" / "file.txt"
-    crlf.parent.mkdir(parents=True)
-    crlf.write_bytes(b"a\r\nb\r\n")
-    raw = hashlib.sha1(b"blob %d\x00" % len(b"a\r\nb\r\n") + b"a\r\nb\r\n").hexdigest()
-
-    assert stored(crlf, "sub/file.txt") == blob, (
-        "a CRLF file whose committed blob is LF did not answer the committed id: the "
-        "comparison has left git's own convention, which is exactly what made "
-        "`test-windows` red (run 37588646750)"
-    )
-    assert raw != blob, (
-        "the raw construction agrees here, so this fixture no longer exercises the "
-        "divergence it exists to pin - the filter is not being applied"
-    )
-
-
-def test_a_crlf_install_file_is_not_called_drift(tmp_path: Path) -> None:
-    """The regression itself, end to end through the tool's process boundary.
-
-    A clean install tree whose files carry CRLF, in a checkout configured to normalize line
-    endings, must answer `0`. Under the raw construction every such file is reported as an
-    edit - on the Windows leg that was five failing tests, and on a host whose attributes
-    transform a whole file type it would be a reading nobody could use.
-
-    The control is in the same test: changing a byte of that same file must still answer
-    `1`, so this is not a tool that stopped seeing drift.
-    """
-    root = tmp_path / "checkout"
-    (root / "emrg").mkdir(parents=True)
-    (root / "emrg" / "mod.py").write_bytes(b"x = 1\ny = 2\n")
-    _git(root, "init", "-q")
-    _git(root, "config", "user.email", "t@example.invalid")
-    _git(root, "config", "user.name", "t")
-    _git(root, "config", "core.autocrlf", "true")
-    _git(root, "add", "-A")
-    _git(root, "commit", "-q", "-m", "lf blob")
-
-    install = tmp_path / "install" / "source"
-    (install / "emrg").mkdir(parents=True)
-    (install / "emrg" / "mod.py").write_bytes(b"x = 1\r\ny = 2\r\n")
-
-    clean = _run(install, root)
-    assert clean.returncode == 0, (
-        "an install file differing from the committed blob only in line endings was "
-        f"reported as drift: {clean.stdout!r}"
-    )
-
-    (install / "emrg" / "mod.py").write_bytes(b"x = 1\r\ny = 3\r\n")
-    edited = _run(install, root)
-    assert edited.returncode == 1, (
-        f"a real edit of the same file was not reported: {edited.stdout!r}"
-    )
-
-
-def test_the_repo_relative_path_is_what_decides_the_conversion(tmp_path: Path) -> None:
-    """`--path` is load-bearing, and only a **path-keyed** attribute shows it.
-
-    Attributes are matched against the file's repo-relative path, so the path has to be
-    supplied: the install copy lives outside the checkout, and git cannot derive one. A
-    basename-only rule (`*.cmd`) hides this, because the file's own name matches it either
-    way - found by a mutation arm that dropped the flag and **survived** (cycle
-    `cyc20261007-182502`). With a directory-keyed rule the difference is measurable:
-
-        .gitattributes:  sub/*.cmd text eol=crlf
-        hash-object <file>                -> the raw CRLF id, which no commit holds
-        hash-object --path=sub/a.cmd <f>  -> the committed LF blob
-
-    So a clean install copy of such a file is reported as an edit unless the path is given,
-    which is the whole reason this tool passes it.
-    """
-    root = tmp_path / "checkout"
-    (root / "sub").mkdir(parents=True)
-    (root / ".gitattributes").write_text("sub/*.cmd text eol=crlf\n", encoding="utf-8")
-    (root / "sub" / "a.cmd").write_text("echo hi\n", encoding="utf-8")
-    _git(root, "init", "-q")
-    _git(root, "config", "user.email", "t@example.invalid")
-    _git(root, "config", "user.name", "t")
-    _git(root, "add", "-A")
-    _git(root, "commit", "-q", "-m", "lf blob")
-    blob = _git(root, "rev-parse", "HEAD:sub/a.cmd").stdout.strip()
-
-    install = tmp_path / "install" / "source"
-    (install / "sub").mkdir(parents=True)
-    crlf = install / "sub" / "a.cmd"
-    crlf.write_bytes(b"echo hi\r\n")
-
-    module = _load(TOOL)
-    assert module._git_stored_id(root, crlf, "sub/a.cmd") == blob, (
-        "the tool did not answer the committed blob for a CRLF file whose attribute rule "
-        "is keyed on its directory"
-    )
-    without_path = _git(root, "hash-object", str(crlf)).stdout.strip()
-    assert without_path != blob, (
-        "this fixture no longer exercises the flag: without `--path` git answered the "
-        "committed blob, so the rule is not keyed on the path here"
-    )
-
-    proc = _run(install, root)
-    assert proc.returncode == 0, (
-        f"a clean install copy under a path-keyed attribute rule was reported as drift: "
-        f"{proc.stdout!r}"
-    )
-
-
-def test_a_clean_install_tree_answers_zero(install_dir: Path, checkout: Path) -> None:
-    """The positive half: a tree holding exactly the released bytes is not drift."""
-    proc = _run(install_dir, checkout)
-    assert proc.returncode == 0, f"a clean install tree was reported as drift: {proc.stdout}"
-    assert "2 file(s) checked, 0 named as leftovers" in proc.stdout, (
-        f"the count of what was checked is what keeps a green verdict from being a "
-        f"reading over nothing: {proc.stdout!r}"
-    )
-
-
-def test_an_edited_file_answers_one_and_names_the_path(
-    install_dir: Path, checkout: Path
-) -> None:
-    """The negative half: an in-place edit is named, with the stack it belongs in."""
-    edited = install_dir / SHARED
-    edited.write_text(RELEASED + "\n### a rule added in the install tree\n", encoding="utf-8")
-
-    proc = _run(install_dir, checkout)
-    assert proc.returncode == 1, f"an edited install file was not reported: {proc.stdout}"
-    assert SHARED in proc.stdout, f"the drifted path is not named: {proc.stdout!r}"
-    assert "1 file(s) hold content no shipped commit has; 2 checked" in proc.stdout, (
-        f"the summary must name how many of how many: {proc.stdout!r}"
-    )
-    assert "the next one destroys it" in proc.stdout, (
-        "the verdict does not say what the consequence is, which is the whole reason to "
-        f"report it: {proc.stdout!r}"
-    )
-    assert (checkout / SHARED).read_text(encoding="utf-8") == RELEASED, (
-        "the tool wrote to the checkout: it is a reading, and it may not repair anything"
-    )
-
-
-def test_the_verdict_flips_on_a_single_added_byte(
-    install_dir: Path, checkout: Path
-) -> None:
-    """The discriminating control: the two verdicts differ only by the edit.
-
-    Both runs share the checkout, the install tree and every other file; the only change
-    between them is one appended line. Without this pair, a tool that always answered `1`
-    would pass the case above, and one that always answered `0` would pass the case before
-    it.
-    """
-    before = _run(install_dir, checkout)
-    assert before.returncode == 0
-    with (install_dir / SHARED).open("a", encoding="utf-8") as handle:
-        handle.write("\n")
-    after = _run(install_dir, checkout)
-    assert after.returncode == 1, (
-        "appending one newline to the install copy is exactly the edit class this tool "
-        f"exists for: {after.stdout!r}"
-    )
-
-
-def test_an_install_file_the_checkout_does_not_track_is_named_as_a_leftover(
-    install_dir: Path, checkout: Path
-) -> None:
-    """A file only the install has is a version difference, not an edit - and it is named.
-
-    Packaging writes files this repository does not track (`py.typed` is the measured one),
-    and the repository also moves files between releases, so neither may turn the verdict
-    red: a reading that fires on those stops being read. What they may not be is *silent*,
-    which is what this test asserted until 2026-10-17: the host's tree carried a whole
-    renderer directory the source had deleted on 2026-08-27, and three host rants of that
-    day audited it as live code.
-    """
-    (install_dir / "packaging_only.txt").write_text("not in the repository\n", encoding="utf-8")
-
-    proc = _run(install_dir, checkout)
-    assert proc.returncode == 0, (
-        f"an untracked install file was reported as drift: {proc.stdout!r}"
-    )
-    assert "leftovers: 1 file(s)" in proc.stdout, proc.stdout
-    assert "packaging_only.txt" in proc.stdout, (
-        f"a file only the install has was not named, so a reader cannot tell it was "
-        f"considered: {proc.stdout!r}"
-    )
-    assert "file(s) hold content no shipped commit has" not in proc.stdout, (
-        f"a version difference must not read as an in-place edit: {proc.stdout!r}"
-    )
-
-
-def test_content_only_a_bookkeeping_ref_holds_is_reported_and_that_ref_named(
-    tmp_path: Path,
-) -> None:
-    """A recovery snapshot is not history a release ships, so an edit it alone holds is drift.
-
-    `refs/emrg/rescue/*` is where `scripts/recover-worktree.py` pins a dirty tree's work
-    precisely because it exists nowhere else - which is the point: a snapshot no release
-    builds from cannot make a live install-tree edit safe. Counting it as history is how
-    the install tree's `vibe_check.j2` sat unreported while the tag comparison found it
-    (#1898), so membership is asked of `refs/heads/*`, `refs/remotes/*` and `refs/tags/*`.
-
-    The ref is not discarded from the report either: it is where the bytes still are, and
-    "an upgrade will delete this" is only actionable somewhere to recover them from. The
-    control runs the same pair with the ref deleted, so the naming is exercised in both
-    directions instead of asserted once.
-    """
-    root = tmp_path / "checkout"
-    (root / SHARED).parent.mkdir(parents=True)
-    (root / SHARED).write_text(RELEASED, encoding="utf-8")
-    _git(root, "init", "-q")
-    _git(root, "config", "user.email", "test@example.invalid")
-    _git(root, "config", "user.name", "test")
-    _git(root, "add", "-A")
-    _git(root, "commit", "-q", "-m", "released")
-    branch = _git(root, "rev-parse", "--abbrev-ref", "HEAD").stdout.strip()
-
-    # The edit, committed on a scratch branch and pinned into the bookkeeping namespace,
-    # then that branch deleted: the bytes now reach nothing a release is built from.
-    edited = "an edit that reaches no shipped ref\n"
-    _git(root, "checkout", "-q", "-b", "scratch")
-    (root / SHARED).write_text(edited, encoding="utf-8")
-    _git(root, "add", "-A")
-    _git(root, "commit", "-q", "-m", "the edit")
-    pinned = _git(root, "rev-parse", "HEAD").stdout.strip()
-    rescue = "refs/emrg/rescue/20260101T000000Z"
-    _git(root, "update-ref", rescue, pinned)
-    _git(root, "checkout", "-q", branch)
-    _git(root, "branch", "-D", "scratch")
-
-    install = tmp_path / "install" / "source"
-    (install / SHARED).parent.mkdir(parents=True)
-    (install / SHARED).write_text(edited, encoding="utf-8")
-
-    proc = _run(install, root)
-    assert proc.returncode == 1, (
-        "content reachable only from a recovery snapshot was read as shipped history, "
-        f"which is the whole defect of #1898: {proc.stdout!r}"
-    )
-    assert SHARED in proc.stdout, f"the drifted path is not named: {proc.stdout!r}"
-    assert rescue in proc.stdout, (
-        "the report does not name the ref the bytes are still recoverable from, so it says "
-        f"'an upgrade destroys this' without saying where it lives: {proc.stdout!r}"
-    )
-
-    # The control: with the snapshot gone the file is drift like any other, so the naming
-    # above is about the ref and not a string the tool always prints.
-    _git(root, "update-ref", "-d", rescue)
-    after = _run(install, root)
-    assert after.returncode == 1, after.stdout
-    assert rescue not in after.stdout, f"the ref is named after it was deleted: {after.stdout!r}"
-
-
-def test_an_absent_object_is_tolerated_rather_than_making_the_reading_unmeasurable(
-    tmp_path: Path,
-) -> None:
-    """A clone whose history has a hole must still answer, and must say the hole is there.
-
-    Not hypothetical: measured 2026-10-08 (`cyc20261008-001036`) on the host this tool
-    serves, `git rev-list --branches --tags --remotes --objects` exits 128 on `bad tree
-    object 219ff46e...`, and so does every narrower walk - the hole is in the *history*,
-    which is exactly what a membership question is about. Left intolerant the tool answers
-    `2` on the very host it exists for, and a reading that can only say "could not measure"
-    there measures nothing.
-
-    The hole is forged rather than waited for: the branch's own tree object is removed from
-    the store, so the walk meets an object it does not have - the same condition, on a
-    repository built for the case. Tolerating it can only *remove* a candidate, so the files
-    under the missing tree read as drift: the safe direction, and the count is printed so a
-    narrowed set is never read as the whole one.
-    """
-    root = tmp_path / "checkout"
-    (root / "emrg").mkdir(parents=True)
-    (root / "emrg" / "mod.py").write_text("x = 1\n", encoding="utf-8")
-    _git(root, "init", "-q")
-    _git(root, "config", "user.email", "t@example.invalid")
-    _git(root, "config", "user.name", "t")
-    _git(root, "add", "-A")
-    _git(root, "commit", "-q", "-m", "released")
-
-    install = tmp_path / "install" / "source"
-    (install / "emrg").mkdir(parents=True)
-    (install / "emrg" / "mod.py").write_text("x = 1\n", encoding="utf-8")
-
-    intact = _run(install, root)
-    assert intact.returncode == 0, (
-        f"an intact history did not answer cleanly, so this is not a control: {intact.stdout!r}"
-    )
-
-    tree = _git(root, "rev-parse", "HEAD^{tree}").stdout.strip()
-    loose = root / ".git" / "objects" / tree[:2] / tree[2:]
-    assert loose.exists(), (
-        "this fixture needs a freshly written, still-loose object to forge the hole; "
-        f"{tree} is not loose, so the case would not exercise anything"
-    )
-    os.chmod(loose, stat.S_IWRITE)
-    loose.unlink()
-
-    intolerant = subprocess.run(
-        ["git", "-C", str(root), "rev-list", "--branches", "--tags", "--remotes", "--objects"],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    assert intolerant.returncode != 0, (
-        "the forgery did not create the condition: the intolerant walk still finished, so "
-        "this case would pass with or without the tolerance"
-    )
-
-    proc = _run(install, root)
-    assert proc.returncode == 1, (
-        "content under a missing tree is not reachable from the refs a release is built "
-        f"from, so it is drift in the safe direction: {proc.stdout!r} {proc.stderr!r}"
-    )
-    assert "membership: 1 object(s)" in proc.stdout, (
-        "the report does not say how much of history it walked, so a narrowed membership "
-        f"set reads as the whole one: {proc.stdout!r}"
-    )
-
-
-def test_the_report_names_both_trees_before_the_verdict(
-    install_dir: Path, checkout: Path
-) -> None:
-    """Which pair answered, printed first - the family's rule for a tree-reading guard.
-
-    This tool is the family's only member whose subject is a *pair*, and both halves can
-    be pointed somewhere else: a verdict that did not say which install tree and which
-    checkout produced it would read the same for this host and for a tmp directory.
-    `check-merge-sequence.py` reads sibling reports and refuses one that does not name its
-    tree, so the line is a contract and not a courtesy.
-    """
-    proc = _run(install_dir, checkout)
-    lines = proc.stdout.splitlines()
-    assert lines[0] == f"tree: {checkout}", f"the checkout is not named first: {lines[:2]}"
-    assert lines[1] == f"install: {install_dir}", (
-        f"the install tree is not named second, so the pair is not identified: {lines[:2]}"
-    )
-
-
-def test_a_missing_install_tree_is_unmeasurable(tmp_path: Path, checkout: Path) -> None:
-    """No install tree is not a clean install tree."""
-    proc = _run(tmp_path / "nowhere", checkout)
-    assert proc.returncode == 2, f"a missing subject answered a verdict: {proc.stdout!r}"
-    assert "could not measure" in proc.stderr
-
-
-def test_a_root_that_is_not_a_checkout_is_unmeasurable(
-    install_dir: Path, tmp_path: Path
-) -> None:
-    """Nothing can say whether content was ever committed without a history."""
-    plain = tmp_path / "not_a_checkout"
-    plain.mkdir()
-    proc = _run(install_dir, plain)
-    assert proc.returncode == 2, f"a root with no history answered a verdict: {proc.stdout!r}"
-    assert "not a git checkout" in proc.stderr
-
-
-def test_a_tree_sharing_no_tracked_path_is_unmeasurable(
-    tmp_path: Path, checkout: Path
-) -> None:
-    """The empty-set refusal: nothing checked may not read as nothing found.
-
-    The check is per shared path, so a tree sharing none with the checkout has had no
-    question put to it at all - and `0` would say the files were checked. This is the
-    class fixed across the family on 2026-10-06 (`cyc20261006-165503`).
-    """
-    unrelated = tmp_path / "unrelated"
-    (unrelated / "somewhere_else").mkdir(parents=True)
-    (unrelated / "somewhere_else" / "file.txt").write_text("x\n", encoding="utf-8")
-
-    proc = _run(unrelated, checkout)
-    assert proc.returncode == 2, (
-        f"a tree sharing no path with the checkout answered a verdict: {proc.stdout!r}"
-    )
-    assert "share no tracked path" in proc.stderr, proc.stderr
-
-
-def test_the_default_install_tree_is_the_one_the_daemon_runs() -> None:
-    """The default subject is the install tree, not this checkout.
-
-    `_resolve_task_template` renders a built-in template from `Path(__file__).parent`, and
-    for a running daemon that is the installed copy. A default pointed anywhere else would
-    answer about a tree no session reads, in the same words.
-    """
-    module = _load(TOOL)
-    assert module.DEFAULT_INSTALL_DIR == "~/.emrg/install/source", (
-        "the default install tree moved away from the one the daemon renders from"
-    )
-
-
-def test_the_help_and_both_verdicts_survive_an_ascii_console(
-    install_dir: Path, checkout: Path
-) -> None:
-    """A script's own output must not turn a verdict into a traceback.
-
-    `tests/test_script_output_ascii.py` covers this statically for every script in
-    `scripts/`; this drives the paths that matter here through a hostile codec, because a
-    crash on the drift path would be read as `1` - the code that means "drift found".
-    """
-    help_proc = subprocess.run(
-        [sys.executable, str(TOOL), "--help"],
-        capture_output=True,
-        text=True,
-        encoding="ascii",
-        errors="replace",
-        env={"PYTHONIOENCODING": "ascii", "PATH": "/usr/bin:/bin"},
-        timeout=120,
-    )
-    assert help_proc.returncode == 0, f"--help under an ascii codec: {help_proc.stderr!r}"
-    assert "could not measure" not in help_proc.stderr
-
-    with (install_dir / SHARED).open("a", encoding="utf-8") as handle:
-        handle.write("\n")
-    drift = _run(install_dir, checkout, codec="ascii")
-    assert drift.returncode == 1, (
-        f"the drift verdict under an ascii codec came back as {drift.returncode}: "
-        f"{drift.stderr!r}"
-    )
-    assert drift.stdout.encode("ascii"), "the report is not ascii-clean"
-
-
-def test_the_module_does_not_inherit_the_hosts_git_config(tmp_path: Path) -> None:
-    """The condition `test-windows` runs under, reproducible on any host.
-
-    The failure this pins was not a wrong assertion - it was a fixture reading the host.
-    GitHub's `windows-2025` runner has `core.autocrlf=true` globally, this development host
-    has it unset, and a case that asserts which paths a conversion rule matches therefore
-    answered differently in the two places (run `37608201387`, `1 failed, 3963 passed`).
-    A green local suite could not have said so, which is the whole cost of the class.
-
-    So the module is run under a deliberately hostile global config with the test deselected
-    (it would otherwise recurse), and every other case must still pass. That makes the
-    platform condition a *measurement* rather than a place-only observation: delete the
-    autouse pinning fixture and this test fails on Linux and macOS alike.
-    """
-    hostile = tmp_path / "hostile.gitconfig"
-    hostile.write_text("[core]\n\tautocrlf = true\n", encoding="utf-8")
-
-    import os
-
-    env = {
-        **os.environ,
-        "GIT_CONFIG_GLOBAL": str(hostile),
-        "GIT_CONFIG_NOSYSTEM": "1",
-    }
-    proc = subprocess.run(
-        [
-            sys.executable,
-            "-m",
-            "pytest",
-            str(Path(__file__).resolve()),
-            "-q",
-            "-p",
-            "no:cacheprovider",
-            "-k",
-            f"not {test_the_module_does_not_inherit_the_hosts_git_config.__name__}",
-        ],
-        cwd=str(REPO_ROOT),
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        env=env,
-        timeout=600,
-    )
-    assert proc.returncode == 0, (
-        "with the Windows runner's `autocrlf=true` in force, this module's own fixtures "
-        "stopped agreeing with their assertions:\n"
-        f"{proc.stdout[-4000:]}\n{proc.stderr[-2000:]}"
-    )
-
-
-def test_a_file_the_checkout_no_longer_tracks_is_named_not_silently_skipped(
-    install_dir: Path, checkout: Path
-) -> None:
-    """The class the tool used to count and never name.
-
-    Its docstring justified the skip with "it is removed by the upgrade either way", and
-    that premise is false: measured 2026-10-17, this host's tree reports `0.3.16` and still
-    carries 11 files from a renderer directory the source deleted on 2026-08-27. Three host
-    rants of the same day were audits of exactly that dead code, which is what silence at
-    this line costs.
-    """
-    stale = install_dir / "emrg" / "gui" / "renderer" / "js" / "chat.js"
-    stale.parent.mkdir(parents=True)
-    stale.write_text("// a file no build ships\n", encoding="utf-8")
-
-    done = _run(install_dir, checkout)
-
-    assert done.returncode == 0, (
-        "a leftover is not drift by content, so it must not turn the verdict red: "
-        f"{done.stdout}{done.stderr}"
-    )
-    assert "leftovers: 1 file(s)" in done.stdout, done.stdout
-    assert "emrg/gui/renderer/js/chat.js" in done.stdout, done.stdout
-    assert "remedy:" in done.stdout, "the reading must name an action a host can take"
-
-
-def test_a_tree_without_leftovers_does_not_print_the_section(
-    install_dir: Path, checkout: Path
-) -> None:
-    """The other direction: the section appears because of a file, not always."""
-    done = _run(install_dir, checkout)
-
-    assert done.returncode == 0, done.stdout + done.stderr
-    assert "leftovers:" not in done.stdout, done.stdout
-    assert "0 named as leftovers above" in done.stdout, (
-        "the clean line must still state the count, or a zero and a silence read alike: "
-        f"{done.stdout}"
-    )
-
-
-def test_interpreter_caches_are_counted_but_not_listed(
-    install_dir: Path, checkout: Path
-) -> None:
-    """A `.pyc` under `__pycache__` is not source a reader reasons about.
-
-    Listed instead of dropped: the count says how many were left out of the list, so the
-    section is not silently editing what it found.
-    """
-    cache = install_dir / "emrg" / "gui" / "renderer" / "js" / "__pycache__" / "chat.pyc"
-    cache.parent.mkdir(parents=True)
-    cache.write_bytes(b"\x00compiled\x00")
-
-    done = _run(install_dir, checkout)
-
-    assert done.returncode == 0, done.stdout + done.stderr
-    assert "leftovers:" not in done.stdout, (
-        "an interpreter cache alone must not open the leftover section: " + done.stdout
-    )
-    assert "1 interpreter cache file(s) not listed" in done.stdout, done.stdout
-    assert "chat.pyc" not in done.stdout, done.stdout
-
-
-# ── the second question: which release is this tree, and is a newer one out? ─────────────
-#
-# `scan` asks whether a file's content is reachable from any ref a release is built from, and
-# an install tree several releases old passes it: the old bytes are in an older release's
-# history, which is a release ref. Measured 2026-10-20: this host's install tree carries the
-# pre-narrowing `evolution_prompt.md` while master and five releases since carry the narrowed
-# rule, and the drift reading answered `0`. The cases below pin the reading that can see it.
-
-
-def _recommit(root: Path, text: str, message: str) -> None:
-    """Change `SHARED` and commit, so each commit can carry its own release tag."""
-    (root / SHARED).write_text(text, encoding="utf-8")
-    _git(root, "add", "-A")
-    _git(root, "commit", "-q", "-m", message)
-
-
-def test_a_tree_that_is_an_older_release_is_named_as_behind(
-    install_dir: Path, checkout: Path
-) -> None:
-    """The measured defect: a green drift verdict over a superseded install tree.
-
-    The tree holds `v0.3.1`'s bytes, `v0.3.2` changed them, and the drift reading still says
-    every file is reachable from a release ref - which is true, and is exactly why it cannot
-    answer this question. The `behind:` line has to name both versions, because "behind" with
-    no number is a warning nobody can act on.
-    """
-    _git(checkout, "tag", "v0.3.1")
-    _recommit(checkout, "narrowed content\n", "narrow the rule")
-    _git(checkout, "tag", "v0.3.2")
-
-    done = _run(install_dir, checkout)
-
-    assert done.returncode == 0, done.stdout + done.stderr
-    assert "still reach" in done.stdout, "the drift reading is unchanged: " + done.stdout
-    assert "behind:" in done.stdout, done.stdout
-    assert "v0.3.1 copy" in done.stdout, done.stdout
-    assert "newest release tag this clone carries is v0.3.2" in done.stdout, (
-        "the line must name the tree's own release and the newest one: " + done.stdout
-    )
-    assert SHARED in done.stdout, (
-        "the lagging path must be named, or the reader cannot tell which rule is stale: "
-        + done.stdout
-    )
-    assert "1 of 2 shared file(s) differ" in done.stdout, (
-        "the size of the gap is a derived number, so it is asserted rather than left to a "
-        "reader to infer from a path list: " + done.stdout
-    )
-    assert "remedy: an upgrade to v0.3.2 brings these" in done.stdout, (
-        "the remedy is only true in this direction, so the arm that establishes the "
-        "direction pins it: " + done.stdout
-    )
-
-
-def test_a_tree_that_is_the_newest_release_is_not_reported_as_behind(
-    install_dir: Path, checkout: Path
-) -> None:
-    """The other direction: a current tree must read as current, not merely stay silent.
-
-    Silence and "current" are different readings and a reader has to be able to tell them
-    apart - which is why the up-to-date branch prints `none` and the version it compared to.
-    """
-    _git(checkout, "tag", "v0.3.1")
-
-    done = _run(install_dir, checkout)
-
-    assert done.returncode == 0, done.stdout + done.stderr
-    assert "behind: none" in done.stdout, done.stdout
-    assert "carries what v0.3.1 ships" in done.stdout, done.stdout
-    assert "copy and the newest release tag" not in done.stdout, done.stdout
-
-
-def test_a_clone_with_no_release_tag_says_it_could_not_measure(
-    install_dir: Path, checkout: Path
-) -> None:
-    """No tags is `could not measure`, never "current".
-
-    The rest of the tool answers a question about history and stays valid without tags, so the
-    exit code is unchanged; what must not happen is the second reading claiming a currency it
-    never measured. This is the family rule the whole tool is written to.
-    """
-    done = _run(install_dir, checkout)
-
-    assert done.returncode == 0, done.stdout + done.stderr
-    assert "could not measure which release" in done.stdout, done.stdout
-    assert "carries no release tag" in done.stdout, done.stdout
-    assert "behind: none" not in done.stdout, (
-        "an unmeasured currency is not a clean one: " + done.stdout
-    )
-
-
-def test_the_newest_release_is_read_in_version_order_not_lexically(
-    install_dir: Path, checkout: Path
-) -> None:
-    """`v0.3.10` is newer than `v0.3.9`; a lexical sort says the opposite.
-
-    Pinned because the wrong sort does not crash or look odd - it names a real release that is
-    simply not the newest, and every subsequent sentence in the line inherits the mistake.
-    """
-    _git(checkout, "tag", "v0.3.9")
-    _recommit(checkout, "content that ships in 0.3.10\n", "v0.3.10 content")
-    _git(checkout, "tag", "v0.3.10")
-
-    done = _run(install_dir, checkout)
-
-    assert done.returncode == 0, done.stdout + done.stderr
-    assert "newest release tag this clone carries is v0.3.10" in done.stdout, done.stdout
-    assert "v0.3.9 copy" in done.stdout, done.stdout
-
-
-def test_a_tree_matching_no_release_names_no_version(tmp_path: Path, checkout: Path) -> None:
-    """A mixed tree is not any release, and the line must not name one it does not match.
-
-    Two files from two different releases: the tree is real and readable, so it is reported,
-    but calling it `v0.3.2` would be inventing a fact about which rule the daemon renders.
-    """
-    _git(checkout, "tag", "v0.3.1")
-    _recommit(checkout, "shared content for 0.3.2\n", "second release")
-    _git(checkout, "tag", "v0.3.2")
-    (checkout / "README.md").write_text("# a later readme\n", encoding="utf-8")
-    _git(checkout, "add", "-A")
-    _git(checkout, "commit", "-q", "-m", "third release")
-    _git(checkout, "tag", "v0.3.3")
-
-    tree = tmp_path / "mixed" / "source"
-    (tree / "emrg" / "server").mkdir(parents=True)
-    (tree / SHARED).write_text(RELEASED, encoding="utf-8")          # v0.3.1's copy
-    (tree / "README.md").write_text("# a later readme\n", encoding="utf-8")   # v0.3.3's copy
-
-    done = _run(tree, checkout)
-
-    assert done.returncode == 0, done.stdout + done.stderr
-    assert "no single release" in done.stdout, done.stdout
-    assert "newest release tag this clone carries is v0.3.3" in done.stdout, done.stdout
-
-
-def test_a_drift_verdict_still_carries_the_release_reading(
-    install_dir: Path, checkout: Path
-) -> None:
-    """Both facts, one run: the tree lags *and* holds content no commit has.
-
-    That is the historical incident's shape, and it is why the release line is printed under
-    both verdicts. A hand-edited tree matches no release, so it is named as such rather than
-    attributed to the one it is closest to - while the newest release is still named, because
-    that is the upgrade that replaces the edit.
-    """
-    _git(checkout, "tag", "v0.3.1")
-    _recommit(checkout, "narrowed content\n", "narrow the rule")
-    _git(checkout, "tag", "v0.3.2")
-    (install_dir / "README.md").write_text("# edited in place\n", encoding="utf-8")
-
-    done = _run(install_dir, checkout)
-
-    assert done.returncode == 1, "content in no commit is drift: " + done.stdout + done.stderr
-    assert "hold content no shipped commit has" in done.stdout, done.stdout
-    assert "behind:" in done.stdout, (
-        "a drift verdict must not swallow the release reading: " + done.stdout
-    )
-    assert "no single release" in done.stdout, done.stdout
-    assert "newest release tag this clone carries is v0.3.2" in done.stdout, (
-        done.stdout
-    )
-
-
-def test_a_release_tag_this_clone_cannot_read_is_skipped_not_fatal(
-    tmp_path: Path, install_dir: Path, checkout: Path
-) -> None:
-    """One unreadable tag must not take the drift verdict down with it.
-
-    Measured 2026-10-20 on a peer host (`cyc20261020-100652`): two release tags answer
-    `fatal: not a tree object` - their trees are absent from that clone, the same clone whose
-    `membership:` line already reports 40 absent objects - and the release walk raised on the
-    first of them, so `main` answered `could not measure` and **`2`** where the reading before
-    it answered `0`. A second question may not cost the first one's answer.
-
-    The hole is forged rather than waited for, as the absent-object arm does for membership: a
-    tag ref is written pointing at an object this clone does not have. The forgery is checked
-    before the assertion, so a fixture that fails to create the condition cannot pass.
-    """
-    _git(checkout, "tag", "v0.3.1")
-
-    ref = checkout / ".git" / "refs" / "tags" / "v0.3.9"
-    ref.parent.mkdir(parents=True, exist_ok=True)
-    ref.write_text("0" * 39 + "1\n", encoding="utf-8")
-
-    forged = subprocess.run(
-        ["git", "-C", str(checkout), "ls-tree", "-r", "v0.3.9"],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    assert forged.returncode != 0, (
-        "the forgery did not create the condition: the tag still reads, so this case would "
-        "pass with or without the tolerance"
-    )
-
-    done = _run(install_dir, checkout)
-
-    assert done.returncode == 0, (
-        "an unreadable tag is one release this reading cannot name, not a reason to answer "
-        f"nothing: {done.stdout!r} {done.stderr!r}"
-    )
-    assert "still reach" in done.stdout, (
-        "the drift verdict is the reading's reason to exist and must survive: " + done.stdout
-    )
-    assert "tags: 1 release tag(s)" in done.stdout and "v0.3.9" in done.stdout, (
-        "the skipped tag has to be counted and named, or a narrowed list reads as the whole "
-        "one: " + done.stdout
-    )
-    assert "behind: none" in done.stdout, (
-        "the newest tag that *can* be read is still v0.3.1 and the tree is its copy, so the "
-        "verdict over what was readable is unchanged: " + done.stdout
-    )
-
-
-def test_a_tree_newer_than_every_release_tag_is_not_reported_as_behind(
-    tmp_path: Path, checkout: Path
-) -> None:
-    """The direction, not just the distance: advice to downgrade is the defect.
-
-    A checkout nobody has fetched lately carries tags that stop short of the install tree -
-    ordinary, and measured 2026-10-20 on a peer host where the newest tag was `v0.3.18` and
-    the tree reported `0.3.21`. The line printed there named `v0.3.18` as "the newest release"
-    and recommended "an upgrade to v0.3.18", for a tree three releases **newer**. The tree's
-    own version file is what answers it here, and the remedy has to follow.
-    """
-    (checkout / "emrg" / "__init__.py").write_text(
-        '__version__ = "0.3.1"\n', encoding="utf-8"
-    )
-    _git(checkout, "add", "-A")
-    _git(checkout, "commit", "-q", "-m", "the version file ships too")
-    _git(checkout, "tag", "v0.3.1")
-
-    # Two releases of work the tag list does not know about - committed, so the drift
-    # reading is green and the case is about the release line alone.
-    _recommit(checkout, "narrowed content\n", "the next release's content")
-    (checkout / "emrg" / "__init__.py").write_text(
-        '__version__ = "0.3.3"\n', encoding="utf-8"
-    )
-    _git(checkout, "add", "-A")
-    _git(checkout, "commit", "-q", "-m", "version 0.3.3")
-
-    tree = tmp_path / "install" / "source"
-    (tree / "emrg" / "server").mkdir(parents=True)
-    for name in (SHARED, "README.md", "emrg/__init__.py"):
-        shutil.copyfile(checkout / name, tree / name)
-
-    done = _run(tree, checkout)
-
-    assert done.returncode == 0, done.stdout + done.stderr
-    assert "still reach" in done.stdout, (
-        "the content is committed, so the drift reading is green and this case is about the "
-        "release line: " + done.stdout
-    )
-    assert "newer than v0.3.1" in done.stdout, (
-        "the line has to say which side is ahead, or the remedy is a guess: " + done.stdout
-    )
-    assert "0.3.3" in done.stdout, (
-        "the tree's own version is the local fact that answers this: " + done.stdout
-    )
-    assert "would move this tree backwards" in done.stdout, (
-        "an upgrade to an older tag is the advice that made this a defect: " + done.stdout
-    )
-    assert "remedy: an upgrade to v0.3.1 brings these" not in done.stdout, (
-        "the remedy must not recommend a downgrade: " + done.stdout
-    )
-    assert "git fetch --tags" in done.stdout, (
-        "what is actually wrong is the tag list, and the line must say so: " + done.stdout
-    )
diff --git a/tests/test_check_stacked_prs.py b/tests/test_check_stacked_prs.py
deleted file mode 100644
index 91607e9f..00000000
--- a/tests/test_check_stacked_prs.py
+++ /dev/null
@@ -1,378 +0,0 @@
-"""`check-stacked-prs.py`: the reading that reports a PR carrying another open PR's head.
-
-Both directions, because a check is only evidence if it can fail: the carrier is reported
-when the carried PR is open, and the same shape is *not* a fault once that PR has landed
-(the state #1879 was in after #1877 merged, measured 2026-10-07: the landing changes one
-path instead of three).
-
-The fixtures are the API's own shapes, taken from the live endpoints this cycle:
-`pulls?state=open` projects `{number, title, head_sha, head_ref, base_ref}`, and
-`pulls/<N>/commits` projects `{sha, subject}` with the subject taken to the end of its
-first line. The commit list of a real stacked PR is what makes the positive arm real:
-measured on #1879, `pulls/1879/commits` returns four commits whose first is #1877's head
-`b1e50447` and whose last is the PR's own.
-"""
-from __future__ import annotations
-
-import importlib.util
-import json
-import sys
-from pathlib import Path
-
-import pytest
-
-from emrg.server.daemon import PROJECT_CONTEXT_MAX_CHARS
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-SCRIPT = REPO_ROOT / "scripts" / "check-stacked-prs.py"
-
-#: A stacked pair, as the API reported it for #1879 and #1877 (recorded 2026-10-07).
-OLD_HEAD = "b1e5044726e3d5fd6a4a5d0e2e1d3a4b5c6d7e8f"
-OWN_HEAD = "c8b5bb5c35c70ec75a0ede53654de290e6623541"
-OTHER_PR = 1877
-CARRIER = 1879
-
-
-def _load_module():
-    spec = importlib.util.spec_from_file_location("check_stacked_prs", SCRIPT)
-    mod = importlib.util.module_from_spec(spec)
-    # Registered before exec: dataclasses resolves annotations through
-    # `sys.modules[cls.__module__]` at class-creation time, and an unregistered module
-    # raises inside dataclasses itself with a message naming neither this file nor why.
-    sys.modules[spec.name] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-@pytest.fixture
-def mod():
-    return _load_module()
-
-
-class FakeGh:
-    """A stand-in for the module's two gh readers, answering from a routing table.
-
-    Routes on the *endpoint* rather than on the jq filter: the filter is the caller's and
-    the point of the arrangement is that a projection which did not apply comes back
-    looking like a subject with no rows, so the fake has to be able to answer both.
-    """
-
-    def __init__(self, pulls, commits, statuses=None, break_on=""):
-        self.pulls = pulls
-        self.commits = commits
-        self.statuses = statuses or {}
-        self.break_on = break_on
-        self.calls: list[list[str]] = []
-        #: The module's own "could not measure" type, filled in by `_install`: the fake has
-        #: to raise what the tool catches, or it would prove only that *a* RuntimeError is
-        #: caught. `MeasurementError` derives from RuntimeError, so the wrong class is the
-        #: one a reader would not notice.
-        self.error_cls: type[Exception] = RuntimeError
-
-    def _route(self, args: list[str]) -> object:
-        self.calls.append(list(args))
-        endpoint = next((a for a in args if a.startswith("repos/")), "")
-        if self.break_on and self.break_on in endpoint:
-            raise self.error_cls(f"gh failed (rc=1): {endpoint}")
-        if "/pulls?" in endpoint:
-            return list(self.pulls)
-        if endpoint.endswith("/commits?per_page=100"):
-            number = int(endpoint.split("/pulls/")[1].split("/")[0])
-            return list(self.commits.get(number, []))
-        if "/compare/" in endpoint:
-            sha = endpoint.split("...")[1]
-            return {"status": self.statuses.get(sha, "ahead")}
-        raise AssertionError(f"unexpected endpoint: {endpoint}")
-
-    def __call__(self, args: list[str]) -> object:
-        return self._route(args)
-
-    def lines(self, args: list[str]) -> list[dict]:
-        answer = self._route(args)
-        assert isinstance(answer, list)
-        return answer
-
-
-def _install(mod, monkeypatch, fake: FakeGh) -> None:
-    fake.error_cls = mod.MeasurementError
-    monkeypatch.setattr(mod, "_gh_json", lambda args: fake(args))
-    monkeypatch.setattr(mod, "_gh_lines", lambda args: fake.lines(args))
-
-
-def _pull(number: int, head: str, title: str = "t") -> dict:
-    return {
-        "number": number,
-        "title": title,
-        "head_sha": head,
-        "head_ref": f"fix/pr-{number}",
-        "base_ref": "master",
-    }
-
-
-def _commit(sha: str, subject: str) -> dict:
-    return {"sha": sha, "subject": subject}
-
-
-def _run(mod, monkeypatch, fake: FakeGh, argv: list[str] | None = None) -> int:
-    _install(mod, monkeypatch, fake)
-    return mod.main(argv if argv is not None else ["--repo", "argszero/emrg"])
-
-
-def test_a_carrier_is_reported_when_the_other_pr_is_open(mod, monkeypatch, capsys):
-    """The defect this tool was written for, on the payload #1879 really returned.
-
-    #1879's commit list begins with #1877's head commit, because the branch was cut from
-    that PR's branch. While #1877 is open, merging #1879 lands #1876's fix under a PR that
-    declares only #1878 - which is what the reviewer vetoed it for, by hand.
-    """
-    fake = FakeGh(
-        pulls=[_pull(CARRIER, OWN_HEAD), _pull(OTHER_PR, OLD_HEAD)],
-        commits={
-            CARRIER: [
-                _commit(OLD_HEAD, "emrg: grep counts only the files it really read"),
-                _commit(OWN_HEAD, "emrg: the empty tree leg holds every guard"),
-            ],
-            OTHER_PR: [_commit(OLD_HEAD, "emrg: grep counts only the files it really read")],
-        },
-        statuses={OLD_HEAD: "diverged"},
-    )
-    rc = _run(mod, monkeypatch, fake)
-    cap = capsys.readouterr()
-    assert rc == 1, "a PR that would land another open PR's work is a fault, not a pass"
-    assert f"#{CARRIER} stacked" in cap.out
-    assert f"carries #{OTHER_PR} head {OLD_HEAD[:8]}" in cap.out
-    assert f"#{OTHER_PR} ok" in cap.out, (
-        "the carried PR is not the fault - it holds its own work; the carrier is"
-    )
-    assert "would land another open PR's work" in cap.err
-    # The remedy has to be runnable as printed: a bare `scripts/x.py` is mode 644 here.
-    assert mod.RUNNER in cap.err
-    assert f"{mod.RUNNER} scripts/check-merge-landing-diff.py {CARRIER}" in cap.err
-
-
-def test_a_queue_with_no_stack_is_clean(mod, monkeypatch, capsys):
-    """Two PRs cut from the same master share no head commits, and that is the clean run."""
-    fake = FakeGh(
-        pulls=[_pull(1, "a" * 40), _pull(2, "b" * 40)],
-        commits={1: [_commit("a" * 40, "one")], 2: [_commit("b" * 40, "two")]},
-    )
-    rc = _run(mod, monkeypatch, fake)
-    cap = capsys.readouterr()
-    assert rc == 0
-    assert "OK: 2 open PR(s), none carries another open PR's head commit" in cap.out
-    assert "#1 ok" in cap.out and "#2 ok" in cap.out
-
-
-def test_a_pr_does_not_report_itself(mod, monkeypatch, capsys):
-    """`pulls/<N>/commits` always contains the PR's own head - the self-skip is load-bearing.
-
-    Without it every PR in every queue would be reported as carrying a head commit, and
-    the reading would be noise that fires on everything.
-    """
-    fake = FakeGh(
-        pulls=[_pull(1, "a" * 40)],
-        commits={1: [_commit("a" * 40, "one"), _commit("a" * 40, "one again")]},
-    )
-    rc = _run(mod, monkeypatch, fake)
-    cap = capsys.readouterr()
-    assert rc == 0
-    assert "stacked" not in cap.out
-
-
-def test_a_carried_head_whose_pr_is_closed_is_not_a_fault(mod, monkeypatch, capsys):
-    """The state #1879 was in after #1877 landed - and it is why the condition is the queue.
-
-    The carried commit is still in the commit list (squash landed it, so the SHA is not on
-    master: `compare/master...b1e50447` answers `diverged, ahead_by 1`, measured 2026-10-07),
-    and the landing then changes one path rather than three. Nothing in the graph can say
-    that; the *open set* can, and this arm pins that the graph is not asked to.
-    """
-    fake = FakeGh(
-        pulls=[_pull(CARRIER, OWN_HEAD)],
-        commits={CARRIER: [_commit(OLD_HEAD, "emrg: grep counts only the files it really read")]},
-        statuses={OLD_HEAD: "diverged"},
-    )
-    rc = _run(mod, monkeypatch, fake)
-    cap = capsys.readouterr()
-    assert rc == 0, (
-        "the carried PR is closed, so this PR lands only its own work - reporting the "
-        "diverged SHA as a fault is the 'the commit is not an ancestor, so the work is "
-        "unlanded' inference the squash landing falsifies"
-    )
-    assert "OK:" in cap.out
-    assert not [c for c in fake.calls if "/compare/" in " ".join(c)], (
-        "no compare call is owed when no open PR owns the carried commit"
-    )
-
-
-def test_a_carried_head_already_on_master_is_reported_and_not_counted(mod, monkeypatch, capsys):
-    """The one answer the compare endpoint can prove: `behind` means the commit is master's ancestor.
-
-    That commit's work is on master, so landing it again is not what this tool is about -
-    but the row says so rather than dropping the finding, because a row that silently lost
-    a finding reads exactly like one that never had it.
-    """
-    fake = FakeGh(
-        pulls=[_pull(CARRIER, OWN_HEAD), _pull(OTHER_PR, OLD_HEAD)],
-        commits={CARRIER: [_commit(OLD_HEAD, "emrg: already landed")]},
-        statuses={OLD_HEAD: "behind"},
-    )
-    rc = _run(mod, monkeypatch, fake)
-    cap = capsys.readouterr()
-    assert rc == 0
-    assert "already on master" in cap.out
-    assert f"#{OTHER_PR} head {OLD_HEAD[:8]}" in cap.out, (
-        "the fact is still reported - only the fault is withheld"
-    )
-    assert "stacked" not in cap.out
-
-
-def test_a_broken_lookup_is_not_a_clean_queue(mod, monkeypatch, capsys):
-    """An unreadable queue is not an empty one: rc 2, and no OK line."""
-    fake = FakeGh(pulls=[], commits={}, break_on="/pulls?")
-    rc = _run(mod, monkeypatch, fake)
-    cap = capsys.readouterr()
-    assert rc == 2
-    assert "cannot determine the stacked PRs" in cap.err
-    assert "OK:" not in cap.out, "a read that failed may not print a clean verdict"
-
-
-def test_the_open_pr_projection_is_read_not_assumed(mod, monkeypatch, capsys):
-    """A projection that did not apply comes back with no `head_sha`, and every PR then looks clean.
-
-    That is the shape `check-vote-count.py`'s caller-owned-filter rule was written for: the
-    tool cannot tell "no carriers" from "the field I read was never asked for", so it refuses
-    to answer instead of reporting a clean queue.
-    """
-    fake = FakeGh(pulls=[{"number": 5, "title": "t"}], commits={})
-    rc = _run(mod, monkeypatch, fake)
-    cap = capsys.readouterr()
-    assert rc == 2
-    assert "projection did not apply" in cap.err
-    assert "OK:" not in cap.out
-
-
-def test_a_crash_answers_could_not_measure(mod, monkeypatch, capsys):
-    """A crash may not leave as this tool's `1`, because `1` means "there is a stacked PR".
-
-    Measured while arming this file (2026-10-07): with the projection check disabled, a row
-    without `head_sha` reaches `judge` and raises `KeyError`. Without the wrapper that is an
-    unhandled exception, Python exits `1`, and a caller reading the code reads "a PR carries
-    another one's work" about a queue the tool never read. Both halves are asserted: the
-    code, and the line that names the cause.
-    """
-
-    def boom(*args, **kwargs):
-        raise KeyError("head_sha")
-
-    monkeypatch.setattr(mod, "main", boom)
-    rc = mod._entry()
-    cap = capsys.readouterr()
-    assert rc == 2, "a crash is the unmeasurable code, never the code that means a finding"
-    assert "check-stacked-prs.py: could not measure - KeyError: 'head_sha'" in cap.err, (
-        "the summary line has to name the tool and the cause, or a reader sees only a "
-        "traceback and cannot tell which reading failed"
-    )
-
-
-def test_the_entry_point_returns_what_main_answered(mod, monkeypatch):
-    """The other direction: a verdict is passed through, not turned into an unmeasurable."""
-    monkeypatch.setattr(mod, "main", lambda *a, **k: 1)
-    assert mod._entry() == 1, (
-        "a wrapper that swallowed the verdict would make every fault unreadable"
-    )
-    monkeypatch.setattr(mod, "main", lambda *a, **k: 0)
-    assert mod._entry() == 0
-
-
-def test_a_commit_list_is_read_past_the_first_page(mod, monkeypatch):
-    """A PR with more than one page of commits must not lose the page the carried head is on.
-
-    `--paginate` with a per-line filter emits one JSON object per line across pages, so the
-    reader is exercised at the shape gh really produces: two pages' worth of lines, parsed
-    as one list, with nothing silently dropped at the page boundary.
-    """
-    pages = "\n".join(
-        json.dumps({"sha": f"{i:040d}", "subject": f"commit {i}"}) for i in range(150)
-    )
-    calls: list[list[str]] = []
-
-    def fake_run(argv, **kwargs):
-        calls.append(list(argv))
-        assert "--paginate" in argv, "the pagination flag is what makes the read complete"
-        return type("P", (), {"returncode": 0, "stdout": pages, "stderr": ""})()
-
-    monkeypatch.setattr(mod.subprocess, "run", fake_run)
-    rows = mod._gh_lines(["api", "repos/x/y/pulls/1/commits?per_page=100", "--jq", ".[] | {}"])
-    assert len(rows) == 150, "every line of every page is one commit, and none is dropped"
-    assert rows[0]["sha"] == f"{0:040d}" and rows[-1]["sha"] == f"{149:040d}"
-    assert calls and calls[0][-1] == "--paginate"
-
-
-# ── A gate nobody can find is a gate nobody runs ──────────────────────────────
-#
-# Measured 2026-10-07 (`cyc20261007-103453`), the day after this tool landed: it was named in
-# **no tracked document at all** — not in `Agent.md`'s merge-gate list, not in
-# `DEVELOPMENT.md`, not in `evolution_prompt.md`'s table of readings. The only carriers were
-# its own docstring, this file, and the private `.emrg/` records, which is the wrong direction
-# for a reading whose whole reason for existing is that "no reading in this repository caught
-# it" (PR #1885): the next reviewer who does not already know the name cannot run it.
-#
-# The list it belongs in was at 7997 of the 8000 characters `Agent.md` gets in the prompt, so
-# naming it there needs space freed from something else — a content decision rather than an
-# edit this file may make. The two arms below pin the substitute home and *measure* the reason
-# for it, so the arrangement ends when its reason does instead of by habit.
-
-#: The runnable form, because a bare name is not a command (`scripts/*.py` is mode 644) — the
-#: rule `tests/test_printed_commands_carry_the_python_runner.py` holds for printed remedies,
-#: applied to the document that carries this one.
-_INVOCATION = "uv run --no-sync python3 scripts/check-stacked-prs.py"
-
-#: What it answers, so the reader knows when to reach for it.
-_ANSWERS = "another open PR's commits"
-
-#: The entry `Agent.md`'s merge-gate list would gain, spelled as that list spells its members.
-_AGENT_ENTRY = " · `scripts/check-stacked-prs.py` (a head carrying another open PR's commits)"
-
-
-def test_the_document_names_this_gate_in_a_form_that_runs() -> None:
-    """A gate whose name is in no document is not part of the process, however good it is."""
-    text = (REPO_ROOT / "DEVELOPMENT.md").read_text(encoding="utf-8")
-    assert _INVOCATION in text, (
-        f"DEVELOPMENT.md does not carry `{_INVOCATION}` — the gate is then findable only by "
-        f"someone who already knows it exists"
-    )
-    assert _ANSWERS in text, (
-        f"the document names the gate without the question it answers (`{_ANSWERS}`), so a "
-        f"reader cannot tell when to run it"
-    )
-
-
-def test_the_reason_it_is_not_in_the_agent_brief_is_measured_not_assumed() -> None:
-    """The claim in `DEVELOPMENT.md` is about a size, so it is measured here rather than stated.
-
-    `Agent.md` is injected into the prompt and the daemon keeps only its first
-    `PROJECT_CONTEXT_MAX_CHARS`, so an entry that does not fit is not a line anyone forgot —
-    it is a trade. This arm asserts the trade is still forced: the gate is absent from the list
-    **and** adding it would exceed the cap. The day space is freed, this fails and says what to
-    move, which is the only way a temporary home stops being a permanent one.
-    """
-    agent = (REPO_ROOT / "Agent.md").read_text(encoding="utf-8")
-    gate_line = [
-        line for line in agent.splitlines() if line.startswith("- Merge gates")
-    ]
-    assert len(gate_line) == 1, (
-        f"expected exactly one `- Merge gates` line in Agent.md, found {len(gate_line)}"
-    )
-
-    assert "check-stacked-prs.py" not in gate_line[0], (
-        "Agent.md's merge-gate list now names this gate, so the stand-in paragraph in "
-        "DEVELOPMENT.md ('The reading that reports a stacked head') has outlived its reason — "
-        "delete it and keep the entry that fits"
-    )
-    assert len(agent) + len(_AGENT_ENTRY) > PROJECT_CONTEXT_MAX_CHARS, (
-        f"Agent.md ({len(agent)} chars) now has room for the entry "
-        f"({len(_AGENT_ENTRY)} chars) inside its {PROJECT_CONTEXT_MAX_CHARS}-character cap, so "
-        f"the reason `DEVELOPMENT.md` gives for this gate living outside the brief no longer "
-        f"holds — move the entry into the merge-gate list"
-    )
diff --git a/tests/test_check_suite_durations.py b/tests/test_check_suite_durations.py
deleted file mode 100644
index 14713f23..00000000
--- a/tests/test_check_suite_durations.py
+++ /dev/null
@@ -1,380 +0,0 @@
-"""`scripts/check-suite-durations.py` — the CI-leg duration guard (issue #2296 R4).
-
-Every arm here is offline: the API is a stand-in, so the suite that runs this file
-never makes a request, and the one arm that runs the real script does it with an empty
-`PATH` so `gh` cannot be found at all (the same technique `tests/test_check_pr_base.py`
-uses for the cannot-ask path — the Windows runner has no `gh`, and a guard whose tests
-need the network would be red for a reason that is not the rule).
-
-The three-state contract is what these arms are about, in the order the family means
-it: a leg over budget is **1**, an unreadable leg is **2**, and only a complete, clean
-reading is **0**. The arm that matters most is the middle one — a guard that reported
-"no suite step found" as success is exactly the failure mode R4 exists to close.
-"""
-from __future__ import annotations
-
-import importlib.util
-import json
-import os
-import re
-import subprocess
-import sys
-from datetime import datetime, timedelta
-from pathlib import Path
-
-import pytest
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-SCRIPT = REPO_ROOT / "scripts" / "check-suite-durations.py"
-WORKFLOWS_DIR = REPO_ROOT / ".github" / "workflows"
-
-
-def _load():
-    spec = importlib.util.spec_from_file_location("check_suite_durations", SCRIPT)
-    assert spec is not None and spec.loader is not None
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)
-    return mod
-
-
-_BASE = datetime(2026, 10, 15, 6, 0, 0)
-
-
-def _stamp(minute: int, seconds: int) -> tuple[str, str]:
-    """`(started_at, completed_at)` for a step starting `minute` minutes after the base.
-
-    Built by adding a delta rather than by formatting arithmetic: the first version
-    formatted the end from `minute * 60 + seconds` and so produced instants *before*
-    their start, which `step_seconds` refuses (rightly) — the guard was correct and the
-    fixture was wrong.
-    """
-    start = _BASE + timedelta(minutes=minute)
-    end = start + timedelta(seconds=seconds)
-    return start.strftime("%Y-%m-%dT%H:%M:%SZ"), end.strftime("%Y-%m-%dT%H:%M:%SZ")
-
-
-class FakeGh:
-    """`subprocess.run`, answering the three endpoints the guard calls.
-
-    `runs` maps a workflow file to (run dict, jobs list). A workflow that is absent
-    answers as GitHub does when there is no run to read: an empty `workflow_runs`.
-    """
-
-    def __init__(self, runs: dict, jobs: dict | None = None):
-        self.runs = runs
-        self.jobs = jobs or {}
-        self.calls: list[list[str]] = []
-
-    def __call__(self, args, **kwargs):
-        self.calls.append(list(args))
-        joined = " ".join(args)
-        match = re.search(r"workflows/([^/]+)/runs", joined)
-        if match:
-            workflow = match.group(1)
-            if workflow not in self.runs:
-                return _Completed(json.dumps({"workflow_runs": []}))
-            return _Completed(json.dumps({"workflow_runs": [self.runs[workflow][0]]}))
-        match = re.search(r"actions/runs/(\d+)/jobs", joined)
-        if match:
-            run_id = int(match.group(1))
-            for run, jobs in self.runs.values():
-                if run["id"] == run_id:
-                    return _Completed(json.dumps({"jobs": jobs}))
-            return _Completed(json.dumps({"jobs": self.jobs.get(run_id, [])}))
-        match = re.search(r"actions/runs/(\d+)$", joined)
-        if match:
-            run_id = int(match.group(1))
-            for run, _jobs in self.runs.values():
-                if run["id"] == run_id:
-                    return _Completed(json.dumps(run))
-            return _Completed("{}", returncode=1, stderr="gh: Not Found (HTTP 404)")
-        return _Completed("{}", returncode=1, stderr="gh: unexpected call")
-
-
-class _Completed:
-    def __init__(self, stdout: str, returncode: int = 0, stderr: str = ""):
-        self.stdout = stdout
-        self.returncode = returncode
-        self.stderr = stderr
-
-
-def _run_dict(run_id: int = 111, branch: str = "master", path: str = ".github/workflows/test.yml") -> dict:
-    return {
-        "id": run_id,
-        "head_branch": branch,
-        "created_at": "2026-10-15T06:00:00Z",
-        "path": path,
-        "name": "Test",
-    }
-
-
-def _step(name: str, seconds: int, minute: int = 0) -> dict:
-    start, end = _stamp(minute, seconds)
-    return {
-        "name": name, "status": "completed", "conclusion": "success",
-        "started_at": start, "completed_at": end,
-    }
-
-
-def _job(name: str, steps: list[dict], conclusion: str = "success") -> dict:
-    return {"name": name, "conclusion": conclusion, "steps": steps}
-
-
-def _two_legs(test_seconds=100, windows_seconds=200, release_seconds=150) -> dict:
-    """Both declared workflows, each with the legs the guard has to read.
-
-    Every declared workflow must contribute a readable run, or `main` refuses with
-    rc 2 — which is the point of `test_a_workflow_with_no_run_at_all_is_rc_2`, and why
-    this fixture cannot supply only `test.yml`.
-    """
-    return {
-        "test.yml": (_run_dict(), [
-            _job("test", [_step("uv run pytest tests/ -v -n auto --dist loadfile", test_seconds)]),
-            _job("test-windows", [_step("Python tests (Windows)", windows_seconds)]),
-        ]),
-        "build-release.yml": (_run_dict(222, "v0.3.13"), [
-            _job("build (windows-2025, x64)", [
-                _step("Python tests (regression gate)", release_seconds),
-            ]),
-            _job("build (ubuntu-24.04, x86_64)", [
-                _step("Python tests (regression gate)", release_seconds),
-            ]),
-        ]),
-    }
-
-
-# ── the three states ──────────────────────────────────────────────────────────────────
-
-
-def test_a_leg_over_budget_is_rc_1(monkeypatch, capsys) -> None:
-    mod = _load()
-    monkeypatch.setattr(mod.subprocess, "run", FakeGh(_two_legs()))
-
-    rc = mod.main([])
-
-    out = capsys.readouterr().out
-    assert rc == 1, out
-    assert "test-windows" in out
-    assert "OVER" in out
-
-
-def test_a_clean_reading_is_rc_0(monkeypatch, capsys) -> None:
-    mod = _load()
-    monkeypatch.setattr(mod.subprocess, "run", FakeGh(_two_legs(test_seconds=90, windows_seconds=170)))
-
-    rc = mod.main([])
-
-    out = capsys.readouterr().out
-    assert rc == 0, out
-    assert "ok" in out.lower()
-
-
-def test_a_leg_with_no_readable_step_is_rc_2_not_0(monkeypatch, capsys) -> None:
-    """The refusal that keeps this guard from blessing a workflow it never read.
-
-    A run whose jobs carry no recognisable suite step is not a clean reading — it is a
-    reading that did not happen. Reporting 0 here is the whole defect class.
-    """
-    mod = _load()
-    monkeypatch.setattr(mod.subprocess, "run", FakeGh({
-        "test.yml": (_run_dict(), [_job("test", [_step("Set up Python", 3)])]),
-    }))
-
-    rc = mod.main(["--workflow", "test.yml"])
-
-    captured = capsys.readouterr()
-    assert rc == 2, captured.out + captured.err
-    assert "could not measure" in captured.err
-    assert "no step this guard can recognise" in captured.err
-
-
-def test_a_workflow_with_no_run_at_all_is_rc_2(monkeypatch, capsys) -> None:
-    mod = _load()
-    monkeypatch.setattr(mod.subprocess, "run", FakeGh({}))
-
-    rc = mod.main([])
-
-    captured = capsys.readouterr()
-    assert rc == 2
-    assert "no completed run to read" in captured.err
-
-
-def test_a_step_with_no_instants_is_rc_2_not_0(monkeypatch, capsys) -> None:
-    """`completed_at: null` is unknown, not zero.
-
-    A step that has not finished (or was skipped) carries no instants. Reading that as
-    0.0s would invent the number the guard exists to measure — and 0.0s passes.
-    """
-    mod = _load()
-    unfinished = _step("Python tests (Windows)", 200)
-    unfinished["completed_at"] = None
-    monkeypatch.setattr(mod.subprocess, "run", FakeGh({
-        "test.yml": (_run_dict(), [_job("test-windows", [unfinished])]),
-    }))
-
-    rc = mod.main(["--workflow", "test.yml"])
-
-    captured = capsys.readouterr()
-    assert rc == 2, captured.out + captured.err
-    assert "no started_at/completed_at" in captured.err
-
-
-# ── the number comes from the artefact ────────────────────────────────────────────────
-
-
-def test_the_duration_is_read_from_the_stamps(monkeypatch, capsys) -> None:
-    """Two payloads differing only in the instants give different seconds.
-
-    Without this the arms above would pass against a guard that printed a constant.
-    """
-    mod = _load()
-    monkeypatch.setattr(mod.subprocess, "run", FakeGh(_two_legs(test_seconds=10, windows_seconds=170)))
-    assert mod.main([]) == 0
-    first = capsys.readouterr().out
-
-    monkeypatch.setattr(mod.subprocess, "run", FakeGh(_two_legs(test_seconds=42, windows_seconds=170)))
-    assert mod.main([]) == 0
-    second = capsys.readouterr().out
-
-    assert "10.0s" in first and "42.0s" in second
-    assert first != second
-
-
-def test_the_budget_flag_moves_the_verdict(monkeypatch, capsys) -> None:
-    """The one duration written down is the rule, and it is overridable."""
-    mod = _load()
-    monkeypatch.setattr(mod.subprocess, "run", FakeGh(_two_legs(test_seconds=100, windows_seconds=200)))
-
-    assert mod.main(["--budget", "250"]) == 0
-    assert "250s" in capsys.readouterr().out
-
-    assert mod.main(["--budget", "150"]) == 1
-    assert capsys.readouterr().out
-
-
-def test_a_run_id_is_read_directly_when_given(monkeypatch) -> None:
-    mod = _load()
-    fake = FakeGh(_two_legs())
-    monkeypatch.setattr(mod.subprocess, "run", fake)
-
-    assert mod.main(["--run", "111"]) == 1
-
-    joined = [" ".join(call) for call in fake.calls]
-    assert any("actions/runs/111" in call and "workflows" not in call for call in joined), joined
-
-
-def test_the_report_names_the_run_it_read(monkeypatch, capsys) -> None:
-    """The subject is named before the verdict — the remote reader's version of `tree:`."""
-    mod = _load()
-    monkeypatch.setattr(mod.subprocess, "run", FakeGh(_two_legs()))
-
-    mod.main([])
-
-    out = capsys.readouterr().out
-    lines = out.splitlines()
-    assert lines[0].startswith("repo: ")
-    first_verdict = next(i for i, line in enumerate(lines) if "OVER" in line or "OK:" in line)
-    assert any("run 111" in line for line in lines[:first_verdict]), out
-
-
-def test_a_missing_gh_is_rc_2_offline(tmp_path) -> None:
-    """The real script, no network: `gh` is not on an empty PATH.
-
-    The in-process arms above stub `subprocess.run`; this one proves the *shipped*
-    entry point refuses too, and does it without a round trip.
-    """
-    empty = tmp_path / "empty-path"
-    empty.mkdir()
-    # `errors="replace"`, the same convention as `run_guard_once` in
-    # `tests/conftest.py` and as `test_check_pr_base.py`'s sibling spawn below:
-    # a strict decode of a child's stderr raises on a host whose system language
-    # is not English and leaves `proc.stderr` as `None`, which turns this row red
-    # for its own plumbing rather than for the refusal it pins. (This script's
-    # refusal carries no OS text, so the row is green today either way; the
-    # keyword is what keeps it green when the message gains one.)
-    proc = subprocess.run(
-        [sys.executable, str(SCRIPT)],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        env=dict(os.environ, PATH=str(empty)),
-    )
-
-    assert proc.returncode == 2, (proc.returncode, proc.stdout, proc.stderr)
-    assert "gh is not available" in proc.stderr
-
-
-# ── the reading is not this file's arithmetic ─────────────────────────────────────────
-
-
-@pytest.mark.parametrize(
-    "value,expected",
-    [
-        ("2026-10-15T06:00:00Z", "2026-10-15 06:00:00+00:00"),
-        ("2026-10-15T06:00:00+00:00", "2026-10-15 06:00:00+00:00"),
-    ],
-)
-def test_both_stamp_spellings_parse(value, expected) -> None:
-    mod = _load()
-    assert str(mod.parse_stamp(value)) == expected
-
-
-@pytest.mark.parametrize("value", [None, "", "not a date", 12345])
-def test_an_unreadable_stamp_is_none_not_an_exception(value) -> None:
-    mod = _load()
-    assert mod.parse_stamp(value) is None
-
-
-def test_a_negative_duration_is_unmeasurable() -> None:
-    """Clock skew between two instants is not a duration to report."""
-    mod = _load()
-    step = {
-        "name": "Python tests (Windows)",
-        "started_at": "2026-10-15T06:10:00Z",
-        "completed_at": "2026-10-15T06:00:00Z",
-    }
-    assert mod.step_seconds(step) is None
-
-
-def test_a_skipped_step_is_unmeasurable() -> None:
-    mod = _load()
-    assert mod.step_seconds({"name": "Python tests (Windows)", "conclusion": "skipped"}) is None
-
-
-# ── the closure at the tree level ─────────────────────────────────────────────────────
-
-
-def test_every_declared_workflow_carries_a_step_this_guard_can_see() -> None:
-    """A rename that hid the suite from the markers fails here, not in CI.
-
-    The guard recognises a suite step by marker, and a marker list is a hand-written
-    claim about what the workflows spell. This asks the workflows themselves, so the
-    claim is measured: every workflow the guard declares must carry at least one step
-    whose API name (its `name:`, or its run command when unnamed) would match.
-    """
-    mod = _load()
-    missing = []
-    for workflow in mod.WORKFLOWS:
-        text = (WORKFLOWS_DIR / workflow).read_text(encoding="utf-8")
-        lowered = text.lower()
-        if not any(marker in lowered for marker in mod.SUITE_STEP_MARKERS):
-            missing.append(workflow)
-
-    assert not missing, (
-        f"{missing} carry no spelling this guard recognises, so their suite steps would "
-        f"read as 'contributed nothing' (markers: {mod.SUITE_STEP_MARKERS})"
-    )
-
-
-def test_the_declared_workflows_are_the_ones_that_run_pytest() -> None:
-    """The tuple is a claim too: a third workflow running pytest would go unread."""
-    mod = _load()
-    runners = sorted(
-        path.name for path in WORKFLOWS_DIR.glob("*.yml")
-        if "pytest" in path.read_text(encoding="utf-8")
-    )
-    assert runners == sorted(mod.WORKFLOWS), (
-        "the workflows running pytest and the ones this guard reads differ: "
-        f"{runners} vs {sorted(mod.WORKFLOWS)}"
-    )
diff --git a/tests/test_clipboard_extraction_leaves_nothing_behind.py b/tests/test_clipboard_extraction_leaves_nothing_behind.py
index ea7efbb0..2142e937 100644
--- a/tests/test_clipboard_extraction_leaves_nothing_behind.py
+++ b/tests/test_clipboard_extraction_leaves_nothing_behind.py
@@ -200,7 +200,7 @@ def test_the_refusal_has_one_wording() -> None:
 # the Windows leg reads them too.
 #
 # Each arm is checked against the **pre-change** tree, not only against a mutated one:
-# `run-mutation-arm.py` judges a *file*, so a sibling's red hides an arm that pins
+# A mutation arm judges a *file*, so a sibling's red hides an arm that pins
 # nothing. Measured 2026-10-12 (`cyc20261012-134702`), this file against `8c4a9f55`'s
 # `app.py`: the two arms that name a defect fail there, and the FIFO verdict arm failed
 # only once it asserted the subject's survival beside the answer.
diff --git a/tests/test_competition_prompt.py b/tests/test_competition_prompt.py
index 5c80dec9..bc3d1113 100644
--- a/tests/test_competition_prompt.py
+++ b/tests/test_competition_prompt.py
@@ -20,8 +20,8 @@
 file keeps every character, and a file read cannot see that at all: measured 2026-10-08
 (`cyc20261008-082424`, issue #1904), wrapping §0.0 in `{# … #}` left all five
 load-bearing phrases in the file, every file-level assertion green, and the render 2,301
-characters shorter with none of them — `scripts/run-mutation-arm.py` reported `SURVIVED`
-for exactly that arm. The same shape was fixed for `emrg/server/prompts/vibe_check.j2`
+characters shorter with none of them — a hand-written mutation arm reported `SURVIVED`
+for exactly that one. The same shape was fixed for `emrg/server/prompts/vibe_check.j2`
 in issue #1902.
 """
 
@@ -966,8 +966,8 @@ def test_the_render_substitutes_values_and_carries_no_template_syntax(rendered):
 # Same two levels as above, for the same reason. §0.7 and §1's first sentence are new text
 # in a Jinja2 template: a `{# … #}` around either removes it from every round's prompt while
 # the file keeps every character, and that is the one failure a file-level guard cannot see
-# (measured 2026-10-08, `cyc20261008-082424`, issue #1904 — `run-mutation-arm.py` reported
-# SURVIVED for exactly that arm).
+# (measured 2026-10-08, `cyc20261008-082424`, issue #1904 — a hand-written mutation arm
+# reported SURVIVED for exactly that one).
 
 
 def test_the_coverage_and_hygiene_rules_reach_the_round_and_not_merely_the_file(rendered):
diff --git a/tests/test_config_template_carriers.py b/tests/test_config_template_carriers.py
index 64c55500..780f82e9 100644
--- a/tests/test_config_template_carriers.py
+++ b/tests/test_config_template_carriers.py
@@ -232,9 +232,8 @@ def test_the_gui_reader_keys_on_the_same_sentinel():
     Issue #2256's table names two readers: ``emrg/gui/main.js::isKeyConfigured`` (G117,
     which opens the setup wizard) and ``LlmClient._headers`` (which refuses the request).
     Only the second was pinned when that fix landed. Renaming the GUI's comparison left this
-    whole module green — measured on master `f33bbc7e` with
-    ``run-mutation-arm.py --file emrg/gui/main.js --old 'key !== "sk-..."' --new
-    'key !== "some-other-placeholder"'`` → **SURVIVED, 4 passed**. The drift that hides there
+    whole module green — measured on master `f33bbc7e` by renaming that comparison in
+    `emrg/gui/main.js` by hand → **SURVIVED, 4 passed**. The drift that hides there
     is silent: move the constant and the writers' test above forces every template to follow,
     the refusal follows with the constant, and the GUI stops recognising the key the product
     writes — two halves of one rule, consistent with each other and wrong together.
diff --git a/tests/test_daemon_manager.py b/tests/test_daemon_manager.py
index 602f50ed..96cc04b8 100644
--- a/tests/test_daemon_manager.py
+++ b/tests/test_daemon_manager.py
@@ -158,7 +158,7 @@ def test_no_token_file_returns_early(self, mock_connect, mock_kill, mock_cleanup
         The rest of the state is pinned too, and that is not tidiness: a mutation that
         drops the early return sends the code down the path this test never meant to
         exercise, where an unpatched `os.kill` fires at the fixture's pid for real
-        (`scripts/run-mutation-arm.py` measured exactly that here on 2026-10-05 — the
+        (a hand-written mutation arm measured exactly that here on 2026-10-05 — the
         first version of this test pinned the connection but not the signal). With the
         source mtime, the kill and the cleanup all mocked, the same mutation reaches
         the assertion below and fails there.
diff --git a/tests/test_forward_slashes_in_reports.py b/tests/test_forward_slashes_in_reports.py
index da704d18..05d2ad33 100644
--- a/tests/test_forward_slashes_in_reports.py
+++ b/tests/test_forward_slashes_in_reports.py
@@ -7,8 +7,8 @@
 by a host, by a CI log, by a sibling guard, and by the tests written against it -- so the
 separator it happens to carry is a fact about the machine that produced it, not about the
 finding. `tests/test_conflict_markers.py` states the rule for its own consumers ("every
-consumer below must use `.as_posix()`"), and `check-doc-count.py`, `check-install-drift.py`,
-`check-merge-plan-suite.py` and `check-rant-citations.py` already obey it. Nothing failed
+consumer below must use `.as_posix()`"), and `check-doc-count.py`, `check-merge-plan-suite.py`
+and `check-rant-citations.py` already obey it. Nothing failed
 when a new renderer did not, and three times in the last month one did not:
 
 * 2026-09-10, `check-conflict-markers` -- **two** CI rounds, the second because only the
diff --git a/tests/test_guard_report.py b/tests/test_guard_report.py
index 67ea43d0..1681ff5f 100644
--- a/tests/test_guard_report.py
+++ b/tests/test_guard_report.py
@@ -46,9 +46,9 @@
 * an AST sweep over **every** `scripts/*.py`: a tool that prints a `tree: ` line to
   stdout *and* writes to stderr must carry the call - unconditionally, so a tool that
   gains the shape without the remedy is caught wherever it came from. The class is the
-  **shape**, not a name: it used to glob `check*.py`, which is how three tools that
-  claim the convention in their own comments went unnoticed (`review-queue.py`,
-  `bump-version.py`, `run-mutation-arm.py` - issue #2049). The sweep also holds a
+  **shape**, not a name: it used to glob `check*.py`, which is how tools that claim
+  the convention in their own comments went unnoticed (`review-queue.py`,
+  `bump-version.py` - issue #2049). The sweep also holds a
   hand-written baseline of the tools known to have the shape, and asserts that the
   baseline and the class name the **same** tools - so a `tree: ` line that quietly
   disappears is visible, and a tool that joins without being held is not silent
@@ -95,7 +95,6 @@
     "bump-version.py",
     "check-citation-resolves.py",
     "check-doc-count.py",
-    "check-install-drift.py",
     "check-memory-index.py",
     "check-merge-landed.py",
     "check-node-test-count.py",
@@ -107,7 +106,6 @@
     "check_nonlocal.py",
     "check_unbound_reads.py",
     "review-queue.py",
-    "run-mutation-arm.py",
 }
 
 
diff --git a/tests/test_llm_cost_report.py b/tests/test_llm_cost_report.py
deleted file mode 100644
index 74126840..00000000
--- a/tests/test_llm_cost_report.py
+++ /dev/null
@@ -1,157 +0,0 @@
-"""Tests for scripts/llm-cost-report.py (LLM API cost profiler).
-
-Covers: token/cost aggregation math, model pairing across rotated llm.jsonl
-backups, the unknown-model fallback, the OpenAI-style cache-details branch,
-and the CLI end-to-end.
-"""
-
-import json
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-SCRIPT = REPO_ROOT / "scripts" / "llm-cost-report.py"
-
-
-def _write_llm_log(session_dir: Path, records: list[dict], name: str = "llm.jsonl") -> None:
-    (session_dir / name).write_text(
-        "".join(json.dumps(r, ensure_ascii=False) + "\n" for r in records),
-        encoding="utf-8",
-    )
-
-
-def _request(model: str) -> dict:
-    return {"type": "request", "model": model, "messages": [], "tools": None, "payload": None}
-
-
-def _response(prompt: int, completion: int, cache: int = 0) -> dict:
-    return {
-        "type": "response",
-        "content": "",
-        "finish_reason": "stop",
-        "usage": {
-            "prompt_tokens": prompt,
-            "completion_tokens": completion,
-            "reasoning_tokens": 0,
-            "cache_hit_tokens": cache,
-        },
-    }
-
-
-def _run_report(root: Path, *extra: str) -> dict:
-    out = subprocess.run(
-        [sys.executable, str(SCRIPT), "--root", str(root), "--json", *extra],
-        capture_output=True,
-        text=True,
-        check=True,
-        # Model names and session ids come from the log; decode them as
-        # UTF-8, never with the host locale.
-        encoding="utf-8",
-        errors="replace",
-    )
-    return json.loads(out.stdout)
-
-
-def test_aggregates_tokens_and_cost_per_model(tmp_path: Path) -> None:
-    sd = tmp_path / "s1"
-    sd.mkdir()
-    # deepseek-v4-flash @ $0.20/$1.20 per 1M: cache billed at 10% of prompt price.
-    _write_llm_log(sd, [_request("deepseek-v4-flash"), _response(1000, 200, cache=900)])
-    result = _run_report(tmp_path, "--pricing", "deepseek-v4-flash:0.2:1.2")
-
-    model = result["models"]["deepseek-v4-flash"]
-    assert model["requests"] == 1
-    assert model["prompt_tokens"] == 1000
-    assert model["cache_hit_tokens"] == 900
-    assert model["completion_tokens"] == 200
-    # billed prompt = 1000 - 900 = 100 -> 0.20*100/1e6
-    # completion = 200 -> 1.20*200/1e6 ; cache = 0.1*0.20*900/1e6
-    expected = (0.20 * 100 + 1.20 * 200 + 0.1 * 0.20 * 900) / 1e6
-    assert model["cost"] == pytest.approx(expected)
-    assert result["totals"] == {
-        "requests": 1,
-        "prompt_tokens": 1000,
-        "cache_hit_tokens": 900,
-        "completion_tokens": 200,
-        "cost": pytest.approx(expected),
-    }
-    assert result["unknown_models"] == []
-
-
-def test_model_pairing_across_rotation_and_unknown(tmp_path: Path) -> None:
-    sd = tmp_path / "s2"
-    sd.mkdir()
-    # Old backup (.1): request only. Newer main file: response pairs with it.
-    _write_llm_log(sd, [_request("deepseek-v4")], name="llm.jsonl.1")
-    _write_llm_log(sd, [_response(500, 50)])
-    # A response with no preceding request anywhere -> (unknown).
-    sd2 = tmp_path / "s3"
-    sd2.mkdir()
-    _write_llm_log(sd2, [_response(10, 5)])
-
-    result = _run_report(tmp_path, "--pricing", "deepseek-v4:1.0:3.0")
-    assert result["models"]["deepseek-v4"]["requests"] == 1
-    assert result["models"]["(unknown)"]["requests"] == 1
-    assert result["models"]["(unknown)"]["cost"] == 0.0
-    assert result["unknown_models"] == ["(unknown)"]
-
-
-def test_openai_style_prompt_tokens_details(tmp_path: Path) -> None:
-    sd = tmp_path / "s4"
-    sd.mkdir()
-    resp = {
-        "type": "response",
-        "content": "",
-        "finish_reason": "stop",
-        "usage": {
-            "prompt_tokens": 400,  # excludes cache
-            "completion_tokens": 100,
-            "prompt_tokens_details": {"cached_tokens": 300},
-        },
-    }
-    _write_llm_log(sd, [_request("gpt-5"), resp])
-    result = _run_report(tmp_path, "--pricing", "gpt-5:1.25:10.0")
-    model = result["models"]["gpt-5"]
-    # prompt 400 billed in full; cache 300 at 10% of prompt price
-    expected = (1.25 * 400 + 10.0 * 100 + 0.1 * 1.25 * 300) / 1e6
-    assert model["cost"] == pytest.approx(expected)
-
-
-def test_cli_human_output_smoke(tmp_path: Path) -> None:
-    sd = tmp_path / "s5"
-    sd.mkdir()
-    _write_llm_log(sd, [_request("deepseek-v4-flash"), _response(100, 10)])
-    out = subprocess.run(
-        [sys.executable, str(SCRIPT), "--root", str(tmp_path)],
-        capture_output=True,
-        text=True,
-        check=True,
-        # Model names and session ids come from the log; decode them as
-        # UTF-8, never with the host locale.
-        encoding="utf-8",
-        errors="replace",
-    )
-    assert "deepseek-v4-flash" in out.stdout
-    assert "TOTAL" in out.stdout
-    assert "Estimated cost" in out.stdout
-
-
-def test_cross_backup_pairing_reads_oldest_first(tmp_path: Path) -> None:
-    """A response in a mid backup pairs with the request in the OLDEST backup.
-
-    Rotation shifts main -> .1 -> .2 -> .3, so .3 is the oldest backup and
-    must be read before .1. Reading .1 first would pair this response with
-    a request that chronologically came AFTER it.
-    """
-    sd = tmp_path / "s6"
-    sd.mkdir()
-    _write_llm_log(sd, [_request("deepseek-v4")], name="llm.jsonl.3")
-    _write_llm_log(sd, [_request("other-model")], name="llm.jsonl.1")
-    _write_llm_log(sd, [_response(500, 50)], name="llm.jsonl.2")
-
-    result = _run_report(tmp_path, "--pricing", "deepseek-v4:1.0:3.0")
-    assert result["models"]["deepseek-v4"]["requests"] == 1
-    assert "other-model" not in result["models"]
diff --git a/tests/test_printed_commands_carry_the_python_runner.py b/tests/test_printed_commands_carry_the_python_runner.py
index 7f4bb35b..0d5109ca 100644
--- a/tests/test_printed_commands_carry_the_python_runner.py
+++ b/tests/test_printed_commands_carry_the_python_runner.py
@@ -73,12 +73,12 @@
 what keeps the clause off prose: "update `VERSION_SOURCES` in `scripts/bump-version.py`"
 ends at the file name and is not a thing to run, while `scripts/check-vote-count.py <PR>` is.
 
-What the clause reads on this tree, measured 2026-10-17: **40** command-shaped mentions, in
-nine tools - `bump-version.py` 2, `cast-vote.py` 8, `check-merge-freshness.py` 8,
-`check-merge-sequence.py` 1, `check-release-published.py` 1, `check-stacked-prs.py` 1,
-`check-vote-count.py` 1, `review-queue.py` 17, `run-mutation-arm.py` 1. This is the first
-reading on which the number went **down**, by exactly one, and it went down the same way the
-sentences above went up: a *printed remedy* is a printed command either way.
+What the clause reads on this tree, measured 2026-10-20: **38** command-shaped mentions, in
+seven tools - `bump-version.py` 2, `cast-vote.py` 8, `check-merge-freshness.py` 8,
+`check-merge-sequence.py` 1, `check-release-published.py` 1, `check-vote-count.py` 1,
+`review-queue.py` 17. This number has gone down as well as up, and it goes down the way it
+went up: a *printed remedy* is a printed command either way, so a remedy deleted together
+with the tool that printed it takes its mention with it.
 `review-queue.py` carried a second `abstain` branch - a head pushed below a window whose
 lower bound the record corpus could not measure, whose printed remedy named
 `scripts/check-vote-count.py <pr>` and offered `--prev-cycle <id>` as the caller's way to
@@ -93,15 +93,8 @@
 (`bash scripts/re-trigger-ci.sh <branch>`), added the same day as the per-cause cures above it
 (cycle `cyc20261011-002826`). Before that the newest was `review-queue.py`'s row for a PR
 whose CI half could not be read (cycle `cyc20261007-203559`), which names the re-ask that failed
-(`uv run --no-sync python3 scripts/check-merge-freshness.py <PR>`), and before it
-`check-stacked-prs.py`, which arrived the same way as the two before it: through a *remedy*. Its
-row for a PR that would
-land another open PR's work ends by naming the instrument that prices what that merge changes
-(`uv run --no-sync python3 scripts/check-merge-landing-diff.py <PR>`), and naming a reading is
-printing a command. The sentence also moved the cycle before, when `run-mutation-arm.py`'s
-refusal for a gate it cannot load gained a runnable remedy
-(`uv run --no-sync python3 scripts/check-merge-plan-suite.py --help`) - a printed command like
-any other, carrying the runner like any other. Two of the others are new in one
+(`uv run --no-sync python3 scripts/check-merge-freshness.py <PR>`), and naming a reading is
+printing a command. Two of the others are new in one
 afternoon and both came from a *remedy*: a printed remedy is a printed
 command, so adding one to a tool's repair path moves this number whether or not the author
 was thinking about citations (`review-queue.py`'s no-verdict row, and the reason
@@ -122,14 +115,11 @@
 other one stale.
 
 **Docstrings are excluded**, and the reason is measured rather than assumed. The docstrings
-of `scripts/*.py` hold **65** mentions of that shape, far more than the strings the code
-prints hold, and the 9 bare ones among them are the family *naming* its readings rather
-than offering commands: four comparisons to a sibling's rule ("in the same shape as
-`scripts/bump-version.py --check`"), three usage lines in `llm-cost-report.py` (a file that
-never hands its docstring to the parser), one transcript line in `cast-vote.py`
-(`scripts/check-vote-count.py 1255`, the reading a reviewer is shown getting), and one
-argument value that merely looks like a command (`--file scripts/check-pr-base.py` in
-`run-mutation-arm.py`'s usage block). A rule keyed on command *shape* cannot tell a name from
+of `scripts/*.py` hold **68** mentions of that shape, far more than the strings the code
+prints hold, and the bare ones among them are the family *naming* its readings rather
+than offering commands: comparisons to a sibling's rule ("in the same shape as
+`scripts/bump-version.py --check`") and one transcript line in `cast-vote.py`
+(`scripts/check-vote-count.py 1255`, the reading a reviewer is shown getting). A rule keyed on command *shape* cannot tell a name from
 a command, and one that fired on those would be firing on the explanations it stands beside.
 So this clause reads the strings a tool hands a reader, and leaves the prose alone.
 
diff --git a/tests/test_recover_worktree.py b/tests/test_recover_worktree.py
deleted file mode 100644
index 61e49591..00000000
--- a/tests/test_recover_worktree.py
+++ /dev/null
@@ -1,1580 +0,0 @@
-"""The reconstructible-dirt criterion and `scripts/recover-worktree.py` (#1237).
-
-The guard's contract is "a cycle must not destroy work that exists nowhere else".
-These pin the two halves: dirt that IS unique is **pinned** (`refs/emrg/rescue/`) and
-converged — the exit from the absorbing state of #1465, which the older contract bought by
-refusing to touch the tree at all — and dirt that is NOT unique is converged
-**reversibly**, the scenario the measured 33-cycle deadlock was made of, built here as a
-real repository.
-"""
-
-from __future__ import annotations
-
-import ast
-import importlib.util
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-SCRIPT = Path(__file__).resolve().parent.parent / "scripts" / "recover-worktree.py"
-DOC = Path(__file__).resolve().parent.parent / "DEVELOPMENT.md"
-SCHEDULER = Path(__file__).resolve().parent.parent / "emrg" / "server" / "scheduler.py"
-
-#: The one owner of the undo spelling (issue #1284), imported rather than re-spelled:
-#: a test that copies the string it is checking cannot see the copy drift. Both
-#: printers in the tree — the daemon's receipt and the manual tool's fallback — are
-#: asserted against this function, so the only way to change the spelling is to
-#: change it in one place, and the only thing left to assert *about* it is which
-#: stash it names and that `--index` is in it.
-from emrg.server.scheduler import recovery_recipe  # noqa: E402  (repo root is on sys.path)
-
-#: The recovery bullet whose prose is the reader-facing undo recipe. Its opening
-#: words are the anchor, not a line number: the section is re-wrapped and
-#: re-numbered by edits that have nothing to do with the recipe, and the anchor is
-#: asserted to appear exactly once so a renamed bullet fails instead of silently
-#: measuring a different paragraph.
-_RECIPE_BULLET = "- **stashes it when it is reconstructible**"
-
-
-def _recovery_bullet() -> str:
-    """That bullet as one paragraph, with its markdown line breaks collapsed."""
-    text = DOC.read_text(encoding="utf-8")
-    found = text.count(_RECIPE_BULLET)
-    assert found == 1, (
-        f"expected exactly one `{_RECIPE_BULLET}` bullet in {DOC.name}, found {found}"
-        " — the anchor moved, so this test would be measuring a different paragraph"
-    )
-    rest = text.split(_RECIPE_BULLET, 1)[1]
-    end = rest.find("\n- ")  # the bullet ends at the next top-level item
-    assert end != -1, f"`{_RECIPE_BULLET}` is the last bullet in {DOC.name}"
-    return " ".join(rest[:end].split())
-
-
-#: The document's *second* statement of the undo, in the `-f` discussion rather than
-#: in the recovery bullet: it tells a reader who has untracked-only dirt to reach for
-#: `git stash -u`, and how to come back (`git stash apply --index`). Named by its
-#: opening words, not a line number, and asserted to appear exactly once so a moved
-#: paragraph fails instead of silently measuring a different one.
-_RECIPE_CAVEAT = "`-f` is the right tool for tracked modifications only."
-
-
-def _recovery_caveat() -> str:
-    """That paragraph as one string, with its markdown line breaks collapsed."""
-    text = DOC.read_text(encoding="utf-8")
-    found = text.count(_RECIPE_CAVEAT)
-    assert found == 1, (
-        f"expected exactly one `{_RECIPE_CAVEAT}` paragraph in {DOC.name}, found "
-        f"{found} — the anchor moved, so this test would be measuring a different "
-        "paragraph"
-    )
-    rest = text.split(_RECIPE_CAVEAT, 1)[1]
-    end = rest.find("\n\n")  # the paragraph ends at the blank line
-    assert end != -1, f"`{_RECIPE_CAVEAT}` is the last paragraph in {DOC.name}"
-    return " ".join((_RECIPE_CAVEAT + rest[:end]).split())
-
-
-def _load():
-    spec = importlib.util.spec_from_file_location("recover_worktree", SCRIPT)
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def _git(repo: Path, *args: str):
-    return subprocess.run(
-        ["git", "-C", str(repo), *args], capture_output=True, text=True, timeout=30,
-        # The guard's rule, and the reason for it: a text-mode subprocess without
-        # an explicit encoding decodes with the *host* locale codec, so it raises or
-        # mojibakes on cp936/cp1252 for data that is valid UTF-8 (issue #1132).
-        encoding="utf-8", errors="replace",
-    )
-
-
-def _status(repo: Path) -> str:
-    return _git(repo, "status", "--porcelain").stdout
-
-
-def _rescue_ref(repo: Path) -> str:
-    """The pin that holds the worktree's bytes — the plain ref, not the `-head` one."""
-    out = _git(repo, "for-each-ref", "--format=%(refname)", "refs/emrg/rescue/")
-    refs = [r for r in out.stdout.split() if r and not r.endswith("-head")]
-    assert len(refs) == 1, f"expected exactly one rescue pin, found {refs}"
-    return refs[0]
-
-
-def _assert_unique_dirt_is_pinned_not_refused(repo: Path) -> str:
-    """The contract for work found nowhere else, since the exit from issue #1465.
-
-    This replaces the assertion `status == "refused"` at every site that used it, and the
-    reason it is a *replacement* rather than a deletion is the whole point of the change.
-    What those assertions were protecting — "the bytes must survive" — is still asserted
-    here, and asserted harder: the dirt must round-trip. What they also asserted, and what
-    must not survive, is that the daemon declines to touch the tree at all — because the
-    refusal arrived with `read-only`, and that tier refuses the git verbs that would
-    converge the tree, so the cycle could neither clean it nor leave (measured on this
-    host: 10/10 mutators blocked, `pytest` unable to start). Host directive 2026-09-23:
-    a dirty tree must clean itself up, it must not get stuck.
-
-    So three things, where the old test asserted one:
-      1. the action converges the tree (`"recovered"`, promoted to a PIN — not "refused");
-      2. the tree is left genuinely clean;
-      3. the pin restores the *exact* original dirt, index side included, so nothing that
-         was in the tree is missing from anywhere git can reach.
-    """
-    before = _status(repo)
-    assert before.strip(), "precondition: this test is about a dirty tree"
-
-    status, detail = _load().TaskHandler._recover_dirty_tree_sync(str(repo))
-    assert status == "recovered", f"{status}: {detail}"
-    assert "PINNED" in detail, f"the promoted outcome must name the pin: {detail}"
-    assert _status(repo) == "", f"the convergence must leave a clean tree: {_status(repo)!r}"
-
-    ref = _rescue_ref(repo)
-    assert _git(repo, "rev-parse", "--verify", "--quiet", ref).stdout.strip() == (
-        _git(repo, "rev-parse", ref).stdout.strip()
-    ), ref
-
-    applied = _git(repo, "stash", "apply", "--index", ref)
-    # The exit code is not the verdict — the state is, and this is measured rather than
-    # assumed. On the `D ??` geometry (a staged deletion *and* an untracked file at the
-    # same path, which is one of this file's most-regressed shapes) git restores the dirt
-    # **exactly** and still exits 1 with "f.txt already exists, no checkout / error: could
-    # not restore untracked files from stash", because the untracked side was already
-    # provided by the other tree. Asserting rc == 0 there would fail a correct restore;
-    # asserting the bytes cannot. #464's lesson ("test the output, not the exit code")
-    # arriving in a third place — and the direction stays fail-closed, since a wrong state
-    # fails whatever the exit code said.
-    assert _status(repo) == before, (
-        f"the pin must restore the exact dirt (git returned rc={applied.returncode}: "
-        f"{(applied.stderr or applied.stdout).strip()!r}); "
-        f"got {_status(repo)!r} != {before!r}"
-    )
-    return ref
-
-
-def _new_repo(path: Path, content: str = "v1", name: str = "f.txt") -> None:
-    """A one-commit repository. `-b master` because the criterion's upstream ref is
-    the default branch, and a test whose branch name drifts would measure nothing.
-
-    ``name`` exists because the criterion's defects are about *paths*: `git status`
-    quotes some names and not others, so a geometry has to be buildable at the name
-    that triggers the quoting (`add -A` rather than a literal name keeps that possible
-    for a name beginning with a space or a dash).
-    """
-    path.mkdir(parents=True, exist_ok=True)
-    _git(path, "init", "-q", "-b", "master")
-    _git(path, "config", "user.email", "t@t.t")
-    _git(path, "config", "user.name", "t")
-    (path / name).write_text(content, encoding="utf-8")
-    _git(path, "add", "-A")
-    _git(path, "commit", "-q", "-m", "base")
-
-
-def _with_upstream(tmp_path: Path, name: str = "f.txt"):
-    """The deadlock's exact shape: HEAD behind, worktree carrying upstream's bytes.
-
-    Measures `(repo, head_sha)`: the tree is dirty (one modified tracked file) and
-    holds **no unique work at all** — the file's bytes are the upstream tip's blob.
-    Of the 33 lost cycles, this was the state of the working tree.
-    """
-    origin = tmp_path / "origin.git"
-    subprocess.run(
-        ["git", "init", "-q", "--bare", "-b", "master", str(origin)],
-        capture_output=True, text=True, timeout=30,
-        encoding="utf-8", errors="replace",
-    )
-    work = tmp_path / "work"
-    _new_repo(work, "v1", name)
-    _git(work, "remote", "add", "origin", str(origin))
-    _git(work, "push", "-q", "-u", "origin", "master")
-    head = _git(work, "rev-parse", "HEAD").stdout.strip()
-    (work / name).write_text("v2", encoding="utf-8")
-    _git(work, "commit", "-q", "-am", "v2")
-    _git(work, "push", "-q", "origin", "master")
-    _git(work, "reset", "-q", "--hard", head)      # HEAD back to v1 …
-    (work / name).write_text("v2", encoding="utf-8")  # … worktree at upstream's v2
-    assert _status(work).startswith(" M"), _status(work)
-    return work, head
-
-
-# ── the criterion itself, against real repositories ──────────────────────────
-
-
-def test_dirt_carrying_upstreams_bytes_is_reconstructible(tmp_path):
-    """False = nothing would be lost. This is the case that cost 33 cycles."""
-    work, _ = _with_upstream(tmp_path)
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(work))
-    assert loses is False, why
-    # The reason now **names the ref** that carries those bytes instead of a fixed
-    # phrase about "the upstream tip" (issue #1338): with every ref tip as a candidate,
-    # "already published" is only evidence if it says where, and here the publisher is
-    # the remote-tracking ref the push wrote.
-    assert "origin/master" in why, why
-
-
-def test_a_modification_found_nowhere_is_unique(tmp_path):
-    """The real protection, in the other direction: nothing upstream holds these bytes."""
-    _new_repo(tmp_path / "repo", "v1")
-    repo = tmp_path / "repo"
-    (repo / "f.txt").write_text("host's unreleased work", encoding="utf-8")
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True
-    assert "f.txt" in why
-
-
-@pytest.mark.parametrize("ref", [
-    "refs/tags/published",
-    "refs/remotes/origin/fix/x",
-    "refs/cdrain/pr9999",
-])
-def test_a_modification_published_in_another_ref_is_recoverable(tmp_path, ref):
-    """The third place a blob can live, and the one a cycle's own workflow fills (#1338).
-
-    The criterion asked `HEAD` and the upstream tip, so a blob published at this path in
-    *any other* ref still read as unique: measured 2026-09-17, a cycle's own four staged
-    files were byte-identical to the head of a branch it had just pushed and the next
-    cycle was pinned read-only anyway — with no route out, because the recovery refuses
-    on the same criterion, the landing-tree route needs `git worktree add`, and refreshing
-    needs `git merge` + `git push`.
-
-    Parametrised over the three shapes that actually occur, because the discovery
-    (`for-each-ref`) is not tag-specific and a fix that only consulted tags would pass one
-    arm of this and pin the other two: a tag, a remote-tracking branch, and the
-    `refs/cdrain/prNNNN` tips this workspace's own tooling writes.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo, "v1")
-    (repo / "f.txt").write_text("v2", encoding="utf-8")
-    _git(repo, "commit", "-q", "-am", "v2")
-    _git(repo, "update-ref", ref, "HEAD")
-    _git(repo, "reset", "-q", "--hard", "HEAD~1")          # HEAD back to v1 …
-    (repo / "f.txt").write_text("v2", encoding="utf-8")    # … worktree at the ref's bytes
-    assert _status(repo).startswith(" M"), _status(repo)
-
-    blob = _git(repo, "hash-object", "--", "f.txt").stdout.strip()
-    assert _git(repo, "rev-parse", "HEAD:f.txt").stdout.strip() != blob, (
-        "precondition: HEAD does not hold these bytes — the geometry the criterion "
-        "used to call unique"
-    )
-    assert _git(repo, "rev-parse", f"{ref}:f.txt").stdout.strip() == blob, (
-        "precondition: the bytes are published at this path in the ref under test"
-    )
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is False, why
-    assert ref in why, f"the evidence has to name the ref it matched: {why!r}"
-
-    # And the action obeys the verdict, reversibly: the tier is only released so the
-    # cycle can converge its own tree, so the convergence has to actually work here.
-    head = _git(repo, "rev-parse", "HEAD").stdout.strip()
-    status, detail = _load().TaskHandler._recover_dirty_tree_sync(str(repo))
-    assert status == "recovered", f"{status}: {detail}"
-    assert _status(repo) == ""
-    assert _git(repo, "rev-parse", "HEAD").stdout.strip() == head
-    assert _git(repo, "rev-parse", f"{ref}:f.txt").stdout.strip() == blob, (
-        "the ref that carried the bytes must not be moved by a recovery"
-    )
-
-
-def test_a_modification_only_in_an_older_commit_is_still_unique(tmp_path):
-    """The widened clause asks **ref tips**, and this pins that it is a decision.
-
-    A blob recorded at this path in an *older* commit of some branch is reachable —
-    `git log --all --find-object` finds it — but it is not what the new rule admits, and
-    the case is worth a test precisely because the looser rule would feel natural. Asking
-    for reachability instead of tips means running a full-history object walk per path on
-    the tier it is deciding about, and buys only a direction that cannot be wrong: naming
-    this unique merely keeps the cycle read-only, which is what it was before. Fail-closed
-    is the contract (see the docstring's closing paragraph), so the limitation is asserted
-    rather than left to be rediscovered as a bug.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo, "v1")
-    (repo / "f.txt").write_text("v2", encoding="utf-8")
-    _git(repo, "commit", "-q", "-am", "v2")
-    (repo / "f.txt").write_text("v3", encoding="utf-8")
-    _git(repo, "commit", "-q", "-am", "v3")
-    _git(repo, "update-ref", "refs/tags/published", "HEAD")  # the tag *tips* at v3
-    _git(repo, "reset", "-q", "--hard", "HEAD~2")            # HEAD back to v1
-    (repo / "f.txt").write_text("v2", encoding="utf-8")
-    assert _status(repo).startswith(" M"), _status(repo)
-
-    blob = _git(repo, "hash-object", "--", "f.txt").stdout.strip()
-    reachable = _git(repo, "log", "--all", "--oneline", f"--find-object={blob}")
-    assert reachable.stdout.strip(), (
-        "precondition: the bytes *are* in an older commit — the criterion asks for tips"
-    )
-    assert _git(repo, "rev-parse", "refs/tags/published:f.txt").stdout.strip() != blob, (
-        "precondition: the tag's tip does not hold them"
-    )
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True, why
-    assert "f.txt" in why
-
-
-def test_an_untracked_file_is_unique(tmp_path):
-    """Untracked content exists in exactly one place, so it is never reconstructible."""
-    _new_repo(tmp_path / "repo")
-    repo = tmp_path / "repo"
-    (repo / "notes.md").write_text("only here", encoding="utf-8")
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True
-    assert "notes.md" in why
-
-
-def test_an_untracked_file_is_unique_even_when_upstream_has_those_bytes(tmp_path):
-    """The clause that decides this case: "untracked == 0" is a precondition.
-
-    Found by mutation (removing the `??` fast path changed no existing answer —
-    the content comparison reaches the same verdict for a file git never tracked).
-    That is not true here: when the path is *absent from HEAD* but present in the
-    upstream tip, the content comparison finds a matching blob and would release
-    the file, while the criterion says otherwise. An untracked file is content git
-    has never tracked, so it is the host's by construction; releasing it because a
-    copy was published once would discard a file the host created. Conservative by
-    design, and the safe side: naming it unique only refuses.
-    """
-    origin = tmp_path / "origin.git"
-    subprocess.run(
-        ["git", "init", "-q", "--bare", "-b", "master", str(origin)],
-        capture_output=True, text=True, timeout=30,
-        encoding="utf-8", errors="replace",
-    )
-    repo = tmp_path / "repo"
-    _new_repo(repo, "v1")
-    _git(repo, "remote", "add", "origin", str(origin))
-    _git(repo, "push", "-q", "-u", "origin", "master")
-    head = _git(repo, "rev-parse", "HEAD").stdout.strip()
-    (repo / "b.txt").write_text("published elsewhere", encoding="utf-8")
-    _git(repo, "add", "b.txt")
-    _git(repo, "commit", "-q", "-m", "b")
-    _git(repo, "push", "-q", "origin", "master")
-    _git(repo, "reset", "-q", "--hard", head)   # b.txt now exists only upstream
-    (repo / "b.txt").write_text("published elsewhere", encoding="utf-8")  # untracked again
-    assert _status(repo).strip() == "?? b.txt", _status(repo)
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True, "untracked content is never reconstructible"
-    assert "b.txt" in why
-
-
-def test_an_untracked_file_is_unique_even_when_a_tag_has_those_bytes(tmp_path):
-    """The widened clause stops at the `??` branch, and this is that boundary (#1338).
-
-    "Which refs publish these bytes" is a widening about *tracked* content: a
-    modification or a staged change is a change to a path git knows, so finding its
-    bytes at that path in some ref is evidence of a re-checkout. An untracked path is
-    one git does not track now, so the same match is not evidence about the host's file
-    — a copy published once under a tag does not make the host's copy recoverable, and
-    the criterion still says so (#1277). The test exists because the leak's direction is
-    the dangerous one: leaking the widening into the `??` branch releases the tier over
-    a file the host wrote, and every other test in this file would still pass.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo, "v1")
-    (repo / "b.txt").write_text("published once", encoding="utf-8")
-    _git(repo, "add", "b.txt")
-    _git(repo, "commit", "-q", "-m", "b")
-    _git(repo, "update-ref", "refs/tags/published", "HEAD")
-    _git(repo, "reset", "-q", "--hard", "HEAD~1")   # b.txt exists only in the tag now
-    (repo / "b.txt").write_text("published once", encoding="utf-8")   # untracked again
-    assert _status(repo).strip() == "?? b.txt", _status(repo)
-    assert _git(repo, "rev-parse", "refs/tags/published:b.txt").stdout.strip() == (
-        _git(repo, "hash-object", "--", "b.txt").stdout.strip()
-    ), "precondition: another ref publishes these very bytes at this very path"
-    assert _git(repo, "rev-parse", "--verify", "--quiet", "HEAD:b.txt").returncode != 0, (
-        "precondition: the path is absent from HEAD — the distinction from "
-        "test_an_untracked_copy_of_head_is_recoverable"
-    )
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True, why
-    assert "b.txt" in why
-
-
-def test_an_untracked_copy_of_head_is_recoverable(tmp_path):
-    """`git rm --cached f` on unchanged content: `D  f` *and* `?? f` for one path (#1277).
-
-    The `??` line used to name the path unique before anything was hashed, so a tree
-    that loses nothing stayed read-only and the git verbs that could converge it stayed
-    refused. The bytes are `HEAD`'s own, under that same name — which is the whole
-    distinction from `test_an_untracked_file_is_unique_even_when_upstream_has_those_bytes`
-    above: content published once at this path but absent from `HEAD` is the host's file.
-
-    This geometry also measures something about the reversal that the receipt's own
-    wording does not cover, pinned below rather than left as a surprise: the named
-    inverse *works* and *exits 1* on it. That is the undo/audit half, filed in #1284.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo, "unchanged")
-    _git(repo, "rm", "-q", "--cached", "f.txt")
-    assert _status(repo) == "D  f.txt\n?? f.txt\n", _status(repo)
-    # The precondition that makes releasing the tier lossless, asserted rather than
-    # assumed: the untracked bytes are byte-identical to `HEAD`'s blob for this path,
-    # so they are reachable from a commit — the measurement #1277 reports, and the one
-    # that separates this case from a file the host wrote.
-    digest = _git(repo, "hash-object", "--", "f.txt").stdout.strip()
-    assert digest == _git(repo, "rev-parse", "HEAD:f.txt").stdout.strip()
-    assert _git(repo, "log", "--all", "--oneline", f"--find-object={digest}").stdout.strip()
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is False, why
-
-    # And the action obeys that verdict, reversibly, with `HEAD` where it was.
-    head = _git(repo, "rev-parse", "HEAD").stdout.strip()
-    status, detail = _load().TaskHandler._recover_dirty_tree_sync(str(repo))
-    assert status == "recovered", f"{status}: {detail}"
-    assert _status(repo) == ""
-    assert _git(repo, "rev-parse", "HEAD").stdout.strip() == head
-
-    # The inverse the receipt names, run as named: the receipt names the entry
-    # `git stash list` prints, and this repository has exactly one stash, so the list
-    # prints `stash@{0}`. What this geometry does to it is *measured*, not assumed
-    # (the residual is a finding, filed with the undo/audit half in #1284, not
-    # something to wish away here): the state comes back byte for byte — deletion
-    # still staged, file still untracked — while git exits **1** and warns `f.txt
-    # already exists, no checkout`, having restored the untracked copy already by the
-    # time it tries again. The stash is consequently *kept*, so the one-shot
-    # spelling's evidence is not consumed either (measured: `pop --index` reports the
-    # same failure and keeps the entry here).
-    receipt = json.loads(
-        (Path(_git(repo, "rev-parse", "--absolute-git-dir").stdout.strip())
-         / "emrg-recovery-receipt.json").read_text(encoding="utf-8")
-    )
-    listing = _git(repo, "stash", "list").stdout
-    index = next(
-        ln.split(":")[0].split("{")[1].rstrip("}")
-        for ln in listing.splitlines()
-        if ln.endswith(receipt["stash_message"])
-    )
-    applied = _git(repo, "stash", "apply", "--index", f"stash@{{{index}}}")
-    assert "already exists, no checkout" in applied.stderr, applied.stderr
-    assert _status(repo) == "D  f.txt\n?? f.txt\n", _status(repo)
-    assert _git(repo, "stash", "list").stdout.strip() != "", \
-        "the reversal must not consume the stash it is named by"
-    assert _git(repo, "rev-parse", "HEAD").stdout.strip() == head
-
-
-def test_an_untracked_copy_of_head_with_other_bytes_is_unique(tmp_path):
-    """The control for the clause above: the measurement is of the bytes, not the gesture.
-
-    The same `git rm --cached` shape with edited content — the host's newer draft — exists
-    in no commit, so the criterion must call it unique and the draft must survive the
-    action. Since #1465's exit "survive" means the pin round-trips it, not that the tree
-    is left alone (see `_assert_unique_dirt_is_pinned_not_refused`).
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo, "unchanged")
-    _git(repo, "rm", "-q", "--cached", "f.txt")
-    (repo / "f.txt").write_text("the host's newer draft", encoding="utf-8")
-    assert _status(repo) == "D  f.txt\n?? f.txt\n", _status(repo)
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True, why
-    assert "f.txt" in why
-
-    _assert_unique_dirt_is_pinned_not_refused(repo)
-    assert (repo / "f.txt").read_text(encoding="utf-8") == "the host's newer draft"
-
-
-def test_an_untracked_file_duplicating_another_path_is_unique(tmp_path):
-    """Path-exactness: a blob with these bytes at *another* path is not evidence about this file.
-
-    The tempting looser test — "some blob with these bytes is in a commit" — releases the
-    tier here, over a file the host wrote; only `HEAD:<this path>` counts. Pinned because
-    the temptation is concrete: the duplication is measurable with one `hash-object` and
-    the shortcut would have passed every other test in this file.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo)
-    (repo / "other.txt").write_text("v1", encoding="utf-8")
-    _git(repo, "add", "other.txt")
-    _git(repo, "commit", "-q", "-m", "other")
-    assert (
-        _git(repo, "rev-parse", "HEAD:other.txt").stdout.strip()
-        == _git(repo, "hash-object", "--", "other.txt").stdout.strip()
-    )
-    (repo / "fresh.txt").write_text("v1", encoding="utf-8")   # same bytes, a new path
-    assert _status(repo).strip() == "?? fresh.txt", _status(repo)
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True, why
-    assert "fresh.txt" in why
-
-
-def test_a_deletion_loses_nothing(tmp_path):
-    """A deleted tracked file is restored by discarding, so it is not unique work."""
-    _new_repo(tmp_path / "repo")
-    repo = tmp_path / "repo"
-    (repo / "f.txt").unlink()
-    assert _status(repo).startswith(" D"), _status(repo)
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is False, why
-
-
-def test_a_staged_deletion_loses_nothing(tmp_path):
-    """The same verdict on the *index* side of a deletion (`D `, not ` D`).
-
-    Pinned because the clause that skips deletions was narrowed from `"D" in code`
-    to the two sides that actually lose nothing. `D ` is the case that a careless
-    narrowing drops: the worktree copy is gone as well, so a check that looked for a
-    worktree blob would answer "could not be read to compare" and refuse a tree that
-    loses nothing. Both spellings are deletions; both must stay recoverable.
-    """
-    _new_repo(tmp_path / "repo")
-    repo = tmp_path / "repo"
-    _git(repo, "rm", "-q", "--cached", "f.txt")
-    (repo / "f.txt").unlink()
-    assert _status(repo) == "D  f.txt\n", _status(repo)
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is False, why
-
-
-def test_staged_content_the_worktree_cannot_evidence_is_unique(tmp_path):
-    """`MM`: staged, then the worktree copy reverted to HEAD (review of #1274).
-
-    The worktree blob *is* HEAD's, so a measurement that reads only the worktree
-    answers "recoverable" — while the staged blob is in no commit at all, and a plain
-    `git stash pop` then drops it as an unreferenced object (measured: the index went
-    back to HEAD's blob and the unique bytes became unreachable). The criterion must
-    measure the index side too.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo)
-    (repo / "f.txt").write_text("STAGED-ONLY-UNIQUE", encoding="utf-8")
-    _git(repo, "add", "f.txt")
-    (repo / "f.txt").write_text("v1", encoding="utf-8")   # back to HEAD's own bytes
-    assert _status(repo) == "MM f.txt\n", _status(repo)
-
-    staged = _git(repo, "rev-parse", ":f.txt").stdout.strip()
-    reachable = _git(repo, "log", "--all", "--oneline", f"--find-object={staged}")
-    assert reachable.stdout.strip() == "", "precondition: the staged blob is in no commit"
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True, why
-    assert "staged" in why, why
-
-    # And the action obeys that verdict: the worktree side must not be the thing the
-    # convergence relies on — the index side is pinned with it (the pin is a stash, whose
-    # `--index` half exists for exactly this shape; the round-trip is asserted by the
-    # helper below, and the staged blob is re-read here to name the half that was at risk).
-    ref = _assert_unique_dirt_is_pinned_not_refused(repo)
-    assert _git(repo, "rev-parse", ":f.txt").stdout.strip() == staged, \
-        "the pin must restore the staged blob into the index"
-    assert _git(repo, "rev-parse", ref).stdout.strip() != "", ref
-
-
-def test_staged_content_with_no_worktree_copy_is_unique(tmp_path):
-    """`MD`: staged, then the worktree copy removed — the same hole, other spelling.
-
-    The worktree cannot evidence the index here for a different reason (there is no
-    worktree blob at all), which is why the deletion clause had to be narrowed rather
-    than left to skip anything containing a `D`.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo)
-    (repo / "f.txt").write_text("STAGED-ONLY-UNIQUE", encoding="utf-8")
-    _git(repo, "add", "f.txt")
-    (repo / "f.txt").unlink()
-    assert _status(repo) == "MD f.txt\n", _status(repo)
-
-    staged = _git(repo, "rev-parse", ":f.txt").stdout.strip()
-    assert _git(repo, "log", "--all", "--oneline",
-                f"--find-object={staged}").stdout.strip() == ""
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True, why
-    assert "staged" in why, why
-
-
-def test_staged_content_upstream_already_holds_is_recoverable(tmp_path):
-    """The other direction: the index clause must not refuse published content.
-
-    Both states carry an index blob that equals the **upstream tip's** blob for that
-    path, so discarding loses nothing (the bytes are in a commit anyone can reach).
-    A clause that refused every staged change would trade the #1274 hole for the
-    over-block class #1273 tracks — the two are not interchangeable.
-    """
-    for kind in ("mm", "md"):
-        work, _head = _with_upstream(tmp_path / kind)
-        published = _git(work, "rev-parse", "origin/master:f.txt").stdout.strip()
-        # Stage upstream's own blob for that path (HEAD still holds v1's).
-        staged = _git(work, "update-index", "--cacheinfo", f"100644,{published},f.txt")
-        assert staged.returncode == 0, staged.stderr
-        if kind == "md":
-            (work / "f.txt").unlink()
-        else:
-            # Back to HEAD's bytes, so the worktree cannot evidence the index either —
-            # the same `MM` geometry as the unique case above, differing only in
-            # whether a commit already holds the staged blob.
-            (work / "f.txt").write_text(
-                _git(work, "show", "HEAD:f.txt").stdout, encoding="utf-8"
-            )
-        assert _status(work) == f"{'MM' if kind == 'mm' else 'MD'} f.txt\n", _status(work)
-
-        loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(work))
-        assert loses is False, f"{kind}: {why}"
-
-
-# ── the path, not git's rendering of it ──────────────────────────────────────
-
-
-@pytest.mark.parametrize("name", ["a b.txt", "文档.txt", " leading.txt"])
-def test_a_modification_at_a_quoted_path_is_recoverable(tmp_path, name):
-    """`git status --porcelain` *quotes* these names, and the quotes are not the path.
-
-    The criterion took its path from that rendering, so every comparison it makes
-    (`hash-object -- <path>`, `HEAD:<path>`, `<upstream>:<path>`) was asked about a
-    name containing literal quote characters, could not resolve, and the walk answered
-    *unique*. Measured on the merged tree before this test: the ` M` geometry whose
-    bytes are the upstream tip's — the 33-cycle deadlock shape — was **refused** for
-    `a b.txt` and for `文档.txt`, i.e. the guard re-imposed the deadlock on any host
-    whose filenames are not all ASCII.
-
-    The three names cover the three ways to need quoting: a space, a byte > 0x7f
-    (octal-escaped under the default `core.quotePath=true`), and a *leading* space,
-    which additionally pins that the path is taken verbatim rather than stripped.
-    """
-    work, head = _with_upstream(tmp_path, name)
-    assert '"' in _status(work), f"precondition: git quotes this name: {_status(work)!r}"
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(work))
-    assert loses is False, f"{name!r}: {why}"
-
-    status, detail = _load().TaskHandler._recover_dirty_tree_sync(str(work))
-    assert status == "recovered", f"{status}: {detail}"
-    assert _status(work) == ""
-    assert _git(work, "rev-parse", "HEAD").stdout.strip() == head, "HEAD must not move"
-    # Converging means the tree is at HEAD again, so the file *is* v1 now: the v2 bytes
-    # live in the upstream tip's commit (that is why releasing this tree loses nothing)
-    # and in the stash. Both spellings are asserted rather than assumed.
-    assert (work / name).read_text(encoding="utf-8") == "v1"
-    _git(work, "stash", "pop")
-    assert (work / name).read_text(encoding="utf-8") == "v2"
-
-
-def test_a_modification_at_a_quoted_path_holding_unique_work_is_unique(tmp_path):
-    """The other direction: reading the real path must not become a way to release work.
-
-    With the path finally resolvable, the content comparison *can* answer, and for
-    content that is in no commit it must still refuse — the clause this test guards is
-    the same one the fix touches.
-    """
-    name = "a b.txt"
-    repo = tmp_path / "repo"
-    _new_repo(repo, "v1", name)
-    (repo / name).write_text("the host's unreleased work", encoding="utf-8")
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True, why
-    assert name in why
-
-    status, detail = _load().TaskHandler._recover_dirty_tree_sync(str(repo))
-    assert status == "recovered" and "PINNED" in detail, detail
-    # The dirt is in the pin now, so the file reads as `HEAD` again until it is replayed —
-    # asserted in that order because "the file still has the host's bytes in the worktree"
-    # would be the *stale* claim: the point is that the bytes survive, not where they sit.
-    _git(repo, "stash", "apply", "--index", _rescue_ref(repo))
-    assert (repo / name).read_text(encoding="utf-8") == "the host's unreleased work"
-
-
-def test_an_untracked_file_at_a_quoted_path_names_its_own_path(tmp_path):
-    """The reported reason has to name the path, not the rendering.
-
-    On the pre-fix tree this reason was `"host notes.md" exists only in this checkout`
-    — the message a human reads when the guard refuses their cycle named a filename
-    with quotes in it, which is not a file they can go and look at.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo)
-    (repo / "host notes.md").write_text("only here", encoding="utf-8")
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True, why
-    # Exact, not a substring: on the pre-fix tree the reason was
-    # `"host notes.md" exists only in this checkout` — a filename with quotes in it,
-    # which is not a file the host can go and look at.
-    assert why == "host notes.md exists only in this checkout", why
-
-
-def test_a_rename_is_unique_and_its_origin_is_not_walked(tmp_path):
-    """`R` spends **two** NUL fields in `-z` mode; only the first is an entry.
-
-    Walking the origin field as an entry reads its first two characters as a status,
-    which lands it in the staged clause and reports a filename nobody has — measured by
-    mutation: without the consumption this reason becomes `ig name.txt is staged with
-    content that is in neither HEAD nor the upstream tip`. The assertion on the origin
-    path's absence is therefore the discriminator, not the verdict (which is *unique*
-    either way).
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo, "v1", "orig name.txt")
-    _git(repo, "mv", "orig name.txt", "moved name.txt")
-    assert _status(repo).startswith("R"), _status(repo)
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True
-    # Exact, and that is what carries the evidence: on the pre-fix tree this reason is
-    # the v1 rendering (`"orig name.txt" -> "moved name.txt" was renamed`), and with the
-    # origin field walked as an entry it gains a **second** clause naming `ig name.txt`
-    # (the first two characters eaten as a status). One equality pins both.
-    assert why == "moved name.txt was renamed", why
-
-
-def test_every_entry_is_walked_when_one_of_them_is_quoted(tmp_path):
-    """Both entries must be measured, which is what a NUL-field parse can get wrong.
-
-    A parse that consumes one field too many per entry drops the second one — and a
-    dropped entry is not a *refusal*, it is content the walk never looked at, so the
-    verdict here would flip from unique to recoverable. (This is the failure the
-    origin-field rule above is narrow against; the geometry keeps one entry that is
-    already upstream's and one that is unique, so the unique one has to govern.)
-    """
-    root = tmp_path / "both"
-    work, _head = _with_upstream(root, "plain.txt")
-    (work / "host notes.md").write_text("only here", encoding="utf-8")
-    assert _status(work).count("\n") == 2, _status(work)
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(work))
-    assert loses is True, why
-    assert "host notes.md" in why, why
-    _assert_unique_dirt_is_pinned_not_refused(work)
-
-
-def test_a_commit_only_on_this_branch_is_unique(tmp_path):
-    """A branch reset would orphan it: dirty *and* ahead is never reconstructible."""
-    origin = tmp_path / "origin.git"
-    subprocess.run(
-        ["git", "init", "-q", "--bare", "-b", "master", str(origin)],
-        capture_output=True, text=True, timeout=30,
-        encoding="utf-8", errors="replace",
-    )
-    repo = tmp_path / "repo"
-    _new_repo(repo)
-    _git(repo, "remote", "add", "origin", str(origin))
-    _git(repo, "push", "-q", "-u", "origin", "master")
-    _git(repo, "commit", "-q", "--allow-empty", "-m", "local only")
-    (repo / "f.txt").write_text("v2", encoding="utf-8")
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is True
-    # "In this checkout", not "on this branch": the clause now differs HEAD against
-    # every ref tip *except* this checkout's own branch ref, so what it names is
-    # existence nowhere else — a commit pushed to `refs/remotes/origin/<branch>` is
-    # reachable somewhere else and must not be reported here (see the pushed-branch
-    # test below, which is the same clause read in the other direction).
-    assert "only in this checkout" in why
-
-
-def test_a_branch_already_pushed_is_not_unique(tmp_path):
-    """The second route to the same deadlock (#1338): the commit count, not the blobs.
-
-    Fixing the blob clause alone leaves this one standing. A cycle does its work on a
-    branch and pushes it, then leaves the tree carrying bytes the upstream tip already
-    holds — every *file* recoverable — while `upstream..HEAD` is non-empty by
-    construction, because a branch that has been worked on is ahead of upstream. Read as
-    "work that exists nowhere else" it pins the cycle read-only with exactly the verbs
-    it would need to converge (`merge`, `push`, `worktree add`), which is the same
-    deadlock arriving by a second route.
-
-    So the clause now differs HEAD against every ref tip *except* this checkout's own two
-    self-references. A commit published in `refs/remotes/origin/<branch>` is elsewhere and
-    does not count; a commit nobody else has still does — that direction is pinned by
-    `test_a_commit_only_on_this_branch_is_unique` above, which is this same test with the
-    push removed.
-    """
-    origin = tmp_path / "origin.git"
-    subprocess.run(
-        ["git", "init", "-q", "--bare", "-b", "master", str(origin)],
-        capture_output=True, text=True, timeout=30,
-        encoding="utf-8", errors="replace",
-    )
-    repo = tmp_path / "repo"
-    _new_repo(repo, "v1")
-    _git(repo, "remote", "add", "origin", str(origin))
-    _git(repo, "push", "-q", "-u", "origin", "master")
-    _git(repo, "checkout", "-q", "-b", "fix/x")
-    (repo / "f.txt").write_text("v2", encoding="utf-8")
-    _git(repo, "commit", "-q", "-am", "the fix")
-    _git(repo, "push", "-q", "-u", "origin", "fix/x")
-    # Reconstructible dirt: the upstream tip's own bytes for a path HEAD has moved on
-    # from, so the blob clause releases it and only the commit clause could refuse.
-    (repo / "f.txt").write_text("v1", encoding="utf-8")
-    assert _status(repo).startswith(" M"), _status(repo)
-
-    head = _git(repo, "rev-parse", "HEAD").stdout.strip()
-    assert _git(repo, "rev-list", "--count", "origin/master..HEAD").stdout.strip() == "1", (
-        "precondition: the branch is ahead of upstream — what the old clause read"
-    )
-    assert _git(repo, "rev-parse", "refs/remotes/origin/fix/x").stdout.strip() == head, (
-        "precondition: the commit is published under the branch's remote-tracking ref"
-    )
-
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(repo))
-    assert loses is False, why
-    assert "commit(s)" not in why, why
-
-
-def test_a_clean_tree_is_not_dirt(tmp_path):
-    _new_repo(tmp_path / "repo")
-    loses, why = _load().TaskHandler._dirty_tree_would_lose_work_sync(str(tmp_path / "repo"))
-    assert loses is False
-    assert "clean" in why
-
-
-# ── the tool: refuse, converge, stay reversible ──────────────────────────────
-
-
-def test_the_tool_pins_unique_work_and_a_dry_run_still_refuses(tmp_path, capsys):
-    """The file must survive either path, and `--apply` must not need a human first.
-
-    The old shape of this test asserted that the *action* refused, because a refusal was
-    the only way to be sure the work survived. It is not: the survival claim is now made
-    by the pin, which is asserted here, and the refusal that remains is the one that costs
-    nothing — a **dry run** still exits 1 and writes nothing, so a human asking "what is
-    in this tree?" is not answered with a convergence they did not request.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo)
-    (repo / "notes.md").write_text("only here", encoding="utf-8")
-
-    # Dry run: diagnoses, touches nothing, and says what --apply would do.
-    assert _load().recover(repo, apply=False) == 1
-    out = capsys.readouterr().out
-    assert "unique" in out and "PINNED" in out
-    assert (repo / "notes.md").read_text(encoding="utf-8") == "only here"
-    assert _git(repo, "stash", "list").stdout.strip() == "", "a dry run writes nothing"
-    assert not (Path(_git(repo, "rev-parse", "--absolute-git-dir").stdout.strip())
-                / "emrg-recovery-receipt.json").exists()
-
-    # --apply: converges and pins, so the tree is clean *and* the bytes are reachable.
-    assert _load().recover(repo, apply=True) == 0
-    out = capsys.readouterr().out
-    assert "recovered" in out
-    assert _status(repo).strip() == "", "the tool's whole job is a clean tree"
-    ref = _rescue_ref(repo)
-    assert _git(repo, "rev-parse", "--verify", "--quiet", ref).stdout.strip()
-    applied = _git(repo, "stash", "apply", "--index", ref)
-    assert applied.returncode == 0, applied.stderr or applied.stdout
-    assert (repo / "notes.md").read_text(encoding="utf-8") == "only here"
-    assert _status(repo).strip() == "?? notes.md", _status(repo)
-
-
-def test_the_tool_converges_reconstructible_dirt_reversibly(tmp_path, capsys):
-    """The deadlock's state, repaired: clean tree, HEAD unmoved, work recoverable."""
-    work, head = _with_upstream(tmp_path)
-
-    assert _load().recover(work, apply=False) == 0
-    assert "recoverable" in capsys.readouterr().out
-    assert _status(work).startswith(" M"), "a dry run must not change the tree"
-
-    assert _load().recover(work, apply=True) == 0
-    out = capsys.readouterr().out
-    assert "recovered" in out and "reversible" in out
-    assert _status(work).strip() == "", "the tool's whole job is a clean tree"
-    assert _git(work, "rev-parse", "HEAD").stdout.strip() == head, "HEAD must not move"
-
-    # Reversibility is the reason this action is allowed at all: every byte is
-    # still there, one command away.
-    _git(work, "stash", "pop")
-    assert (work / "f.txt").read_text(encoding="utf-8") == "v2"
-
-
-def test_the_tool_writes_a_receipt_of_what_it_moved(tmp_path):
-    """The structural guard's contract: every release of a safety rule is a receipt."""
-    work, head = _with_upstream(tmp_path)
-
-    assert _load().recover(work, apply=True) == 0
-    git_dir = Path(_git(work, "rev-parse", "--absolute-git-dir").stdout.strip())
-    receipt = json.loads(
-        (git_dir / "emrg-recovery-receipt.json").read_text(encoding="utf-8")
-    )
-    # The receipt must not re-dirty the tree it just cleaned — measured while
-    # writing this tool, when the receipt lived beside it.
-    assert _status(work).strip() == "", "the receipt itself must not be dirt"
-
-    assert receipt["repo"] == str(work)
-    assert receipt["head_before"] == head
-    assert receipt["head_after"] == head, "the receipt must show HEAD did not move"
-    assert any(line.startswith(" M") for line in receipt["status_before"])
-    assert receipt["status_after"] == []
-    assert "stash" in receipt["action"]
-    # The spelled route is the one owner's, not a copy of it: this asserts identity
-    # with the shared recipe, so a receipt that drifted from the function (or a
-    # function that drifted from the receipt) fails here rather than in a reader's
-    # shell. The substrings below only say *what* the owner has to contain.
-    assert receipt["reversible_with"] == recovery_recipe(receipt["stash_message"]), (
-        "the receipt must carry the one owner's recipe for *this* stash"
-    )
-    # The route must name *this* stash: a host may already have stashes, so a bare
-    # `git stash pop` is only correct until the next one is made (measured on the
-    # authoring workspace, which held an unrelated `stash@{0}` when this was written).
-    assert receipt["stash_message"] in receipt["reversible_with"]
-    # A stash carries the index side as well, and a plain pop does not restore it:
-    # measured on an index-only change, `stash pop` printed "Already up to date.",
-    # dropped the stash and left the index at HEAD's blob (#1274 review). The
-    # documented inverse must therefore be the `--index` spelling.
-    assert "--index" in receipt["reversible_with"]
-    # The receipt reaches a human who has to decide whether the discard was safe, so
-    # its `reason` has to carry the ref the bytes were found in (issue #1338) — not a
-    # phrase that would read the same whether or not anything held them.
-    assert "origin/master" in receipt["reason"], receipt["reason"]
-
-
-def test_the_tool_says_when_the_receipt_could_not_be_written(tmp_path, capsys):
-    """Issue #1284: the tool's `receipt:` line is a claim about a *file*, so read the file.
-
-    `_receipt_path` computes where a receipt *would* be written, and the branch for a
-    receipt that could not be written was therefore unreachable: with the path
-    pre-created as a directory (`open(..., "w")` raises `OSError`) the tool printed
-    `receipt: <path>` for a file that does not exist. Same input, twice, so the line is
-    a discriminator rather than a constant.
-    """
-    work, _head = _with_upstream(tmp_path)
-    git_dir = Path(_git(work, "rev-parse", "--absolute-git-dir").stdout.strip())
-    target = git_dir / "emrg-recovery-receipt.json"
-    target.mkdir()
-
-    assert _load().recover(work, apply=True) == 0
-    out = capsys.readouterr().out
-    assert "recovered" in out, out
-    assert "receipt: could not be written" in out, out
-    assert str(target) not in out, "a path is not a receipt"
-    assert not target.is_file()
-    # The convergence itself still happened, and the stash is still the record.
-    assert _status(work).strip() == ""
-    assert _git(work, "stash", "list").stdout.strip() != ""
-
-    control_root = tmp_path / "control"
-    control_root.mkdir()
-    control, _head2 = _with_upstream(control_root)
-    assert _load().recover(control, apply=True) == 0
-    out = capsys.readouterr().out
-    assert "receipt: could not be written" not in out, out
-    assert f"receipt: {Path(_git(control, 'rev-parse', '--absolute-git-dir').stdout.strip()) / 'emrg-recovery-receipt.json'}" in out, out
-
-
-def test_the_fallback_recipe_is_the_owners_recipe_not_a_paraphrase(tmp_path, capsys):
-    """Issue #1284, the branch a receipt-less recovery prints: one owner, not three.
-
-    The tool prints its `reversible:` line from the receipt when it has this run's
-    receipt, and it used to write the spelling **by hand** when it did not — the exact
-    branch a reader lands on when the receipt could not be read. Two copies of a
-    spelling is how the wrong one gets printed, and this pair did disagree once (the
-    receipt said `apply --index`, this line said a bare `git stash pop`), so the
-    fallback now calls the same function the receipt is built from. Measured gap this
-    closes: the branch was *reached* by the test above but its text was named in no
-    test at all — grepping the suite for the fallback's wording found nothing, so a
-    re-worded fallback was a silent edit.
-
-    The assertion is identity with the owner rather than a substring of it: a
-    paraphrase that still contained `--index` would pass a substring test, and the
-    paraphrase is the defect. The placeholder is asserted too, because the fallback's
-    one honest difference from the receipt is that this run's message is unknown here.
-    """
-    work, _head = _with_upstream(tmp_path)
-    git_dir = Path(_git(work, "rev-parse", "--absolute-git-dir").stdout.strip())
-    # Pre-create the receipt path as a *directory*: `open(..., "w")` raises `OSError`,
-    # so no receipt exists and `_receipt_recipe` answers None — the fallback branch.
-    (git_dir / "emrg-recovery-receipt.json").mkdir()
-
-    assert _load().recover(work, apply=True) == 0
-    out = capsys.readouterr().out
-    assert "receipt: could not be written" in out, (
-        f"precondition: this run must take the no-receipt branch; got:\n{out}"
-    )
-
-    line = next((ln for ln in out.splitlines() if ln.startswith("reversible: ")), None)
-    assert line is not None, f"the recovery must print its route; got:\n{out}"
-    assert line == f"reversible: {recovery_recipe('<message>')}", (
-        "the fallback must be the one owner's recipe with the message left as the "
-        "placeholder the reader substitutes from `git stash list` — a hand-written "
-        f"spelling here is the second copy that drifted once; got:\n{line}"
-    )
-    # And the other half of the same claim: the placeholder is a *placeholder*, not a
-    # concrete name invented for a stash this recovery cannot know.
-    assert "stash@{N}" in line, line
-
-
-def test_the_owners_recipe_names_the_measured_route():
-    """The owner's content is a claim too — identity alone cannot see it change.
-
-    The two printer tests assert that each printer equals `recovery_recipe(...)`, and
-    that is exactly one assertion short: **a mutation that changes the owner's own
-    text keeps every identity assertion green**, because both sides moved together.
-    Measured while writing this change: dropping `--index` from the owner left all 36
-    tests in this file passing. The identity assertions cannot close that — only an
-    assertion about the *content* can, and it has to be about the route rather than
-    about the whole string, because the recipe deliberately spells the wrong spelling
-    out in its warning ("a bare `git stash pop` takes the newest…") so a reader knows
-    why the route is the one it is.
-
-    So the route is extracted — the command in the first backtick pair after "then " —
-    and asserted to be the spelling `test_the_advertised_reversal_is_the_measured_one`
-    and `test_the_advertised_selector_survives_a_later_stash` measured with git:
-    `apply --index`, selecting the stash by the **ordinal `git stash list` prints** —
-    not by the message (no documented `@{…}` form names a stash by message, and the
-    ancestry form stops resolving as soon as a later stash exists) and not by
-    `stash@{0}` (the newest, which is this one only until the next is made).
-    """
-    recipe = recovery_recipe("emrg-recovery-20260917T000000Z")
-    assert "then " in recipe, f"the recipe must name the route after 'then': {recipe}"
-    assert "emrg-recovery-20260917T000000Z" in recipe, (
-        f"the recipe must carry the message it was given: {recipe}"
-    )
-    after = recipe.split("then ", 1)[1]
-    assert after.startswith("`"), f"the route must be a quoted command: {after}"
-    route = after.split("`")[1]
-
-    assert "--index" in route, (
-        "the advertised route must restore the staged side — a bare `apply` or `pop` "
-        f"brings a staged change back unstaged; route was: {route!r}"
-    )
-    assert route == "git stash apply --index stash@{N}", (
-        "the route must name the stash the way `git stash list` does and leave the "
-        "ordinal to that list — a message selector either fails (`^{/…}`) or silently "
-        f"applies the newest stash (`@{{/…}}`); route was: {route!r}"
-    )
-    # The ordinal is the reader's substitution, and the test above proves the recipe's
-    # own first half is where they get it: the list is named in the same recipe.
-    assert "`git stash list`" in recipe, (
-        f"the route's `N` has to come from somewhere, and the recipe must say where: {recipe}"
-    )
-    # The message is substituted, not left as a word: two runs must not print the same
-    # recipe, or the receipt would name no stash in particular.
-    other = recovery_recipe("emrg-recovery-19990101T000000Z")
-    assert recipe != other, "the recipe must carry the message it was given"
-
-
-def test_the_git_state_dir_is_answered_normalised(monkeypatch):
-    """The invariant behind #1292's red Windows leg, pinned on every platform.
-
-    `git rev-parse --absolute-git-dir` prints a Windows git dir with **forward
-    slashes** (`C:/.../.git`). The branch that returned it verbatim made the receipt
-    path mixed-separator (`C:/.../.git\\emrg-recovery-receipt.json`) — a spelling that
-    `str(Path(state) / name)`, which is what the test above builds, does not produce,
-    so that test failed on windows-2025 while passing here. The platform semantics
-    cannot be replayed on POSIX (`os.path` is `posixpath`), so what is pinned is the
-    property the fix establishes: whatever git prints — here an absolute git dir
-    wearing a redundant separator, the same *shape* — the answer is normalised, and
-    appending a name to it agrees with `Path(state) / name` on that platform.
-
-    Without the normalisation this fails on every platform, which is the point: the
-    discriminating case used to live only in CI, and a local green said nothing.
-    """
-    class _Fake:
-        returncode = 0
-        stdout = f"{Path(__file__).resolve().parent}/.git/./"
-
-    monkeypatch.setattr(subprocess, "run", lambda *a, **k: _Fake())
-    state = _load().TaskHandler._git_state_dir("/does/not/matter")
-    assert state == os.path.normpath(state), state
-    assert os.path.join(state, "emrg-recovery-receipt.json") == str(
-        Path(state) / "emrg-recovery-receipt.json"
-    ), state
-
-
-def test_the_action_asks_the_criterion_itself_and_cannot_be_told_the_answer(tmp_path):
-    """Defence in depth: no caller's verdict can disarm the net (found in review, #1274).
-
-    An independent review measured the earlier shape — the action accepted the
-    caller's already-measured verdict as an optional argument — stashing a tree that
-    held an untracked file, i.e. work that exists nowhere else, with the receipt
-    calling it a recovery. A guarantee that holds only while every caller passes the
-    truth is not a guarantee, so the parameter is gone: a caller that has not measured
-    now gets a ``TypeError`` instead of a silently wrong answer.
-    """
-    repo = tmp_path / "repo"
-    _new_repo(repo)
-    (repo / "notes.md").write_text("only here", encoding="utf-8")
-
-    _assert_unique_dirt_is_pinned_not_refused(repo)
-
-    # The reviewed exploit, verbatim: `_recover_dirty_tree_sync(repo, <verdict>)`.
-    # It must not be expressible rather than merely discouraged.
-    with pytest.raises(TypeError):
-        _load().TaskHandler._recover_dirty_tree_sync(str(repo), "reported by the caller")
-
-    # The other direction, same entry point: reconstructible dirt does converge.
-    work, head = _with_upstream(tmp_path)
-    status, detail = _load().TaskHandler._recover_dirty_tree_sync(str(work))
-    assert status == "recovered" and "stash" in detail, detail
-    assert _status(work).strip() == ""
-    assert _git(work, "rev-parse", "HEAD").stdout.strip() == head, "HEAD must not move"
-
-
-def test_the_three_outcomes_are_not_two(tmp_path):
-    """`(bool, detail)` collapsed three different answers into `False`; #1274 split them.
-
-    A caller reading any non-recovered answer as "nothing happened" would report a
-    convergence as though the question had been settled, and one reading `clean` as
-    `recovered` would claim a convergence that never ran. So the states are pinned apart,
-    including the one that means "I could not answer". Since #1465's exit there are
-    **three**, not four: the `refused` state is gone with the rule that produced it (it is
-    now `recovered` + a pin, which `test_the_action_asks_the_criterion_itself...` pins).
-    """
-    seen = {}
-
-    clean = tmp_path / "clean"
-    _new_repo(clean)
-    seen["clean"], _ = _load().TaskHandler._recover_dirty_tree_sync(str(clean))
-    assert _git(clean, "stash", "list").stdout.strip() == "", "a no-op makes no stash"
-
-    unique = tmp_path / "unique"
-    _new_repo(unique)
-    (unique / "notes.md").write_text("only here", encoding="utf-8")
-    seen["recovered"], detail = _load().TaskHandler._recover_dirty_tree_sync(str(unique))
-    assert "PINNED" in detail, detail
-    assert _status(unique).strip() == "", "a recovery leaves a clean tree"
-
-    plain = tmp_path / "plain"
-    plain.mkdir()
-    seen["error"], detail = _load().TaskHandler._recover_dirty_tree_sync(str(plain))
-    assert "could not run" in detail, detail
-
-    assert sorted(seen.values()) == ["clean", "error", "recovered"], seen
-    # And the removed state is not merely unused — it is not producible. A tree whose
-    # every byte exists nowhere else is the sharpest case, and it answers `recovered`.
-    assert "refused" not in seen.values()
-
-
-def test_a_clean_tree_is_a_no_op(tmp_path, capsys):
-    repo = tmp_path / "repo"
-    _new_repo(repo)
-
-    assert _load().recover(repo, apply=True) == 0
-    assert "nothing to recover" in capsys.readouterr().out
-    assert _git(repo, "stash", "list").stdout.strip() == ""
-
-
-def test_a_directory_that_is_not_a_repo_cannot_be_measured(tmp_path, capsys):
-    """Exit 2 — a question that could not be answered is never reported as a pass."""
-    plain = tmp_path / "plain"
-    plain.mkdir()
-
-    assert _load().recover(plain, apply=True) == 2
-    assert "could not measure" in capsys.readouterr().out
-
-
-def test_main_parses_the_repo_and_apply_flags(tmp_path, capsys):
-    """The CLI wiring, so the documented invocation is the tested one."""
-    work, _ = _with_upstream(tmp_path)
-
-    assert _load().main(["--repo", str(work)]) == 0
-    assert "recoverable" in capsys.readouterr().out
-    assert _status(work).startswith(" M"), "without --apply nothing is written"
-
-
-def _staged_deletion_repo(tmp_path: Path, name: str, message: str | None = None) -> Path:
-    """A repository whose only dirt is a staged deletion (`D  f.txt`), now stashed.
-
-    The geometry issue #1284's table is about, and one the criterion releases:
-    `git rm` on content unchanged from `HEAD`, so every byte of the removed file is
-    already in `HEAD` and moving it aside cannot lose anything. Stashed with the
-    action's own spelling (`git stash push -u`), which is what the reversal is the
-    inverse *of*.
-
-    `message` is the action's own `emrg-recovery-<ts>` name when a test needs to
-    address the stash *by* it — the selector is a claim about names, so the tests
-    that measure it cannot use git's default `WIP on …` message.
-    """
-    repo = tmp_path / name
-    _new_repo(repo)
-    _git(repo, "rm", "-q", "f.txt")
-    assert _status(repo) == "D  f.txt\n", _status(repo)
-    _git(repo, "stash", "push", "-u", *(["-m", message] if message else []))
-    assert _status(repo) == "", _status(repo)
-    return repo
-
-
-def test_the_advertised_reversal_is_the_measured_one(tmp_path):
-    """Issue #1284 item 2: the undo half is a claim about a git command, so measure it.
-
-    The prose used to say the stashed work is "one `git stash pop` away". On this
-    geometry — a staged deletion, which the criterion answers *recoverable* — that
-    spelling is **not** the inverse, and the difference is invisible until someone
-    needs the undo: it returns the change unstaged and it consumes the stash, so the
-    exact spelling is no longer available to try again. Measured with git 2.50.1,
-    three fresh repositories stashed the same way, one reversal each:
-
-        git stash pop                     -> ` D f.txt`, stash dropped
-        git stash pop --index             -> `D  f.txt`, stash dropped
-        git stash apply --index stash@{0} -> `D  f.txt`, stash kept   <- advertised
-
-    So this is not a stylistic preference between spellings: only the advertised one
-    restores the state *and* leaves the evidence. The claim is a claim about `git`,
-    which means a future git can invalidate it — if this test ever fails, the prose
-    below is what has to be re-read and re-worded, not the test:
-    `DEVELOPMENT.md` (the recovery section), `scripts/recover-worktree.py`'s
-    docstring and its `reversible:` output, and `_recover_dirty_tree_sync`'s
-    docstring in `emrg/server/scheduler.py`.
-    """
-    bare = _staged_deletion_repo(tmp_path, "bare-pop")
-    _git(bare, "stash", "pop")
-    assert _status(bare).startswith(" D"), (
-        "the bare `git stash pop` was expected to bring the staged deletion back "
-        f"*unstaged* — that is what makes it not the inverse; got {_status(bare)!r}"
-    )
-    assert _git(bare, "stash", "list").stdout.strip() == "", (
-        "the bare `git stash pop` was expected to consume the stash"
-    )
-
-    one_shot = _staged_deletion_repo(tmp_path, "pop-index")
-    _git(one_shot, "stash", "pop", "--index")
-    assert _status(one_shot).startswith("D  "), _status(one_shot)
-    assert _git(one_shot, "stash", "list").stdout.strip() == ""
-
-    advertised = _staged_deletion_repo(tmp_path, "apply-index")
-    _git(advertised, "stash", "apply", "--index", "stash@{0}")
-    assert _status(advertised).startswith("D  "), (
-        "the advertised spelling `git stash apply --index` must restore the staged "
-        f"side, byte for byte; got {_status(advertised)!r}"
-    )
-    assert _git(advertised, "stash", "list").stdout.strip() != "", (
-        "the advertised spelling must KEEP the stash — it is the one a reader can "
-        "run again, and the one the receipt hands them"
-    )
-
-
-def test_the_advertised_selector_survives_a_later_stash(tmp_path):
-    """The selector is a claim about *names*, and the state it is used in has two stashes.
-
-    The recipe's own parenthetical gives the reason it names a stash at all: "a bare
-    `git stash pop` takes the newest, which is this one only until the next stash is
-    made". The state that sentence describes is not a corner case — it is what the
-    second ordinary recovery in a repository looks like, because `apply` keeps the
-    first stash forever. Measured with git 2.50.1 in that state (the named stash at
-    `stash@{1}`, a later `emrg-recovery-…` at `stash@{0}`):
-
-        stash^{/<message>}  -> rc=128 to resolve; `apply` rc=1, `error: … is not a
-                               valid reference`; geometry NOT restored
-        stash@{/<message>}  -> resolves to `stash@{0}` (the LATER stash) whatever
-                               message is passed; `apply` rc=0 restoring the WRONG one
-        stash@{N}           -> rc=0, the named entry; `apply` rc=0, `D  f.txt`
-                               restored, both stashes kept          <- advertised
-
-    The middle row is the trap this test exists for: `@{…}` is documented in
-    `gitrevisions(7)` for ordinals, dates, upstream and push — not for messages — so
-    it does not fail, it silently applies someone else's stash. `^{/<text>}` is
-    documented, but searches **commit ancestry**, and an older stash commit is not an
-    ancestor of a newer one, so the older name stops resolving the moment a later
-    stash exists. Both directions are pinned below, so a future git that changes
-    either reddens here instead of in a reader's shell.
-    """
-    named = "emrg-recovery-20260917T010000Z"
-    later = "emrg-recovery-LATER"
-
-    def _two_stash_repo(name: str) -> Path:
-        repo = _staged_deletion_repo(tmp_path, name, message=named)
-        # The next ordinary recovery in this repository: a second, later stash, so the
-        # named one is no longer `stash@{0}`.
-        (repo / "g.txt").write_text("base\n", encoding="utf-8")
-        _git(repo, "add", "g.txt")
-        _git(repo, "commit", "-q", "-m", "add g")
-        (repo / "g.txt").write_text("later recovery\n", encoding="utf-8")
-        _git(repo, "stash", "push", "-u", "-m", later)
-        assert _status(repo) == ""
-        listing = _git(repo, "stash", "list").stdout
-        assert listing.count("emrg-recovery-") == 2, (
-            f"precondition: the named stash and a later one must both exist; got {listing!r}"
-        )
-        lines = listing.splitlines()
-        assert any(ln.endswith(named) for ln in lines), (
-            f"precondition: the named stash must be in the list; got {listing!r}"
-        )
-        assert any(ln.endswith(later) for ln in lines), (
-            f"precondition: the later stash must be in the list; got {listing!r}"
-        )
-        assert not lines[0].endswith(named), (
-            f"precondition: the named stash must no longer be the newest; got {listing!r}"
-        )
-        return repo
-
-    # The route as the receipt hands it over, taken from the one owner rather than
-    # re-spelled here — the reader's copy and this one must be the same string. The
-    # ordinal the route names is read off the list, which is what the recipe's first
-    # half tells the reader to do.
-    repo = _two_stash_repo("later-stash")
-    index = next(
-        ln.split(":")[0].split("{")[1].rstrip("}")
-        for ln in _git(repo, "stash", "list").stdout.splitlines()
-        if ln.endswith(named)
-    )
-    route = recovery_recipe(named).split("then ", 1)[1].split("`")[1].replace("N", index)
-    argv = route.split()
-    assert argv[0] == "git", f"the advertised command must be a literal git command: {route!r}"
-    applied = _git(repo, *argv[1:])
-    assert "D  f.txt" in _status(repo), (
-        f"the advertised route must still find the named stash when a later one "
-        f"exists — it restored {_status(repo)!r}; git said: {applied.stderr.strip()!r}"
-    )
-    assert _git(repo, "stash", "list").stdout.count("emrg-recovery-") == 2, (
-        "and it must keep both stashes: the reader may have to run it again"
-    )
-
-    # The trap, pinned as measured: `@{/<message>}` resolves to the *newest* entry
-    # regardless of the message, so a reader who "repairs" the recipe into that form
-    # gets a successful apply of the wrong stash. This is asserted, not described,
-    # because a silent wrong-stash apply is the one failure a reader cannot notice.
-    trap = _two_stash_repo("later-stash-reflog-form")
-    resolved = _git(trap, "rev-parse", f"stash@{{/{named}}}")
-    assert resolved.returncode == 0, (
-        f"`@{{/<message>}}` was measured to resolve (to the newest, not the named) "
-        f"rather than fail; it now fails with {resolved.stderr.strip()!r}"
-    )
-    newest = _git(trap, "rev-parse", "stash@{0}").stdout.strip()
-    assert resolved.stdout.strip() == newest, (
-        "`@{/<message>}}` must be recorded as resolving to the newest stash — if it "
-        "now names the entry the message mentions, the recipe may use it again"
-    )
-    _git(trap, "stash", "apply", "--index", f"stash@{{/{named}}}")
-    assert "D  f.txt" not in _status(trap), (
-        "and applying it must NOT restore the named geometry — that is why the recipe "
-        f"does not use this form (status={_status(trap)!r})"
-    )
-
-    # The other direction: the ancestry form does not resolve once a later stash exists.
-    ancestry = _two_stash_repo("later-stash-ancestry")
-    failed = _git(ancestry, "stash", "apply", "--index", f"stash^{{/{named}}}")
-    assert failed.returncode != 0, (
-        "the `^{/<message>}` form was measured to stop resolving once a later stash "
-        f"exists; it now succeeds, so the docstring needs re-measuring: {failed.stdout.strip()!r}"
-    )
-    assert "D  f.txt" not in _status(ancestry), (
-        "the failed form must not have restored the geometry by accident"
-    )
-
-
-def test_the_tool_prints_the_receipts_own_recipe(tmp_path, capsys):
-    """Issue #1284 item 2, mechanised: the undo has one owner, and stdout shows it.
-
-    The receipt written beside the move already carried the measured spelling
-    (`git stash apply --index` with a message-selecting stash name). The tool's own `reversible:`
-    line was a *paraphrase* of it, and the paraphrase was the bare `git stash pop` —
-    one recovery, two spellings, and the one a reader sees on stdout is the one that
-    costs them the staged side and the stash. A paraphrase is a second copy that can
-    drift, so the line is now the receipt's own string, and this asserts that instead
-    of assuming it: re-word the daemon's recipe and stdout re-words with it.
-
-    That fix covered the branch where a receipt *exists*. The other branch — no
-    receipt, so no message to name — still wrote the spelling by hand, which is how a
-    third copy survived the change that was about copies. It now calls the same
-    function (`recovery_recipe`) with the message the reader substitutes, asserted by
-    `test_the_fallback_recipe_is_the_owners_recipe_not_a_paraphrase`, so both printers
-    are the owner and neither can drift from it.
-
-    What the *tool* cannot cover is prose that quotes the recipe in a document, and
-    the first attempt at a scanner for it was a false verdict: it required a paragraph
-    mentioning `stash pop` next to an "undoable"/"recoverable" word to also name
-    `--index`, which refused `emrg/server/scheduler.py`'s own note *recording the harm*
-    a plain pop did — prose that has to spell the wrong spelling out. That class is
-    specific to an *absence* test, so the document is pinned by the other shape: a
-    *presence* assertion that the recovery bullet still names the measured spelling
-    (`test_the_document_still_carries_the_measured_spelling`). Together with
-    `test_the_advertised_reversal_is_the_measured_one`, which measures the behaviour
-    those documents describe and names them so a failure points at the text to re-read,
-    the claim is pinned at both ends: what git does, and what the reader is told.
-    """
-    work, _head = _with_upstream(tmp_path)
-
-    assert _load().recover(work, apply=True) == 0
-    out = capsys.readouterr().out
-    git_dir = Path(_git(work, "rev-parse", "--absolute-git-dir").stdout.strip())
-    receipt = json.loads(
-        (git_dir / "emrg-recovery-receipt.json").read_text(encoding="utf-8")
-    )
-
-    assert "--index" in receipt["reversible_with"], (
-        "precondition: the daemon's recipe is the spelling that restores the state"
-    )
-    assert f"reversible: {receipt['reversible_with']}" in out, (
-        "the tool must print the receipt's own recipe, not a second copy of it that "
-        f"can drift; stdout was:\n{out}"
-    )
-
-
-def test_the_document_still_carries_the_measured_spelling():
-    """The reader-facing recipe is prose, so it can be *re-worded* back to the harm.
-
-    `DEVELOPMENT.md`'s recovery bullet is where a reader meets the undo, and nothing
-    mechanical connected it to the measurement above: re-wording that bullet to "every
-    byte one `git stash pop` away" left the whole file green (measured by
-    `how2how2how2-arch` on this PR, 34 passed). A *presence* assertion has no
-    false-verdict class — it fires on the spelling going missing, not on the wrong
-    spelling appearing — so it can hold this one line without repeating the scanner
-    that had to be dropped (see `test_the_tool_prints_the_receipts_own_recipe`).
-
-    What it deliberately cannot see is a document that states both spellings, or a
-    recipe moved to another sentence: it pins presence, which is weaker than a
-    scanner. The bullet is located by its own opening words, and a bullet that has
-    been re-wrapped or re-numbered is still the same claim; a bullet that is *gone*
-    fails here rather than skipping, because an assertion that cannot find its subject
-    has measured nothing.
-    """
-    bullet = _recovery_bullet()
-    assert "git stash apply --index" in bullet, (
-        "the recovery section must name the reversal that restores the staged side "
-        f"and keeps the stash — the spelling the receipt hands a reader; got:\n{bullet}"
-    )
-    assert "stash@{N}" in bullet, (
-        "the recipe has to select the stash by the message the receipt names, not by "
-        f"`stash@{{0}}` (the newest, which is this one only until the next is made); "
-        f"got:\n{bullet}"
-    )
-
-
-def _module_docstring(path: Path) -> str:
-    """The module docstring of `path`, or "" — located with `ast`, never by line number."""
-    return ast.get_docstring(ast.parse(path.read_text(encoding="utf-8"))) or ""
-
-
-def _named_docstring(path: Path, name: str, owner: str | None = None) -> str:
-    """The docstring of `name`, optionally as a method of class `owner`; "" if absent."""
-    tree = ast.parse(path.read_text(encoding="utf-8"))
-    candidates = ast.walk(tree) if owner is None else (
-        node for node in ast.walk(tree)
-        if isinstance(node, ast.ClassDef) and node.name == owner
-    )
-    for node in candidates:
-        for sub in (node.body if isinstance(node, ast.ClassDef) else [node]):
-            if (isinstance(sub, (ast.FunctionDef, ast.AsyncFunctionDef))
-                    and sub.name == name):
-                return ast.get_docstring(sub) or ""
-    return ""
-
-
-#: Every reader-facing copy of the undo recipe, as (what a reader meets, how to get it).
-#: An explicit list rather than a scan of every mention (issue #1304): prose that
-#: *records the harm* — a plain `git stash pop` dropping staged content — has to spell the
-#: wrong spelling out, so a scanner over mentions is a false verdict on this repo's own
-#: notes, which is why #1296 dropped the one it tried. Naming the sites also means a site
-#: that is **renamed or moved** fails here loudly instead of leaving the class silently,
-#: which a scan cannot promise either. Extracted by `ast` rather than by line number, so
-#: an unrelated edit above the docstring cannot make this measure a different paragraph.
-_RECIPE_DOC_SITES = (
-    ("DEVELOPMENT.md's recovery bullet", DOC, lambda: _recovery_bullet()),
-    ("DEVELOPMENT.md's `-f` recovery caveat", DOC, lambda: _recovery_caveat()),
-    ("scripts/recover-worktree.py's module docstring", SCRIPT,
-     lambda: _module_docstring(SCRIPT)),
-    ("scheduler.recovery_recipe's docstring", SCHEDULER,
-     lambda: _named_docstring(SCHEDULER, "recovery_recipe")),
-    ("TaskHandler._recover_dirty_tree_sync's docstring", SCHEDULER,
-     lambda: _named_docstring(SCHEDULER, "_recover_dirty_tree_sync", owner="TaskHandler")),
-)
-
-
-def _assert_site_names_the_measured_spelling(label: str, text: str) -> None:
-    """The one criterion, applied to one site — so the self-test drives the real check."""
-    assert text.strip(), (
-        f"{label}: the site was found but is empty — the anchor moved, so this "
-        "assertion would be measuring nothing"
-    )
-    assert "stash" in text, (
-        f"{label}: this site has to be about the stash the recovery made; got:\n{text[:400]}"
-    )
-    assert "--index" in text, (
-        f"{label} must name `--index`, the part of the reversal that restores the staged "
-        "side. Without it the text sends a reader to the spelling that takes the newest "
-        "stash, brings a staged change back unstaged and consumes it — the failure "
-        f"#1284 exists to prevent (issue #1304); got:\n{text[:400]}"
-    )
-
-
-def test_every_reader_facing_copy_of_the_recipe_names_the_measured_spelling():
-    """Issue #1304: the recipe is stated in several documents, and only one was pinned.
-
-    #1296 corrected the spelling in the manual tool's own usage text and in the docstring
-    of the function that performs the move, and pinned the *document* (see
-    `test_the_document_still_carries_the_measured_spelling`), concluding the claim was
-    "pinned at both ends". Measured on the merged tree, the guard covered one of the
-    three reader-facing sites: re-wording either docstring back to "the action is
-    undoable with a bare `git stash pop`" left the suite green (`38 passed`, rc=0),
-    while the identical edit to the bullet reddens the test above — the positive
-    control that shows the instrument is not blind to prose. So the tool could print
-    the correct spelling while its own usage text, and the action's own docstring, sent
-    a reader to the harmful one.
-
-    The criterion is the same **presence** assertion, applied to every named site rather
-    than to one: each must name `--index`. Like the test above, it deliberately cannot
-    see a site that states *both* spellings, and cannot see a recipe moved to another
-    sentence — that weakness is the price of not re-introducing the scanner, which was a
-    false verdict on prose that records the harm (see
-    `test_the_tool_prints_the_receipts_own_recipe`).
-
-    Three things keep it from passing vacuously: each extraction is asserted non-empty
-    and to be about the stash, so a renamed function or a moved docstring fails here
-    instead of yielding `""` and passing; the site list itself is floored, because a
-    list that shrank to one entry would be a weaker claim, not a green one; and the
-    check is driven once against the harmed spelling in a `pytest.raises` arm, so the
-    assertion is shown to be able to fail.
-
-    The list is a *reader-facing* inventory, so it has to be an inventory: this PR
-    first named four sites, and review measured a fifth by the list's own criterion —
-    the `-f` paragraph in the same document tells a reader "use `git stash -u`,
-    recoverable with `git stash apply --index`", which names `--index` exactly as
-    `_assert_site_names_the_measured_spelling` requires, while dropping the ordinal.
-    Re-wording it back to a bare `git stash pop` left the suite green (`39 passed`,
-    rc=0) while the identical edit to the bullet reddened it, which is how the omission
-    was found rather than argued. It is in the list now, and the floor moved with it.
-    """
-    texts = [(label, get()) for label, _path, get in _RECIPE_DOC_SITES]
-    assert len(texts) >= 5, (
-        "the class is asserted over the sites named in `_RECIPE_DOC_SITES`; a shorter "
-        f"list is a weaker claim, not a passing one (got {len(texts)})"
-    )
-    for label, text in texts:
-        _assert_site_names_the_measured_spelling(label, text)
-
-    # The selector half, at class level rather than per site: the action's docstring
-    # deliberately delegates the ordinal to the receipt ("the spelling the receipt
-    # names"), so requiring it of every site would redden a correct tree. Requiring it
-    # of *none* would let the whole class drop the ordinal and still pass.
-    naming_the_ordinal = [label for label, text in texts if "stash@{N}" in text]
-    assert len(naming_the_ordinal) >= 2, (
-        "at least two reader-facing sites must still name the ordinal selector "
-        "`stash@{N}` — the newest entry is this one only until the next recovery — "
-        f"rather than a bare `stash@{{0}}`; named by: {naming_the_ordinal}"
-    )
-
-    # Self-test (the arm that keeps this from being an assertion that cannot fail):
-    # this is the spelling #1296 removed from two of these sites, and #1304 measured
-    # free to come back.
-    with pytest.raises(AssertionError):
-        _assert_site_names_the_measured_spelling(
-            "planted", "the action is undoable with a bare `git stash pop`."
-        )
-
-
-def test_a_receipt_from_an_earlier_recovery_is_not_printed(tmp_path):
-    """The recipe has to be *this* run's, so the receipt is matched to the detail.
-
-    A receipt left by an earlier recovery names a different stash, and printing it
-    would send a reader to `apply` someone else's stash — worse than the paraphrase
-    the one-owner change replaced. The detail the action just returned names the
-    stash it made, so that is the discriminator, and it is tested directly rather
-    than through a recovery whose receipt happens to be stale.
-    """
-    module = _load()
-    base = {"stash_message": "emrg-recovery-20260101T000000Z",
-            "reversible_with": "`git stash apply --index stash@{/old}`"}
-    path = tmp_path / "receipt.json"
-    path.write_text(json.dumps(base), encoding="utf-8")
-
-    assert module._receipt_recipe(
-        str(path), "1 change(s) stashed as emrg-recovery-20260916T000000Z; HEAD unmoved"
-    ) is None, "a receipt naming a different stash is not this run's"
-    assert module._receipt_recipe(
-        str(path), "1 change(s) stashed as emrg-recovery-20260101T000000Z; HEAD unmoved"
-    ) == "`git stash apply --index stash@{/old}`"
-    assert module._receipt_recipe(str(tmp_path / "absent.json"), "anything") is None
-    broken = tmp_path / "broken.json"
-    broken.write_text("{ not json", encoding="utf-8")
-    assert module._receipt_recipe(str(broken), "anything") is None, (
-        "unreadable receipt -> None, so the caller falls back to the stated spelling "
-        "rather than crashing a recovery that already succeeded"
-    )
diff --git a/tests/test_run_mutation_arm.py b/tests/test_run_mutation_arm.py
deleted file mode 100644
index 8d7865ed..00000000
--- a/tests/test_run_mutation_arm.py
+++ /dev/null
@@ -1,1133 +0,0 @@
-"""Tests for scripts/run-mutation-arm.py - the arm runner that judges its own arm.
-
-What is being pinned, and why each test is here
------------------------------------------------
-A mutation arm is only evidence if the named test *really ran* and *really failed
-because of the mutation*. Every test below pins one way that judgement can be made
-wrongly, because all of them look like success to a harness that only asks "did the
-run fail?":
-
-* `test_a_node_id_that_collects_nothing_is_refused_before_the_mutation` - the trap
-  that has bitten this repository repeatedly: a class method named without its class
-  makes pytest exit **4** having run nothing. Five arms were once recorded KILLED
-  with none of them executed. The pre-flight is what makes this detectable, so the
-  test also asserts the file was never written.
-* `test_a_mutation_that_cannot_parse_is_not_a_kill` - a mutation that breaks the
-  module's syntax makes pytest error, and an *error* carries the same exit code as a
-  failure (measured 2026-09-26: 1 when a fixture loads the module, 2 when collection
-  imports it). Without the `--expect` fragment this is indistinguishable from a kill.
-* `test_a_failing_run_without_the_expected_assertion_is_unjudgeable` - the same rule
-  at the assertion level: an unrelated failure is not this arm's failure.
-* `test_a_survivor_is_reported_as_a_survivor` - the control. If every branch returned
-  KILLED the suite above would pass and the tool would be useless, so the state that
-  means "no coverage" is pinned in its own right.
-* `test_every_decisive_run_leaves_the_file_byte_for_byte_as_it_was` - the tool writes
-  to the working tree it was pointed at. A failed restore silently deletes work.
-
-The mini tree these run in is built in `tmp_path`: the arms must never mutate this
-repository's checkout, which the tests verify by construction (the tool is always
-pointed at the temporary tree with `--cwd`).
-"""
-
-from __future__ import annotations
-
-import importlib.util
-import json
-import ast
-import re
-from pathlib import Path
-
-import pytest
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-SCRIPT = REPO_ROOT / "scripts" / "run-mutation-arm.py"
-DOC = REPO_ROOT / "DEVELOPMENT.md"
-
-SUBJECT = '''"""A tiny subject for the arm runner's own tests."""
-
-
-def greeting(name: str) -> str:
-    """Say hello."""
-    return "hello " + name
-'''
-
-TEST_FILE = '''import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from subject import greeting
-
-
-class TestGreeting:
-    def test_hello(self):
-        assert greeting("x") == "hello x"
-'''
-
-GREETING = 'return "hello " + name'
-HELLO_NODE = "tests/test_subject.py::TestGreeting::test_hello"
-BARE_NODE = "tests/test_subject.py::test_hello"
-
-
-def _load():
-    spec = importlib.util.spec_from_file_location("run_mutation_arm", SCRIPT)
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)
-    return mod
-
-
-@pytest.fixture(scope="module")
-def mod():
-    return _load()
-
-
-@pytest.fixture()
-def tree(tmp_path: Path) -> Path:
-    """A miniature checkout: one subject module and one test that covers it."""
-    (tmp_path / "tests").mkdir()
-    (tmp_path / "subject.py").write_text(SUBJECT, encoding="utf-8")
-    (tmp_path / "tests" / "test_subject.py").write_text(TEST_FILE, encoding="utf-8")
-    (tmp_path / "tests" / "__init__.py").write_text("", encoding="utf-8")
-    return tmp_path
-
-
-def _arm(mod, tree: Path, *, old: str, new: str, node: str = HELLO_NODE, expect: str = "hello x",
-         json_out: bool = False) -> int:
-    argv = [
-        "--file", "subject.py",
-        "--old", old,
-        "--new", new,
-        "--node", node,
-        "--expect", expect,
-        "--cwd", str(tree),
-    ]
-    if json_out:
-        argv.append("--json")
-    return mod.main(argv)
-
-
-class TestTheJudgementOfOneArm:
-    """Each branch of the verdict, measured end to end against a real pytest run."""
-
-    def test_a_kill_needs_the_expected_assertion_to_have_run(self, mod, tree, capsys) -> None:
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name')
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_KILLED, out
-        assert "verdict: KILLED" in out, out
-        # The claim is about the assertion, so the report shows the assertion.
-        assert "'hello x'" in out, out
-
-    def test_a_survivor_is_reported_as_a_survivor(self, mod, tree, capsys) -> None:
-        """The control: an uncovered line is not a kill, and must not read like one."""
-        rc = _arm(mod, tree, old='"""Say hello."""', new='"""Say hi."""')
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_SURVIVED, out
-        assert "verdict: SURVIVED" in out, out
-        assert "KILLED" not in out, out
-
-    def test_a_node_id_that_collects_nothing_is_refused_before_the_mutation(
-        self, mod, tree, capsys
-    ) -> None:
-        """The trap: a bare class method exits 4 having run no test at all.
-
-        The pre-flight is the only thing that separates this from a kill, so the test
-        pins both halves: the refusal, and that the refusal came *before* any write.
-        """
-        before = (tree / "subject.py").read_text(encoding="utf-8")
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name', node=BARE_NODE)
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_TARGET_BROKEN, out
-        assert "verdict: TARGET-BROKEN" in out, out
-        # The remedy has to be in the message, or the reader is left with exit 4.
-        assert "TestC::test_y" in out, out
-        assert (tree / "subject.py").read_text(encoding="utf-8") == before
-
-    def test_a_target_that_ran_nothing_is_refused_even_when_pytest_succeeds(
-        self, mod, tree, capsys
-    ) -> None:
-        """Measured: a target whose tests are all skipped exits **0** with zero passed.
-
-        `rc == 0` alone therefore accepts a target that executed no test, and an arm
-        judged on such a run is the exact failure this tool exists to catch - reached
-        through another door. The pre-flight also requires that something passed.
-
-        (Found by an arm against this tool: dropping `or passed < 1` SURVIVED all 31
-        tests, which is why the state is pinned here.)
-        """
-        (tree / "tests" / "test_subject.py").write_text(
-            "import pytest\n\n\n@pytest.mark.skip(reason='nothing runs')\n"
-            "def test_hello():\n    assert False\n",
-            encoding="utf-8",
-        )
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name',
-                  node="tests/test_subject.py::test_hello")
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_TARGET_BROKEN, out
-        assert "0 passed" in out, out
-
-    def test_a_mutation_that_cannot_parse_is_not_a_kill(self, mod, tree, capsys) -> None:
-        """A syntax error is an error, not a failure - pytest does not say which."""
-        rc = _arm(mod, tree, old=GREETING, new='return "hello " + (')
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_UNJUDGEABLE, out
-        assert "verdict: UNJUDGEABLE" in out, out
-
-    def test_a_failing_run_without_the_expected_assertion_is_unjudgeable(
-        self, mod, tree, capsys
-    ) -> None:
-        """A failure that is not this arm's is not evidence for this arm."""
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name',
-                  expect="a fragment no assertion prints")
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_UNJUDGEABLE, out
-
-    def test_an_unjudgeable_arm_offers_the_assertions_the_run_did_echo(
-        self, mod, tree, capsys
-    ) -> None:
-        """The remedy for a wrong `--expect` is the fragment the run really printed.
-
-        This is the state measured 2026-09-26 (`cyc20260926-140150`): a fragment copied
-        from the test's *message* never appears, because an earlier assertion in the same
-        test fires first, and the caller then re-runs pytest by hand to find the line that
-        does. The report has the output in hand, so it names it - and the assertion below
-        is that the named text is usable as `--expect` verbatim, not a paraphrase of it.
-        """
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name',
-                  expect="a fragment no assertion prints")
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_UNJUDGEABLE, out
-        assert "any of which can be --expect" in out, out
-        assert "assert 'goodbye x' == 'hello x'" in out, out
-
-    def test_a_killed_arm_does_not_gain_that_block(self, mod, tree, capsys) -> None:
-        """The control: the expectation matched, so there is nothing to search for.
-
-        Without this half, printing the candidates unconditionally would pass the test
-        above while making every kill's report noisier for no reader.
-        """
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name')
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_KILLED, out
-        assert "any of which can be --expect" not in out, out
-
-    def test_the_json_report_carries_the_verdict_and_the_observed_run(
-        self, mod, tree, capsys
-    ) -> None:
-        """`--json` is the other consumer, so it carries the same facts as the prose."""
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name', json_out=True)
-        report = json.loads(capsys.readouterr().out)
-        assert rc == mod.EXIT_KILLED, report
-        assert report["verdict"] == "KILLED"
-        # The evidence behind the verdict, not just the verdict.
-        assert report["mutated_rc"] == 1, report
-        assert report["restored"] is True, report
-        assert report["preflight"] == "1 passed", report
-        # The candidates are a field on every report, not one the prose happens to print,
-        # so a consumer reading the JSON of an UNJUDGEABLE arm gets them too.
-        assert report["assertions"], report
-
-
-class TestTheFileTheArmMutates:
-    """The tool writes to a working tree, so what it leaves behind is part of the contract."""
-
-    @pytest.mark.parametrize(
-        "old,new,node",
-        [
-            (GREETING, 'return "goodbye " + name', HELLO_NODE),   # killed
-            ('"""Say hello."""', '"""Say hi."""', HELLO_NODE),    # survived
-            (GREETING, 'return "hello " + (', HELLO_NODE),        # does not parse
-            (GREETING, 'return "goodbye " + name', BARE_NODE),    # refused pre-flight
-        ],
-    )
-    def test_every_decisive_run_leaves_the_file_byte_for_byte_as_it_was(
-        self, mod, tree, capsys, old, new, node
-    ) -> None:
-        before = (tree / "subject.py").read_text(encoding="utf-8")
-        _arm(mod, tree, old=old, new=new, node=node)
-        capsys.readouterr()
-        assert (tree / "subject.py").read_text(encoding="utf-8") == before
-
-    def test_the_run_reports_that_the_restore_happened(self, mod, tree, capsys) -> None:
-        """Saying nothing about the restore is how a silent revert goes unnoticed."""
-        _arm(mod, tree, old=GREETING, new='return "goodbye " + name')
-        assert "restored byte-for-byte: True" in capsys.readouterr().out
-
-
-class TestTheRefusalsThatNeedNoRun:
-    """Arguments that cannot produce an arm at all, answered without invoking pytest."""
-
-    def test_an_anchor_that_is_not_unique_is_refused(self, mod, tree, capsys) -> None:
-        """Two candidate sites means the arm mutates something other than it names."""
-        (tree / "subject.py").write_text(
-            SUBJECT + "\n\ndef other() -> str:\n    " + GREETING + "\n", encoding="utf-8"
-        )
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name')
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_NO_MUTATION, out
-        assert "occurs 2 time(s)" in out, out
-
-    def test_a_replacement_that_changes_nothing_is_not_a_mutation(self, mod, tree, capsys) -> None:
-        """An arm whose edit is a no-op would report SURVIVED for having mutated nothing."""
-        rc = _arm(mod, tree, old=GREETING, new=GREETING)
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_NO_MUTATION, out
-        assert "byte-identical" in out, out
-
-    def test_a_missing_file_is_unjudgeable_and_still_reported(self, mod, tree, capsys) -> None:
-        rc = mod.main([
-            "--file", "absent.py", "--old", "a", "--new", "b",
-            "--node", HELLO_NODE, "--expect", "x", "--cwd", str(tree),
-        ])
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_UNJUDGEABLE, out
-        assert "no such file" in out, out
-
-
-class TestTheReportConventions:
-    """The family's rules, applied to a tool that writes to the tree it names."""
-
-    def test_the_tree_is_named_before_the_verdict(self, mod, tree, capsys) -> None:
-        """A verdict about a tree that is not named is the defect the family keeps fixing."""
-        mod.main([
-            "--file", "absent.py", "--old", "a", "--new", "b",
-            "--node", HELLO_NODE, "--expect", "x", "--cwd", str(tree),
-        ])
-        out = capsys.readouterr().out
-        assert out.index("tree:") < out.index("verdict:"), out
-        assert str(tree) in out, out
-
-    def test_every_verdict_prints_prose_not_only_an_exit_code(self, mod, tree, capsys) -> None:
-        """An exit code alone is what this tool exists to refuse; so is its own."""
-        for argv in (
-            ["--file", "absent.py", "--old", "a", "--new", "b",
-             "--node", HELLO_NODE, "--expect", "x"],
-            ["--file", "subject.py", "--old", GREETING, "--new", GREETING,
-             "--node", HELLO_NODE, "--expect", "x"],
-        ):
-            capsys.readouterr()
-            rc = mod.main(argv + ["--cwd", str(tree)])
-            out = capsys.readouterr().out
-            assert rc != 0
-            assert out.strip(), f"exit {rc} with no report"
-
-
-class TestTheReasonNamesTheFailure:
-    """`_why_unjudgeable` is the whole point of the third state, so it is pinned directly."""
-
-    @pytest.mark.parametrize(
-        "rc,needle",
-        [
-            (2, "collection"),
-            (4, "still parses"),
-            (5, "no test was collected"),
-            (1, "not on the assertion this arm names"),
-        ],
-    )
-    def test_each_pytest_exit_code_gets_its_own_reason(self, mod, rc, needle) -> None:
-        reason = mod._why_unjudgeable(rc, "the expected fragment", "")
-        assert needle in reason, reason
-
-    def test_the_expected_fragment_is_quoted_in_the_reason_it_concerns(self, mod) -> None:
-        assert "the expected fragment" in mod._why_unjudgeable(1, "the expected fragment", "")
-
-    def test_an_unrecognised_exit_code_is_not_given_a_confident_reading(self, mod) -> None:
-        assert "separates neither" in mod._why_unjudgeable(99, "x", "")
-
-
-class TestTheSmallReadings:
-    """The parsers the verdict rests on, tested where they are cheap to test."""
-
-    @pytest.mark.parametrize(
-        "text,expected",
-        [
-            ("1 passed in 0.02s", 1),
-            ("3 passed, 1 warning in 0.10s", 3),
-            ("5 failed, 2 passed in 0.30s", 2),
-            ("1 error in 0.06s", 0),
-            ("no tests ran in 0.01s", 0),
-        ],
-    )
-    def test_the_passed_count_comes_from_pytests_own_summary(self, mod, text, expected) -> None:
-        assert mod._passed_count(text) == expected
-
-    def test_the_failed_node_is_read_from_the_summary_not_guessed(self, mod) -> None:
-        out = f"FAILED {HELLO_NODE} - AssertionError: assert 'goodbye x' == 'hello x'\n1 failed"
-        assert mod._failed_node(out) == HELLO_NODE
-
-    def test_a_run_with_no_failed_line_names_no_node(self, mod) -> None:
-        assert mod._failed_node("1 passed in 0.02s") == ""
-
-    def test_every_failed_node_is_read_not_only_the_first(self, mod) -> None:
-        """Which nodes failed is the evidence a refused pre-flight turns on.
-
-        One of them says no more than "something failed"; the whole list is what shows
-        whether the failures are the arm's own target or files it never touched.
-        """
-        out = (
-            "FAILED tests/test_bash_v2_boundary.py::test_a - AssertionError\n"
-            "FAILED tests/test_check_node_test_count.py::test_b - AssertionError\n"
-            "FAILED tests/test_bash_v2_boundary.py::test_c - AssertionError\n"
-            "12 failed, 4381 passed in 165.56s\n"
-        )
-        assert mod._failed_nodes(out) == [
-            "tests/test_bash_v2_boundary.py::test_a",
-            "tests/test_check_node_test_count.py::test_b",
-            "tests/test_bash_v2_boundary.py::test_c",
-        ]
-        assert mod._failed_nodes("1 passed in 0.02s") == []
-
-    def test_a_non_unique_anchor_has_no_mutation(self, mod) -> None:
-        assert mod._apply("x x", "x", "y") is None
-
-    def test_a_unique_anchor_is_replaced_once(self, mod) -> None:
-        assert mod._apply("x y", "x", "z") == "z y"
-
-    def test_the_echoed_assertions_are_read_marker_stripped_and_in_order(self, mod) -> None:
-        """Both of pytest's echoed forms, and what the reader must *not* be offered.
-
-        The `where` and exception lines are the ones to refuse: they sit in the same
-        block, they are not assertions, and a caller who pasted one would come back
-        with a second UNJUDGEABLE instead of a verdict.
-        """
-        report = (
-            "FAILED tests/x.py::test_a - AssertionError\n"
-            '>           assert mapping["a"] == 2\n'
-            "E           assert 0 == 1\n"
-            'E            +  where 0 = int("0")\n'
-            "E       AttributeError: boom\n"
-            "1 failed in 0.05s\n"
-        )
-        assert mod._assertion_lines(report) == [
-            'assert mapping["a"] == 2',
-            "assert 0 == 1",
-        ]
-
-    @pytest.mark.parametrize(
-        "text",
-        [
-            "1 passed in 0.02s",
-            "",
-            "E       AttributeError: boom\nE        +  where boom = f()\n",
-        ],
-    )
-    def test_a_run_that_echoed_no_assertion_offers_none(self, mod, text) -> None:
-        """Empty is an answer: a collection error has no assertion to hand back."""
-        assert mod._assertion_lines(text) == []
-
-    def test_the_candidate_list_is_capped_and_deduplicated(self, mod) -> None:
-        """The report is read from a terminal, and a fragment is not a transcript."""
-        many = "\n".join(f"E           assert n == {i}" for i in range(20))
-        lines = mod._assertion_lines(many)
-        assert len(lines) == mod._ASSERTION_CANDIDATES, lines
-        assert len(set(lines)) == len(lines), lines
-        assert mod._assertion_lines("E    assert x == 1\nE    assert x == 1\n") == [
-            "assert x == 1"
-        ]
-
-    def test_a_candidate_is_truncated_to_the_length_the_report_allows(self, mod) -> None:
-        """A parametrised assertion can be very long; the candidate is bounded like the rest.
-
-        Pinned because the bound is the only thing between a caller's terminal and a
-        hypothesis-generated assertion printed at full width - and an unpinned constant
-        is one a later edit can drop without any test noticing.
-        """
-        long_assertion = "assert " + "x" * (mod._ASSERTION_MAX_CHARS * 2) + " == 1"
-        (line,) = mod._assertion_lines(f"E           {long_assertion}\n")
-        assert len(line) == mod._ASSERTION_MAX_CHARS, len(line)
-        assert long_assertion.startswith(line), "the truncation must be a prefix, not a re-wrap"
-
-
-#: How a reader meets this tool. `DEVELOPMENT.md` is where a reader who is not reading
-#: the script's own header finds it, and until this pin existed the tool was named in
-#: **no** tracked document at all - cycles that needed an arm wrote one by hand instead,
-#: which is the drift the tool's header opens by describing.
-_VERDICT_NAMES = ("KILLED", "SURVIVED", "UNJUDGEABLE", "TARGET-BROKEN", "NO-MUTATION",
-                  "RESTORE-MISMATCH")
-
-
-def _documented_invocation(doc: str) -> str:
-    """The shell block in `doc` that invokes the arm runner, continuation lines included.
-
-    Located by the tool's own name rather than by line number, so an edit above it cannot
-    make this measure a different block; the block ends at the first line that is not a
-    backslash continuation.
-    """
-    lines = doc.splitlines()
-    for index, line in enumerate(lines):
-        if "run-mutation-arm.py" in line and line.rstrip().endswith("\\"):
-            block = [line]
-            for following in lines[index + 1:]:
-                block.append(following)
-                if not following.rstrip().endswith("\\"):
-                    break
-            return "\n".join(block)
-    return ""
-
-
-def _flags_in(text: str) -> set[str]:
-    """Every long option spelled in `text`."""
-    return set(re.findall(r"--[a-z][a-z0-9-]*", text))
-
-
-def _documented_tool_flags(doc: str) -> set[str]:
-    """The options the documented invocation passes to the **tool**, not to its launcher.
-
-    The block opens with the launcher's own command (`uv run --no-sync python3 ...`), and
-    `--no-sync` is `uv`'s flag: reading the whole block would report it as an option the
-    tool must accept. So the cut is the tool's own path, which is also the one line that
-    makes it this tool's invocation and not another script's.
-    """
-    invocation = _documented_invocation(doc)
-    if "run-mutation-arm.py" not in invocation:
-        return set()
-    return _flags_in(invocation.split("run-mutation-arm.py", 1)[1])
-
-
-def _real_flags(mod, capsys) -> set[str]:
-    """The tool's own option list, asked of argparse rather than transcribed.
-
-    Read from `--help` because the parser is built inside `main`: a second list here would
-    be a copy of the flags, and a copy is what drifts.
-    """
-    with pytest.raises(SystemExit) as exit_info:
-        mod.main(["--help"])
-    assert exit_info.value.code == 0, "asking for help must not be an error"
-    return _flags_in(capsys.readouterr().out)
-
-
-def _module_docstring(path: Path) -> str:
-    return ast.get_docstring(ast.parse(path.read_text(encoding="utf-8"))) or ""
-
-
-def _exit_code_table(text: str) -> dict[str, str]:
-    """Code -> verdict, as a header writes it: a digit, then the verdict in capitals."""
-    return {code: name for code, name in re.findall(r"^\s*(\d)\s+([A-Z][A-Z0-9-]*)\s", text, re.M)}
-
-
-class TestTheExitCodeTableIsTheConstants:
-    """The header's table is what a caller reads to interpret an exit code, so it is read.
-
-    The judgement is built on these six codes, and the table is prose: correcting a code
-    in `EXIT_*` and leaving the header as it was would send a caller to the wrong reading
-    with nothing red. That already happened one line over - the header claimed a mutation
-    that does not parse exits **4** ("no test ran, the node id does not resolve") while its
-    own measured table gives 1 or 2 for it (found 2026-10-03, corrected there).
-    """
-
-    def test_the_header_table_matches_the_modules_own_constants(self, mod) -> None:
-        expected = {
-            str(mod.EXIT_KILLED): mod.KILLED,
-            str(mod.EXIT_SURVIVED): mod.SURVIVED,
-            str(mod.EXIT_UNJUDGEABLE): mod.UNJUDGEABLE,
-            str(mod.EXIT_TARGET_BROKEN): mod.TARGET_BROKEN,
-            str(mod.EXIT_NO_MUTATION): mod.NO_MUTATION,
-            str(mod.EXIT_RESTORE_MISMATCH): mod.RESTORE_MISMATCH,
-        }
-        assert _exit_code_table(_module_docstring(SCRIPT)) == expected
-
-    def test_the_table_is_the_family_this_test_reads(self) -> None:
-        """The extractor's own shape: a line that is not `digit verdict` is not a row.
-
-        Without this, a regex that matched nothing would leave the comparison above
-        comparing two empty dictionaries and passing for a header with no table at all.
-        """
-        text = (
-            "Exit codes\n----------\n"
-            "    0  KILLED       the mutation landed\n"
-            "a node id that does not resolve         4   (USAGE_ERROR)\n"
-            "1. apply the replacement\n"
-        )
-        assert _exit_code_table(text) == {"0": "KILLED"}
-
-
-class TestTheDocumentNamesTheTool:
-    """`DEVELOPMENT.md` has to name the tool *and* the flags it names have to exist.
-
-    A presence check on the tool's name would accept a paragraph whose invocation has
-    been left behind by a rename, so the flags the document spells are compared with the
-    ones argparse really has. What it deliberately cannot see: a document that describes
-    the tool's behaviour wrongly in prose - only the spelling of the flags is mechanical.
-    """
-
-    def test_the_document_invokes_the_arm_runner(self) -> None:
-        invocation = _documented_invocation(DOC.read_text(encoding="utf-8"))
-        assert invocation.strip(), (
-            "DEVELOPMENT.md no longer shows how to run scripts/run-mutation-arm.py - the "
-            "tool was documented 2026-10-03 because cycles were hand-rolling arms instead"
-        )
-        for flag in ("--file", "--old", "--new", "--node", "--expect"):
-            assert flag in invocation, f"the documented invocation dropped {flag}"
-
-    def test_every_flag_the_document_spells_is_a_flag_the_tool_has(self, mod, capsys) -> None:
-        documented = _documented_tool_flags(DOC.read_text(encoding="utf-8"))
-        assert documented, "the invocation named no flag at all, so this would measure nothing"
-        unknown = documented - _real_flags(mod, capsys)
-        assert not unknown, (
-            f"DEVELOPMENT.md spells {sorted(unknown)}, which the tool does not accept - a "
-            "renamed flag leaves the document showing an invocation that cannot run"
-        )
-
-    def test_the_check_would_fire_on_a_flag_the_tool_does_not_have(self, mod, capsys) -> None:
-        """The control: without it, a `_flags_in` that returned nothing would pass above."""
-        assert _flags_in("--file x --not-a-flag y") - _real_flags(mod, capsys) == {"--not-a-flag"}
-
-    def test_the_document_names_every_verdict_the_tool_can_print(self) -> None:
-        text = DOC.read_text(encoding="utf-8")
-        for name in _VERDICT_NAMES:
-            assert name in text, (
-                f"a reader who meets the tool in DEVELOPMENT.md cannot interpret "
-                f"{name!r} because the document does not name it"
-            )
-
-    def test_the_exit_codes_the_document_spells_are_the_tools_own(self, mod) -> None:
-        """The `3`/`4`/`5` pairs the document writes are compared with the constants.
-
-        The `0`/`1`/`2` sentence names its three verdicts by order rather than by pair, so
-        it is not extractable and the test above covers their presence instead.
-        """
-        spelled = dict(re.findall(r"`(\d)`\s+([A-Z][A-Z-]+)", DOC.read_text(encoding="utf-8")))
-        assert spelled, "no `code` VERDICT pair was found - this assertion would measure nothing"
-        for code, name in spelled.items():
-            assert int(code) in (
-                mod.EXIT_KILLED, mod.EXIT_SURVIVED, mod.EXIT_UNJUDGEABLE,
-                mod.EXIT_TARGET_BROKEN, mod.EXIT_NO_MUTATION, mod.EXIT_RESTORE_MISMATCH,
-            ), f"{code} is not an exit code this tool can produce"
-        expected = {
-            str(mod.EXIT_TARGET_BROKEN): mod.TARGET_BROKEN,
-            str(mod.EXIT_NO_MUTATION): mod.NO_MUTATION,
-            str(mod.EXIT_RESTORE_MISMATCH): mod.RESTORE_MISMATCH,
-        }
-        assert spelled == expected
-
-
-class TestANonParsingMutationIsNamedNotGuessed:
-    """A mutated file that does not parse must be *named*, not read as a bad node id.
-
-    Measured 2026-10-03 (`cyc20261003-202837`), driving one non-parsing mutation through
-    this tool and changing only the target form: a **node id** gives pytest exit **4**
-    and a **path** gives **2**, because pytest reports an uncollectable node as a usage
-    error. The exit-4 branch used to conclude "the target no longer resolves" — an
-    assertion about a target the pre-flight had just proved good, sending the caller to
-    re-check a node id that was never wrong. Both arms below run the real tool against
-    the real mini tree; the node-id row is the one that used to misattribute.
-    """
-
-    def test_the_syntax_error_is_read_from_text_that_does_not_parse(self, mod) -> None:
-        assert mod._syntax_error("x = 1\n", "subject.py") == ""
-        message = mod._syntax_error('return "hello " + (\n', "subject.py")
-        assert message, "a file that cannot be compiled must yield a reason"
-        assert "line 1" in message, message
-
-    def test_the_reason_puts_the_syntax_error_before_any_exit_code_reading(self, mod) -> None:
-        reason = mod._why_unjudgeable(4, "assert", "", syntax_error="'(' was never closed at line 2")
-        assert "no longer parses" in reason, reason
-        assert "'(' was never closed at line 2" in reason, reason
-        assert "usage error" not in reason, (
-            "with a syntax error in hand the exit code needs no interpreting, and the "
-            f"old reading is exactly what must not be printed: {reason}"
-        )
-
-    def test_a_target_that_really_does_not_resolve_keeps_its_reason(self, mod) -> None:
-        """The other direction: with a file that still parses, exit 4 is still a bad target."""
-        reason = mod._why_unjudgeable(4, "assert", "", syntax_error="")
-        assert "still parses" in reason and "test_x.py::TestC::test_y" in reason, reason
-        assert "no longer parses" not in reason, reason
-
-    def test_a_non_parsing_mutation_under_a_node_id_names_the_syntax_error(
-        self, mod, tree, capsys
-    ) -> None:
-        """End to end, on the target form that yields exit 4 - the misattributed one."""
-        rc = _arm(mod, tree, old=GREETING, new='return "hello " + (')
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_UNJUDGEABLE, out
-        assert "verdict: UNJUDGEABLE" in out, out
-        assert "no longer parses" in out, out
-        assert "was never closed" in out, (
-            "the report has to name the syntax error itself, not just say the run did "
-            f"not separate the outcomes:\n{out}"
-        )
-        assert "target no longer resolves" not in out, (
-            "the node id was proved good by the pre-flight, so this reading is false "
-            f"here:\n{out}"
-        )
-
-    def test_a_non_parsing_mutation_under_a_path_still_names_it(
-        self, mod, tree, capsys
-    ) -> None:
-        """The same mutation on the other target form, which exits 2 instead of 4.
-
-        Neither form may fall back to a guess: the discriminator is the mutated text,
-        not the code the run happened to return.
-        """
-        rc = _arm(mod, tree, old=GREETING, new='return "hello " + (',
-                  node="tests/test_subject.py")
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_UNJUDGEABLE, out
-        assert "no longer parses" in out and "was never closed" in out, out
-
-    def test_the_tree_is_left_intact_by_a_non_parsing_arm(self, mod, tree, capsys) -> None:
-        """The restore is the one thing an unjudgeable arm must never lose."""
-        before = (tree / "subject.py").read_text(encoding="utf-8")
-        _arm(mod, tree, old=GREETING, new='return "hello " + (')
-        capsys.readouterr()
-        assert (tree / "subject.py").read_text(encoding="utf-8") == before
-
-
-def _parse_bullet() -> str:
-    """The docstring's bullet about a mutation that does not parse, or "" if it is gone."""
-    text = _module_docstring(SCRIPT)
-    if "the mutation did not parse" not in text:
-        return ""
-    return text.split("the mutation did not parse", 1)[1].split("\n* **", 1)[0]
-
-
-def test_the_parse_bullet_keeps_every_code_that_bullet_has_now_been_wrong_about() -> None:
-    """The one part of the header nothing mechanical reads — and it has been wrong twice.
-
-    Its first version gave **4** for a non-parsing mutation (true for a node-id target,
-    false for a path one); the version this branch first carried gave 1 or 2 and said it
-    is *not* 4 (the reverse, measured 2026-10-03). The behaviour is pinned end to end in
-    `TestANonParsingMutationIsNamedNotGuessed`, which is the stronger half; this is the
-    weaker one, and it is deliberate: a *presence* check has no false-verdict class when
-    the prose goes missing, and it cannot certify that a sentence still present is
-    still true. What it does certify is that a future edit cannot drop a code from a
-    bullet whose whole job is to state them.
-    """
-    bullet = _parse_bullet()
-    assert bullet, (
-        "the docstring no longer has a bullet about a mutation that does not parse - "
-        "re-measure before trusting this check's silence"
-    )
-    for code in ("**1**", "**2**", "**4**"):
-        assert code in bullet, f"the parse bullet stopped naming {code}:\n{bullet}"
-    assert "node-id" in bullet or "node id" in bullet, (
-        "the bullet has to name the target form that decides between 2 and 4, which is "
-        f"the distinction it was rewritten for:\n{bullet}"
-    )
-
-
-
-
-class TestTheArmRunsUnderAnInterpreterThatCanImportPytest:
-    """The interpreter is resolved, not assumed - and the report names the one it used.
-
-    Measured 2026-10-05 (`cyc20261005-212445`), on this host, under a bare `python3`
-    (which resolves to the *installed* interpreter, no pytest):
-
-        check-merge-plan-suite._suite_interpreter()  ->  <checkout>/.venv/bin/python
-        python3 scripts/run-mutation-arm.py …        ->  TARGET-BROKEN, "check the node id"
-
-    One question - which interpreter runs pytest here - answered two ways, and the answer
-    the arm runner gave was a refusal that named a cause which was not the cause. The rule
-    now has one implementation: it is asked of the gate that owns it, by file path, the
-    same way that gate asks the sequence tool.
-    """
-
-    def test_the_resolved_interpreter_can_import_pytest(self, mod) -> None:
-        """The property the resolution exists for, measured rather than assumed."""
-        resolved = mod._pytest_interpreter()
-        assert resolved, "the resolver answered with nothing"
-        assert mod._load_gate()._can_import_pytest(resolved), (
-            f"the resolved interpreter cannot import pytest, so an arm judged under it "
-            f"would measure nothing: {resolved}"
-        )
-
-    def test_the_rule_is_asked_of_the_gate_not_reimplemented(self, mod, monkeypatch) -> None:
-        """A second implementation is the drift this delegates to avoid.
-
-        Driven through the gate's own function with a sentinel, because the *equality*
-        check (`_pytest_interpreter() == gate._suite_interpreter()`) cannot discriminate
-        on a machine where both answer with the caller's interpreter - which is every
-        machine whose suite can run at all. Measured, this is the arm that does the work:
-        hardcoding `sys.executable` survives the equality form and dies here.
-        """
-        gate = mod._load_gate()
-        monkeypatch.setattr(gate, "_suite_interpreter", lambda own=None, root=None: "/sentinel/py")
-        assert mod._pytest_interpreter() == "/sentinel/py", (
-            "the resolver did not read its answer from the gate, so the rule now has two "
-            "implementations - the state this delegation was added to end"
-        )
-
-    def test_the_resolution_answers_for_a_layout_it_is_given(self, mod, monkeypatch) -> None:
-        """The arguments are forwarded, so the rule is testable off this machine's layout."""
-        gate = mod._load_gate()
-        seen: list[tuple] = []
-
-        def fake(own=None, root=None):
-            seen.append((own, root))
-            return "/from/the/gate"
-
-        monkeypatch.setattr(gate, "_suite_interpreter", fake)
-        assert mod._pytest_interpreter("/x/python", Path("/y")) == "/from/the/gate"
-        assert seen == [("/x/python", Path("/y"))], (
-            f"the gate has to be asked the question it can answer: {seen}"
-        )
-
-    def test_the_report_names_the_interpreter_and_the_run_uses_it(
-        self, mod, tree, capsys, monkeypatch
-    ) -> None:
-        """Both halves: printed for the reader, and passed to the child that ran."""
-        import subprocess
-
-        sentinel = "/nonexistent/sentinel-python"
-        seen: list[str] = []
-
-        def fake_run(node, cwd, home, python):
-            seen.append(python)
-            return subprocess.CompletedProcess(
-                args=node, returncode=0, stdout="1 passed in 0.01s", stderr=""
-            )
-
-        monkeypatch.setattr(mod, "_pytest_interpreter", lambda *a, **k: sentinel)
-        monkeypatch.setattr(mod, "_run_target", fake_run)
-        _arm(mod, tree, old=GREETING, new='return "goodbye " + name')
-        out = capsys.readouterr().out
-        assert f"interpreter: {sentinel}" in out, out
-        assert seen and set(seen) == {sentinel}, (
-            f"every run must use the resolved interpreter, and both did not: {seen}"
-        )
-
-    def test_the_child_command_carries_the_resolved_interpreter(
-        self, mod, tmp_path, monkeypatch
-    ) -> None:
-        """The command line itself, because every other test here stubs the run out.
-
-        Found by an arm, not by reading the code: with only the tests above,
-        `[python, "-m", "pytest", ...]` -> `[sys.executable, "-m", "pytest", ...]` in
-        `_run_target` **SURVIVED**, since the arms that judge the report monkeypatch
-        `_run_target` and never reach the argv it builds. This test spawns nothing - it
-        intercepts `subprocess.run` and reads the list - so the pin is on the command, not
-        on a stub's return value.
-        """
-        import subprocess
-
-        seen: dict[str, list[str]] = {}
-
-        def fake_run(cmd, **kwargs):
-            seen["cmd"] = list(cmd)
-            return subprocess.CompletedProcess(args=cmd, returncode=0, stdout="1 passed", stderr="")
-
-        monkeypatch.setattr(mod.subprocess, "run", fake_run)
-        mod._run_target(["tests/test_x.py::test_y"], tmp_path, tmp_path, "/resolved/python")
-        assert seen["cmd"][0] == "/resolved/python", (
-            f"the child must be started with the interpreter the arm was resolved under, "
-            f"not the one this process happens to run as: {seen['cmd']}"
-        )
-        assert seen["cmd"][1:3] == ["-m", "pytest"], seen["cmd"]
-
-    def test_the_json_carries_it_too(self, mod, tree, capsys, monkeypatch) -> None:
-        """The machine-readable report is read by callers who see no prose."""
-        import subprocess
-
-        monkeypatch.setattr(mod, "_pytest_interpreter", lambda *a, **k: "/sentinel/py")
-        monkeypatch.setattr(
-            mod, "_run_target",
-            lambda node, cwd, home, python: subprocess.CompletedProcess(
-                args=node, returncode=0, stdout="1 passed in 0.01s", stderr=""
-            ),
-        )
-        _arm(mod, tree, old=GREETING, new='return "goodbye " + name', json_out=True)
-        payload = json.loads(capsys.readouterr().out)
-        assert payload["interpreter"] == "/sentinel/py", payload
-
-
-class TestARefusedPreflightNamesTheCauseItFound:
-    """A refusal has two causes with different remedies, so the report names which one.
-
-    Measured 2026-10-05 (`cyc20261005-191637`), on this host: `python3
-    scripts/run-mutation-arm.py …` - a bare `python3` resolves to the *installed*
-    interpreter here, which has no pytest - gave `preflight: refused (rc=1, 0 passed)`
-    and a verdict whose only remedy was "check the node id". The node id was fine; the
-    same node under `uv run --no-sync pytest` collected and passed. The run's output said
-    so ("<python>: No module named pytest"), which is the text these tests drive, and the
-    interpreter the message names is the one the run *used* - not `sys.executable`, which
-    is no longer what runs when the resolver substitutes the checkout's `.venv`.
-    """
-
-    def test_the_missing_pytest_cause_is_named_with_its_interpreter(self, mod) -> None:
-        line = f"{mod.sys.executable}: No module named pytest"
-        reason = mod._why_target_broken(1, 0, f"collected 0 items\n\n{line}\n", mod.sys.executable)
-        assert "No module named pytest" in reason, reason
-        assert line in reason, (
-            f"the report has to quote the run's own line, not paraphrase it: {reason}"
-        )
-        assert mod.sys.executable in reason, reason
-        assert "uv run --no-sync python3" in reason, (
-            f"a cause without its remedy is half a report: {reason}"
-        )
-        assert "test_x.py::TestC::test_y" not in reason, (
-            "the node id was never wrong here, and sending the reader to it is the "
-            f"defect this branch exists to remove: {reason}"
-        )
-
-    def test_both_spellings_of_the_error_are_read(self, mod) -> None:
-        """`-m pytest` prints the unquoted form; a collection ImportError the quoted one.
-
-        One matcher for one spelling would miss the other, and a missed spelling falls
-        back to the node-id reading - which is exactly the false remedy above.
-        """
-        unquoted = mod._why_target_broken(
-            1, 0, "/usr/bin/python3: No module named pytest", "/usr/bin/python3"
-        )
-        quoted = mod._why_target_broken(
-            1, 0, "ModuleNotFoundError: No module named 'pytest'", "/usr/bin/python3"
-        )
-        for reason in (unquoted, quoted):
-            assert "cannot import pytest" in reason, reason
-
-    def test_a_target_that_really_failed_keeps_the_node_id_reading(self, mod) -> None:
-        """The other direction: with pytest running, the target's own failure stands."""
-        reason = mod._why_target_broken(
-            1, 0, "FAILED tests/test_subject.py::test_hello - assert 1 == 2", mod.sys.executable
-        )
-        assert "test_x.py::TestC::test_y" in reason, reason
-        assert "cannot import pytest" not in reason, reason
-        assert mod.sys.executable in reason, (
-            "the interpreter is printed in both branches, so the two causes stay "
-            f"separable when the detector does not fire: {reason}"
-        )
-
-    def test_the_message_names_the_interpreter_that_ran_not_the_invoked_one(self, mod) -> None:
-        """The resolver can substitute one, so `sys.executable` is the wrong thing to name."""
-        reason = mod._why_target_broken(
-            1, 0, "/somewhere/else/python: No module named pytest", "/checkout/.venv/bin/python"
-        )
-        assert "/checkout/.venv/bin/python" in reason, reason
-        assert mod.sys.executable not in reason, (
-            "the message must describe the run that happened, not the interpreter this "
-            f"process happens to be: {reason}"
-        )
-
-    def test_a_missing_plugin_is_not_read_as_a_missing_pytest(self, mod) -> None:
-        """The veto's shape: the same sentence names a module that is not pytest.
-
-        Measured 2026-10-06 (`cyc20261006-131455`, the veto on PR #1861): the matcher had
-        no right boundary, so `No module named 'pytest_asyncio'` - pytest imports, a plugin
-        does not - was reported as "the interpreter this tool ran it with cannot import
-        pytest". A cause the report did not measure is the family's own defect class, so
-        every name the run can print is enumerated here rather than the two that happen to
-        start with the same letters.
-        """
-        for module in ("pytest_asyncio", "pytest_timeout", "pytest_cov", "pytest.core"):
-            reason = mod._why_target_broken(
-                1, 0, f"ModuleNotFoundError: No module named '{module}'", "/usr/bin/python3"
-            )
-            assert "cannot import pytest" not in reason, (
-                f"{module} is not pytest, and reporting it as an interpreter that cannot "
-                f"import pytest is a cause nobody measured: {reason}"
-            )
-            assert module in reason, (
-                f"the module the run named has to be in the report - it is the cause, and "
-                f"the remedy is an install that only the name can point at: {reason}"
-            )
-            assert "test_x.py::TestC::test_y" not in reason, (
-                "the target never collected, so the node id is not the cause either: "
-                f"{reason}"
-            )
-            assert "uv run --no-sync python3" in reason, (
-                f"a cause without its remedy is half a report: {reason}"
-            )
-
-    def test_the_missing_module_reader_names_the_module_and_stops_at_it(self, mod) -> None:
-        """The reader itself, both spellings and the boundary, on names it must not swallow.
-
-        A greedy pattern would take `pytest.core` for pytest and a boundary-less one takes
-        `pytest_asyncio`; the reader is where that is decided, so it is asked directly
-        rather than through the message it produces.
-        """
-        cases = {
-            "/usr/bin/python3: No module named pytest": "pytest",
-            "ModuleNotFoundError: No module named 'pytest'": "pytest",
-            "No module named pytest.": "pytest",
-            "ModuleNotFoundError: No module named 'pytest_asyncio'": "pytest_asyncio",
-            "ModuleNotFoundError: No module named 'pytest.core'": "pytest.core",
-            "ModuleNotFoundError: No module named 'numpy.linalg'": "numpy.linalg",
-        }
-        for out, expected in cases.items():
-            assert mod._missing_module(out) == expected, (
-                f"{out!r} names {expected!r}, and reading it as anything else sends the "
-                "reader to a remedy for a different failure"
-            )
-        for out in (
-            "ERROR: not found: tests/test_x.py::test_y",
-            "collected 0 items / 1 error",
-            "FAILED tests/test_x.py::test_y - assert 1 == 2",
-        ):
-            assert mod._missing_module(out) == "", (
-                f"this output names no missing module, and a reader that returns one "
-                f"invents a cause: {out!r} -> {mod._missing_module(out)!r}"
-            )
-        assert "pytest" in mod._missing_module("ModuleNotFoundError: No module named 'pytest'"), (
-            "the reader is the one place the module name is read; a rewrite that stops "
-            "reading it has to fail here rather than silently widen a message"
-        )
-
-    def test_the_report_carries_the_cause_end_to_end(self, mod, tree, capsys, monkeypatch) -> None:
-        """Through `main()`, on the output a bare interpreter really produced.
-
-        The run is stubbed rather than spawned: this test is about what the report says,
-        and the honest fixture for it is the bytes that interpreter wrote. The resolver is
-        stubbed to an interpreter that cannot run pytest, which is the state the message
-        describes (after resolution the real one usually can).
-        """
-        import subprocess
-
-        def fake_run(node, cwd, home, python):
-            return subprocess.CompletedProcess(
-                args=node,
-                returncode=1,
-                stdout="",
-                stderr=f"{python}: No module named pytest\n",
-            )
-
-        monkeypatch.setattr(mod, "_pytest_interpreter", lambda *a, **k: "/bare/python3")
-        monkeypatch.setattr(mod, "_run_target", fake_run)
-        before = (tree / "subject.py").read_text(encoding="utf-8")
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name')
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_TARGET_BROKEN, out
-        assert "verdict: TARGET-BROKEN" in out, out
-        assert "No module named pytest" in out, out
-        assert "/bare/python3" in out, out
-        assert "test_x.py::TestC::test_y" not in out, (
-            f"the false remedy must not survive in the printed report:\n{out}"
-        )
-        assert (tree / "subject.py").read_text(encoding="utf-8") == before, (
-            "a refused pre-flight must not have written anything"
-        )
-
-    def test_the_reason_points_at_the_failing_nodes_when_the_run_named_some(self, mod) -> None:
-        """The fourth cause, and the only one the run states in its own output.
-
-        A refusal whose failures are in files the arm never touched is *not* a node-id
-        problem and *not* an interpreter problem, and the two remedies above are both
-        wrong for it. The nodes are what say so.
-        """
-        reason = mod._why_target_broken(
-            1,
-            4381,
-            "FAILED tests/test_bash_v2_boundary.py::test_a - assert 1 == 2\n"
-            "12 failed, 4381 passed in 165.56s\n",
-            "/checkout/.venv/bin/python3",
-        )
-        assert "already red" in reason, reason
-        assert "pre-flight line" in reason, reason
-
-    def test_the_reason_keeps_the_shape_it_had_when_the_run_named_none(self, mod) -> None:
-        """The control: a collection error and a missing module name no node, so no clause.
-
-        Without this, the sentence could be printed unconditionally and the report would
-        send the reader looking for a list that is not there.
-        """
-        for out in (
-            "ERROR: not found: tests/test_x.py::test_hello\n",
-            "/usr/bin/python3: No module named pytest\n",
-        ):
-            reason = mod._why_target_broken(1, 0, out, "/usr/bin/python3")
-            assert "already red" not in reason, reason
-
-    def test_a_refused_preflight_prints_the_nodes_it_failed_on(self, mod, tree, capsys) -> None:
-        """End to end, on a tree whose failures are unrelated to the arm's target.
-
-        Measured 2026-10-09 (`cyc20261009-133913`): a full-suite arm was refused with
-        `failed node: -` while its output held twenty `FAILED` lines, every one of them in
-        another file. The report is the only place a reader could have seen that.
-        """
-        (tree / "tests" / "test_other.py").write_text(
-            "def test_oops():\n    assert 1 == 2\n", encoding="utf-8"
-        )
-        before = (tree / "subject.py").read_text(encoding="utf-8")
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name', node="tests")
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_TARGET_BROKEN, out
-        assert "the pre-flight failed before any mutation, on:" in out, out
-        assert "tests/test_other.py::test_oops" in out, (
-            f"the node that failed is the evidence the verdict turns on:\n{out}"
-        )
-        assert (tree / "subject.py").read_text(encoding="utf-8") == before, (
-            "a refused pre-flight must not have written anything"
-        )
-
-    def test_the_json_report_carries_the_failing_nodes(self, mod, tree, capsys) -> None:
-        """The other consumer gets them too, as a field rather than only as prose."""
-        (tree / "tests" / "test_other.py").write_text(
-            "def test_oops():\n    assert 1 == 2\n", encoding="utf-8"
-        )
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name', node="tests",
-                  json_out=True)
-        payload = json.loads(capsys.readouterr().out)
-        assert rc == mod.EXIT_TARGET_BROKEN, payload
-        assert payload["preflight_failures"] == ["tests/test_other.py::test_oops"], payload
-
-    def test_a_kill_prints_no_preflight_failure_block(self, mod, tree, capsys) -> None:
-        """The control for the print: the block belongs to the refusal, not to the report."""
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name')
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_KILLED, out
-        assert "the pre-flight failed before any mutation" not in out, out
-
-
-class TestAGateThatWillNotLoadIsAVerdict:
-    """The resolution's own failure leaves through the report, not out of `main`.
-
-    Measured 2026-10-06 (`cyc20261006-020931`), on this host, in two shapes and with the
-    same outcome: a gate with one unparsable line appended, and a copy of this tool
-    standing alone without a gate beside it, each gave **no `verdict:` line at all** and
-    exit code **1** - which this file defines as `EXIT_SURVIVED`. A caller that reads the
-    exit code therefore read "the target still passed with the mutation in place" out of a
-    run that never started, which is the class of defect this file's own contract names:
-    "Every verdict leaves through `_report` … an exit code with no prose is the failure
-    this family keeps naming".
-    """
-
-    @pytest.fixture
-    def unloadable_gate(self, mod, tmp_path, monkeypatch):
-        """Point `_GATE` at a path that is not there, and forget the cached module.
-
-        The cache is the reason this is a fixture rather than one line in each test: a gate
-        already loaded by an earlier test would be returned without touching the disk, and
-        the test would then pass without ever exercising the failure.
-        """
-        monkeypatch.setattr(mod, "_GATE", tmp_path / "check-merge-plan-suite.py")
-        monkeypatch.setattr(mod, "_GATE_MODULE", None)
-        return mod._GATE
-
-    def test_the_failure_is_a_verdict_and_never_the_survived_code(
-        self, mod, tree, capsys, unloadable_gate
-    ) -> None:
-        before = (tree / "subject.py").read_text(encoding="utf-8")
-        rc = _arm(mod, tree, old=GREETING, new='return "goodbye " + name')
-        out = capsys.readouterr().out
-        assert rc == mod.EXIT_UNJUDGEABLE, out
-        assert "verdict: UNJUDGEABLE" in out, out
-        assert rc != mod.EXIT_SURVIVED, (
-            "the crash used to exit 1, so a caller reading the code read a survivorship "
-            "finding it never measured"
-        )
-        assert (tree / "subject.py").read_text(encoding="utf-8") == before, (
-            "the arm stopped before it ran anything, so nothing may have been written"
-        )
-
-    def test_the_reason_names_the_gate_it_could_not_load(
-        self, mod, tree, capsys, unloadable_gate
-    ) -> None:
-        """A verdict the reader cannot act on is half a refusal."""
-        _arm(mod, tree, old=GREETING, new='return "goodbye " + name')
-        out = capsys.readouterr().out
-        assert unloadable_gate.name in out, out
-        assert "No such file" in out, (
-            f"the cause the load really raised has to be quoted: {out}"
-        )
-        assert "check-merge-plan-suite.py --help" in out, (
-            f"a cause without a remedy sends the reader back to guessing: {out}"
-        )
-        assert "test_x.py::TestC::test_y" not in out, (
-            f"the node id was never the subject here: {out}"
-        )
-
-    def test_the_json_report_carries_it_too(self, mod, tree, capsys, unloadable_gate) -> None:
-        _arm(mod, tree, old=GREETING, new='return "goodbye " + name', json_out=True)
-        payload = json.loads(capsys.readouterr().out)
-        assert payload["verdict"] == "UNJUDGEABLE", payload
-        assert payload["exit"] == mod.EXIT_UNJUDGEABLE, payload
-        assert "No such file" in payload["why"], payload
diff --git a/tests/test_vibe_check_prompt.py b/tests/test_vibe_check_prompt.py
index 85583110..9d487a0d 100644
--- a/tests/test_vibe_check_prompt.py
+++ b/tests/test_vibe_check_prompt.py
@@ -242,7 +242,7 @@ def test_the_exception_reaches_the_judge_and_not_merely_the_file() -> None:
     carries it. Measured 2026-10-08 (`cyc20261008-060209`): wrapping the block in
     `{# … #}` leaves every term in the file, so all the file-level assertions above stay
     green, while the render drops 182 characters and every one of those terms with them —
-    `scripts/run-mutation-arm.py` reported `SURVIVED` for exactly that arm. The exception
+    a hand-written mutation arm reported `SURVIVED` for exactly that one. The exception
     is only worth having if the model reads it.
 
     Both directions are asserted in one test on purpose: the render must carry what the