@jesdi/skills 0.0.50 → 0.0.51

package/skills/test-prune/prune_review.py

@@ -0,0 +1,363 @@
+"""collect, review-input and batch: from the candidate report to the accepted batch; edits nothing."""
+from __future__ import annotations
+
+import json
+from pathlib import PurePosixPath
+
+from prune_repo import BadInput, Fail, ratchet_lines
+from prune_source import class_refusals, describe, families, undeletable
+
+CAP = 10  # deleted test ids per unattended run; a parametrized test counts each case
+
+CANDIDATE_VERDICTS = {"keep", "delete", "strengthen"}
+GROUP_VERDICTS = {"strengthen", "equivalent"}
+
+
+class Sources:
+    """Test files as of one commit, keyed by their backend-relative path."""
+
+    def __init__(self, repo, commit: str):
+        self.repo, self.commit, self.files = repo, commit, {}
+
+    def text(self, path: str) -> str | None:
+        if path not in self.files:
+            self.files[path] = self.repo.show_test(self.commit, path)
+        return self.files[path]
+
+    def describe(self, test_id: str) -> dict:
+        text = self.text(test_id.split("::")[0])
+        found = describe(text, test_id) if text is not None else None
+        return found or {"source": None, "assertions": []}
+
+    def test(self, test_id: str) -> dict:
+        return dict(test_id=test_id, **self.describe(test_id))
+
+    def class_refusals(self, test_ids: list) -> dict:
+        by_file: dict = {}
+        for test_id in test_ids:
+            by_file.setdefault(test_id.split("::")[0], []).append(test_id)
+        refused: dict = {}
+        for path, ids in by_file.items():
+            refused.update(class_refusals(self.text(path), ids))
+        return refused
+
+    def undeletable(self, test_id: str) -> str | None:
+        path = PurePosixPath(test_id.split("::")[0])
+        if path.parts[0] != "tests" or path.name == "conftest.py":
+            return f"{path} is not a deletable test module"
+        text = self.text(str(path))
+        return f"{path} not found at the base commit" if text is None else undeletable(text, test_id)
+
+
+def _fixer_input(repo, commit: str, report: dict) -> dict:
+    sources = Sources(repo, commit)
+    return {
+        "candidates": [dict(c, **sources.describe(c["test_id"]),
+                            containers=[sources.test(t) for t in c.get("contained_by", [])])
+                       for c in report["candidates"]],
+        "weak_spots": [{"group": f"{PurePosixPath(w['module']).stem}.{w['function']}", **w}
+                       for w in report["weak_spots"]],
+    }
+
+
+def collect(ctx) -> int:
+    repo, args = ctx.repo, ctx.args
+    repo.require_clean()
+    branch = repo.branch()
+    protected = args.unattended or args.protected_only
+    ctx.state.reset()
+    if args.unattended:
+        repo.must_make("test")
+    ratchet = repo.cold_ratchet()
+    if not ratchet["ok"]:
+        raise Fail("the base fails the mutation ratchet, fix it before pruning:\n" + "\n".join(ratchet_lines(ratchet)))
+    mutants = repo.mutant_codes()
+    repo.must_make("test-candidates", *(["ARGS=--protected-only"] if protected else []))
+    report = json.loads((repo.backend / ".mutation" / "test-candidates.json").read_text())
+    commit = repo.head()
+    ctx.state.save("base.json", {
+        "mode": "unattended" if args.unattended else "interactive", "protected": protected, "commit": commit,
+        "branch": branch, "baseline": json.loads((repo.backend / "mutation_baseline.json").read_text()),
+        "mutants": mutants, "tests": repo.collected_tests(), "ratchet": ratchet,
+    })
+    fixer = _fixer_input(repo, commit, report)
+    path = ctx.state.save("fixer-input.json", fixer)
+    kind = "protected candidates" if protected else "candidates"
+    count = f"{len(fixer['candidates'])} {kind}" if fixer["candidates"] else f"no {kind}"
+    ctx.state.emit(f"{count}, {len(fixer['weak_spots'])} weak-spot groups → {path}")
+    return 0
+
+
+def _index(entries: list, key: str, expected: list, label: str, errors: list) -> dict:
+    """{key value: entry}; records missing, unknown and duplicate entries in errors."""
+    found: dict = {}
+    for entry in entries:
+        value = entry.get(key)
+        if value in found:
+            errors.append(f"{label} {value}: more than one entry")
+        elif value not in expected:
+            errors.append(f"{label} {value}: unknown, not in the input")
+        found[value] = entry
+    errors += [f"{label} {value}: no entry" for value in expected if value not in found]
+    return found
+
+
+def _blank(value) -> bool:
+    return not str(value or "").strip()
+
+
+def candidate_problems(tid: str, entry: dict, tests: set) -> list:
+    verdict, into = entry.get("verdict"), entry.get("into")
+    checks = [
+        (verdict not in CANDIDATE_VERDICTS, f"verdict {verdict!r} is not one of {sorted(CANDIDATE_VERDICTS)}"),
+        (verdict == "delete" and (into == tid or into not in tests), f"delete into {into} is not another collected test id"),
+        (verdict == "strengthen" and _blank(entry.get("assertion")), "strengthen names no assertion"),
+        (verdict != "keep" and _blank(entry.get("reason")), "no reason"),
+    ]
+    return [f"candidate {tid}: {message}" for failed, message in checks if failed]
+
+
+def group_problems(group: dict, entry: dict) -> list:
+    verdict, ids = entry.get("verdict"), entry.get("mutant_ids", group["mutant_ids"])
+    listed = isinstance(ids, list) and bool(ids)
+    checks = [
+        (verdict not in GROUP_VERDICTS, f"verdict {verdict!r} is not one of {sorted(GROUP_VERDICTS)}"),
+        (not listed, "mutant_ids must be a non-empty list"),
+        (_blank(entry.get("reason")), "no reason"),
+    ] + [(True, f"{m} is not one of its surviving mutants") for m in (ids if listed else []) if m not in group["mutant_ids"]]
+    return [f"weak spot {group['group']}: {message}" for failed, message in checks if failed]
+
+
+def split_problems(name: str, entries: list) -> list:
+    """A group takes one entry, or one strengthen and one equivalent entry with disjoint, listed ids."""
+    if len(entries) == 1:
+        return []
+    verdicts = sorted(str(e.get("verdict")) for e in entries)
+    if verdicts != ["equivalent", "strengthen"]:
+        return [f"weak spot {name}: at most one strengthen and one equivalent entry, got {verdicts}"]
+    if not all(isinstance(e.get("mutant_ids"), list) for e in entries):
+        return [f"weak spot {name}: a split group lists mutant_ids in both entries"]
+    shared = set(entries[0]["mutant_ids"]) & set(entries[1]["mutant_ids"])
+    return [f"weak spot {name}: {', '.join(sorted(shared))} in both entries"] if shared else []
+
+
+def _group_entries(entries: list, groups: dict, errors: list) -> dict:
+    """{group: [entries]}; records unknown and missing groups and bad splits in errors."""
+    found: dict = {}
+    for entry in entries:
+        found.setdefault(entry.get("group"), []).append(entry)
+    errors += [f"weak spot {name}: unknown, not in the input" for name in found if name not in groups]
+    errors += [f"weak spot {name}: no entry" for name in groups if name not in found]
+    for name in [n for n in found if n in groups]:
+        errors += _entries_problems(groups[name], found[name])
+    return found
+
+
+def _entries_problems(group: dict, entries: list) -> list:
+    return split_problems(group["group"], entries) + [p for e in entries for p in group_problems(group, e)]
+
+
+def _validated(fixer: dict, out: dict, tests: set) -> tuple[dict, dict]:
+    errors: list = []
+    cands = _index(out["candidates"], "test_id", [c["test_id"] for c in fixer["candidates"]], "candidate", errors)
+    for tid, entry in cands.items():
+        errors += candidate_problems(tid, entry, tests)
+    spots = _group_entries(out["weak_spots"], {w["group"]: w for w in fixer["weak_spots"]}, errors)
+    if errors:
+        raise BadInput("invalid fixer proposals:\n" + "\n".join(errors))
+    return cands, spots
+
+
+def _group_proposals(w: dict, entries: list) -> list:
+    """One proposal per entry; id = the group, or `<group>:<verdict>` when the group is split."""
+    return [dict(e, id=w["group"] if len(entries) == 1 else f"{w['group']}:{e['verdict']}", kind=e["verdict"],
+                 module=w["module"], function=w["function"], mutant_ids=e.get("mutant_ids", w["mutant_ids"]))
+            for e in entries]
+
+
+def _candidate_proposal(c: dict, entry: dict, sources: Sources) -> dict:
+    proposal = dict(entry, id=c["test_id"], kind=entry["verdict"],
+                    candidate={k: c[k] for k in ("test_id", "source", "assertions")})
+    if entry["verdict"] == "delete":
+        proposal["into"] = sources.test(entry["into"])
+    return proposal
+
+
+def review_input(ctx) -> int:
+    base = ctx.base()
+    fixer = ctx.state.load("fixer-input.json")
+    cands, spots = _validated(fixer, ctx.proposals(), set(base["tests"]))
+    sources = Sources(ctx.repo, base["commit"])
+    proposals = [_candidate_proposal(c, cands[c["test_id"]], sources)
+                 for c in fixer["candidates"] if cands[c["test_id"]]["verdict"] != "keep"]
+    proposals += [p for w in fixer["weak_spots"] for p in _group_proposals(w, spots[w["group"]])]
+    path = ctx.state.save("review-input.json", {"proposals": proposals})
+    ctx.state.emit(f"{len(proposals)} proposals for the reviewer → {path}")
+    return 0
+
+
+def _skip_reason(tid: str, into: str, kept: list, sources: Sources) -> str | None:
+    for d in kept:
+        if d["test_id"] == into:
+            return f"its containing test {into} is deleted earlier in this batch"
+    return sources.undeletable(tid)
+
+
+def _whole_parametrize(kept: list, tests: list) -> tuple[list, list]:
+    """A parametrized case goes only with all its siblings: the gate refuses a parametrize-list edit."""
+    chosen = {d["test_id"] for d in kept}
+    deletions, skipped = [], []
+    for d in kept:
+        stem = d["test_id"].split("[")[0]
+        missing = [t for t in tests if t.split("[")[0] == stem and t not in chosen]
+        if "[" in d["test_id"] and missing:
+            skipped.append({"test_id": d["test_id"], "reason": "parametrized case: deleting it would edit the "
+                            f"parametrize list, and its siblings {', '.join(missing)} are not all accepted"})
+        else:
+            deletions.append(d)
+    return deletions, skipped
+
+
+def _settle(accepted: list, tests: list, sources: Sources) -> tuple[list, list]:
+    """Accepted deletions → (deletions, skipped): a test whose container goes, or the gate would refuse
+    (alone or with the rest of the batch), or a parametrized case whose siblings stay, is skipped."""
+    kept, skipped = [], []
+    for proposal, review in accepted:
+        tid, into = proposal["test_id"], proposal["into"]["test_id"]
+        reason = _skip_reason(tid, into, kept, sources)
+        if reason:
+            skipped.append({"test_id": tid, "reason": reason})
+        else:
+            kept.append({"test_id": tid, "into": into, "reason": review["reason"]})
+    deletions, partial = _whole_parametrize(kept, tests)
+    refused = sources.class_refusals([d["test_id"] for d in deletions])
+    return ([d for d in deletions if d["test_id"] not in refused],
+            skipped + partial + [{"test_id": t, "reason": r} for t, r in refused.items()])
+
+
+def cap(deletions: list) -> tuple[list, list, list]:
+    """(take, left, over): every whole family that still fits within CAP ids, in batch order; the families
+    that do not fit this run, left for next week; and a family of more than CAP cases, which never fits,
+    as skipped entries."""
+    take, left, over = _fit(families(d["test_id"] for d in deletions))
+    over_entries = [{"test_id": t, "reason": f"{len(f)} cases exceed the cap of {CAP}"} for f in over for t in f]
+    return _only(deletions, take), _only(deletions, left), over_entries
+
+
+def _fit(groups: list) -> tuple[set, set, list]:
+    """(ids taken, ids left, families too big ever to fit) for families in batch order."""
+    take, left, over, count = set(), set(), [], 0
+    for family in groups:
+        if len(family) > CAP:
+            over.append(family)
+        elif count + len(family) > CAP:
+            left.update(family)
+        else:
+            take.update(family)
+            count += len(family)
+    return take, left, over
+
+
+def _only(deletions: list, ids: set) -> list:
+    return [d for d in deletions if d["test_id"] in ids]
+
+
+def _strengthen_item(proposal: dict, review: dict) -> dict:
+    item = {k: v for k, v in proposal.items() if k not in ("into", "verdict")}
+    return dict(item, kind="weak_spot" if "group" in proposal else "candidate",
+                fixer_reason=proposal.get("reason"), reason=review["reason"])
+
+
+def mutant_summary(ids: list, shown: int = 5) -> str:
+    """`(<n> mutants: <first ids> +N more)`: batch.json keeps every id, the printout stays readable."""
+    more = f" +{len(ids) - shown} more" if len(ids) > shown else ""
+    return f"({len(ids)} mutant{'' if len(ids) == 1 else 's'}: {', '.join(ids[:shown])}{more})"
+
+
+def suggestions_section(out: dict) -> list:
+    """Accepted "strengthen with this assertion" verdicts on candidates: listed for a human, never applied."""
+    items = [i for i in out["strengthen"] if i["kind"] == "candidate"]
+    if not items:
+        return []
+    return ["", "## Strengthen suggestions", "",
+            "The reviewer accepted these \"strengthen with this assertion\" verdicts. test-prune does not apply "
+            "them; a human adds each assertion.", ""] + [
+        f"- `{i['id']}`: add `{i['assertion']}`. {i['reason']}" for i in items]
+
+
+def equivalents_section(equivalents: list, shown: int | None = None) -> list:
+    """Accepted equivalent proposals, for a human to check and declare; shown: ids listed per group
+    before the rest is counted (None: every id, as the PR bodies need)."""
+    if not equivalents:
+        return []
+    return ["", "## Equivalent proposals", "",
+            "The reviewer accepted these as equivalent mutants. test-prune never declares an equivalent; "
+            "a human adds them to `backend/mutation_baseline.json` after checking each one.", ""] + [
+        f"- `{e['group']}`: {_ids(e['mutant_ids'], shown)}. {e['reason']}" for e in equivalents]
+
+
+def _ids(ids: list, shown: int | None) -> str:
+    listed = ", ".join(f"`{m}`" for m in ids[:shown])
+    return listed + (f" +{len(ids) - shown} more" if shown is not None and len(ids) > shown else "")
+
+
+def _left_lines(left: list) -> list:
+    if not left:
+        return []
+    return [f"Left for next week ({len(left)}, over the cap of {CAP} per run):"] + [
+        f"  - {d['test_id']} → contained by {d['into']}" for d in left]
+
+
+def _render_batch(out: dict, mode: str) -> str:
+    lines = [f"Accepted batch ({mode})" + (": nothing is edited until a human approves and runs `apply`"
+                                           if mode == "interactive" else "")]
+    lines.append(f"Deletions ({len(out['deletions'])}):")
+    lines += [f"  - {d['test_id']} → contained by {d['into']}: {d['reason']}" for d in out["deletions"]]
+    spots = [i for i in out["strengthen"] if i["kind"] == "weak_spot"]
+    lines.append(f"Strengthen, weak spots for the strengthen agent ({len(spots)}):")
+    lines += [f"  - {s['id']} {mutant_summary(s['mutant_ids'])}: {s['reason']}" for s in spots]
+    lines += _left_lines(out["left"])
+    lines.append(f"Skipped ({len(out['skipped'])}):")
+    lines += [f"  - {s['test_id']}: {s['reason']}" for s in out["skipped"]]
+    lines.append(f"Rejected ({len(out['rejected'])}):")
+    lines += [f"  - {r['id']} [{r['kind']}]: {r['reason']}" for r in out["rejected"]]
+    return "\n".join(lines + suggestions_section(out) + equivalents_section(out["equivalents"], shown=5))
+
+
+def check_reviews(reviews: list, ids: list) -> dict:
+    errors: list = []
+    found = _index(reviews, "id", ids, "proposal", errors)
+    for pid, review in found.items():
+        if review.get("verdict") not in ("accept", "reject"):
+            errors.append(f"proposal {pid}: verdict {review.get('verdict')!r} is not accept or reject")
+        if not str(review.get("reason") or "").strip():
+            errors.append(f"proposal {pid}: no reason")
+    if errors:
+        raise BadInput("invalid reviews:\n" + "\n".join(errors))
+    return found
+
+
+def batch(ctx) -> int:
+    base = ctx.base()
+    proposals = ctx.state.load("review-input.json")["proposals"]
+    reviews = check_reviews(ctx.reviews(), [p["id"] for p in proposals])
+    out: dict = {"deletions": [], "left": [], "strengthen": [], "equivalents": [], "rejected": [], "skipped": []}
+    accepted = []
+    for p in proposals:
+        review = reviews[p["id"]]
+        if review["verdict"] == "reject":
+            out["rejected"].append({"id": p["id"], "kind": p["kind"], "reason": review["reason"]})
+        elif p["kind"] == "delete":
+            accepted.append((p, review))
+        elif p["kind"] == "equivalent":
+            out["equivalents"].append({"group": p["group"], "mutant_ids": p["mutant_ids"], "reason": p["reason"],
+                                       "review": review["reason"]})
+        else:
+            out["strengthen"].append(_strengthen_item(p, review))
+    out["deletions"], out["skipped"] = _settle(accepted, base["tests"], Sources(ctx.repo, base["commit"]))
+    if base["mode"] == "unattended":
+        out["deletions"], out["left"], over = cap(out["deletions"])
+        out["skipped"] += over
+    path = ctx.state.save("batch.json", out)
+    ctx.state.emit(f"{_render_batch(out, base['mode'])}\n→ {path}")
+    return 0

package/skills/test-prune/prune_runs.py

@@ -0,0 +1,240 @@
+"""apply (interactive) and prune (unattended): apply the accepted deletions, run the safety check,
+restore every culprit, then commit; unattended also branches, gates, pushes and opens the PR."""
+from __future__ import annotations
+
+import re
+
+from prune_repo import Fail, capped, fenced, ratchet_lines
+from prune_review import CAP, equivalents_section, suggestions_section
+from prune_source import delete_tests, families, targets
+
+_CHECK_LINE = re.compile(r"^(  [✓✗•!] |      \S|    ↑)")
+_VERDICT = re.compile(r"^Prune gate (PASSED|FAILED|ERROR)")
+_VERDICT_LINE = re.compile(r"^  [✓✗] ")
+GATE_LIMIT = 20_000  # the gate section's share of a PR body: a cut stays inside it
+
+
+def _check_block(lines: list) -> list:
+    """The last `make mutation-check` block in lines: back from `Mutation ratchet PASSED/FAILED.` over its
+    module lines to `Mutation results from…` when printed."""
+    ends = [i for i, line in enumerate(lines) if re.match(r"^Mutation ratchet (PASSED|FAILED)", line)]
+    if not ends:
+        return []
+    start = ends[-1]
+    while start and _CHECK_LINE.match(lines[start - 1]):
+        start -= 1
+    if start and lines[start - 1].startswith("Mutation results from"):
+        start -= 1
+    return lines[start:ends[-1] + 1]
+
+
+def gate_report(stdout: str, stderr: str = "") -> str:
+    """The prune gate's own report out of its stdout (the real gate also prints its cold mutmut run, and
+    mutmut's children warn on stderr): its verdict line with the indented ✓/✗ lines right after it, then
+    the `make mutation-check` block it printed (verdict first: a cut for size keeps it). No verdict on
+    stdout: the last 30 lines of both streams."""
+    lines = stdout.splitlines()
+    verdicts = [i for i, line in enumerate(lines) if _VERDICT.match(line)]
+    if not verdicts:
+        return "\n".join((stdout + stderr).splitlines()[-30:])
+    end = verdicts[-1] + 1
+    while end < len(lines) and _VERDICT_LINE.match(lines[end]):
+        end += 1
+    return "\n".join(lines[verdicts[-1]:end] + _check_block(lines[:verdicts[-1]]))
+
+
+class DeletionSet:
+    """Writes a deletion set over the base commit's content of every file the whole batch touches."""
+
+    def __init__(self, repo, commit: str, ids):
+        self.repo, self.commit, self.files = repo, commit, sorted(targets(ids))
+
+    def write(self, ids) -> None:
+        chosen, texts = targets(ids), {}
+        for path in self.files:
+            source = self.repo.show_test(self.commit, path)
+            texts[self.repo.test_path(path)] = delete_tests(source, chosen[path]) if path in chosen else source
+        self.repo.write(texts, self.commit)
+
+
+def _culprit(family: list, failing: dict, passing: dict) -> list:
+    name = family[0] if len(family) == 1 else family[0].split("[")[0]
+    return [{"test_id": name, "test_ids": family, "module": m, "survivors_with": failing["modules"][m][0],
+             "baseline": failing["modules"][m][1], "survivors_after": passing["modules"].get(m, [None])[0]}
+            for m in failing["failed"]]
+
+
+def _flat(units) -> list:
+    return [test_id for unit in units for test_id in unit]
+
+
+def safety_check(repo, base: dict, ids: list) -> tuple[list, list, dict]:
+    """Restore every deletion whose absence lets a module exceed its baseline; returns (kept ids, restored,
+    ratchet of the kept set) with the kept set written to the tree. Survivors only grow as tests go, so
+    the smallest failing prefix of families ends with a culprit; repeat until the whole kept set passes."""
+    deletion_set = DeletionSet(repo, base["commit"], ids)
+    results = {(): base["ratchet"]}
+
+    def check(units: list) -> dict:
+        key = tuple(_flat(units))
+        if key not in results:
+            deletion_set.write(key)
+            results[key] = repo.cold_ratchet()
+        return results[key]
+
+    kept, restored, lo = families(ids), [], 0
+    while not check(kept)["ok"]:
+        hi = len(kept)
+        while hi - lo > 1:
+            mid = (lo + hi) // 2
+            if check(kept[:mid])["ok"]:
+                lo = mid
+            else:
+                hi = mid
+        restored += _culprit(kept[hi - 1], check(kept[:hi]), check(kept[:hi - 1]))
+        del kept[hi - 1]
+        lo = hi - 1
+    deletion_set.write(_flat(kept))
+    return _flat(kept), restored, check(kept)
+
+
+def _commit(repo, kept: list, by_id: dict) -> str:
+    subject = f"test: delete {len(kept)} redundant test{'' if len(kept) == 1 else 's'}"
+    body = "Each one is contained by another test and the mutation ratchet passes without it:\n" + "\n".join(
+        f"- {t} (contained by {by_id[t]['into']})" for t in kept)
+    repo.git("add", "--", *(repo.test_path(path) for path in sorted(targets(kept))))
+    repo.git("commit", "-q", "-m", subject, "-m", body)
+    return subject
+
+
+def restored_lines(restored: list) -> list:
+    return [f"- `{r['test_id']}`{_cases(r)}: {r['module']} had {r['survivors_with']} survivors with it deleted, baseline "
+            f"{r['baseline']}; {r['survivors_after']} after restoring it" for r in restored]
+
+
+def _cases(restored: dict) -> str:
+    return f" ({len(restored['test_ids'])} parametrized cases)" if len(restored["test_ids"]) > 1 else ""
+
+
+def _deletions_report(heading: str, kept: list, by_id: dict, restored: list, left: list, ratchet: dict) -> list:
+    lines = [f"## {heading} ({len(kept)})", ""]
+    lines += [f"- `{t}`, contained by `{by_id[t]['into']}`: {by_id[t]['reason']}" for t in kept]
+    if restored:
+        lines += ["", f"## Restored by the safety check ({len({t for r in restored for t in r['test_ids']})})", ""]
+        lines += restored_lines(restored)
+    if left:
+        lines += ["", f"## Left for next week ({len(left)})", "",
+                  f"Accepted, over the cap of {CAP} deletions per run (a parametrized test counts each case):", ""]
+        lines += [f"- `{d['test_id']}`, contained by `{d['into']}`" for d in left]
+    lines += ["", "## Mutation ratchet (cold run on this branch)", ""]
+    lines += [f"- {line}" for line in ratchet_lines(ratchet)]
+    return lines
+
+
+def _apply_and_commit(ctx, base: dict, deletions: list) -> tuple[list, list, dict]:
+    """Safety check, make test and the commit; any failure puts every touched test file back."""
+    repo = ctx.repo
+    by_id = {d["test_id"]: d for d in deletions}
+    ids = [d["test_id"] for d in deletions]
+    try:
+        kept, restored, ratchet = safety_check(repo, base, ids)
+        if kept:
+            repo.must_make("test")
+            _commit(repo, kept, by_id)
+    except BaseException:
+        try:
+            DeletionSet(repo, base["commit"], ids).write([])
+        except Fail as kept_edit:  # a file someone else changed stays as it is
+            ctx.state.emit(f"test-prune: {kept_edit}")
+        raise
+    return kept, restored, ratchet
+
+
+def apply(ctx) -> int:
+    repo, base = ctx.repo, ctx.base("interactive")
+    repo.require_at(base, "apply")
+    deletions = ctx.state.load("batch.json")["deletions"]
+    if not deletions:
+        ctx.state.emit("no accepted deletions to apply")
+        return 0
+    kept, restored, ratchet = _apply_and_commit(ctx, base, deletions)
+    head = (f"Committed on {base['branch']}: {repo.git('log', '-1', '--format=%s').strip()}" if kept
+            else "Every deletion was restored: nothing committed")
+    by_id = {d["test_id"]: d for d in deletions}
+    ctx.state.emit("\n".join([head, ""] + _deletions_report("Deletions committed", kept, by_id, restored, [], ratchet)))
+    return 0
+
+
+def _nothing_to_prune(ctx, base: dict, out: dict) -> str:
+    if not ctx.state.load("fixer-input.json")["candidates"]:
+        reason = "no protected candidates" if base["protected"] else "no candidates"
+    else:
+        reason = f"no accepted deletions ({len(out['rejected'])} rejected, {len(out['skipped'])} skipped)"
+    return "\n".join([f"test-prune: {reason}; no branch, no PR"] + suggestions_section(out)
+                     + equivalents_section(out["equivalents"]))
+
+
+def prune(ctx) -> int:
+    repo, base = ctx.repo, ctx.base("unattended")
+    out = ctx.state.load("batch.json")
+    if not out["deletions"]:
+        ctx.state.emit(_nothing_to_prune(ctx, base, out))
+        return 0
+    branch = f"chore/test-prune-{ctx.date}"
+    repo.detach_at(base, branch, "prune")
+    try:
+        return _prune_detached(ctx, base, out, branch)
+    finally:
+        repo.leave_on(base["branch"], base["commit"])
+
+
+def _prune_detached(ctx, base: dict, out: dict, branch: str) -> int:
+    repo = ctx.repo
+    by_id = {d["test_id"]: d for d in out["deletions"]}
+    left = out["left"]
+    kept, restored, ratchet = safety_check(repo, base, [d["test_id"] for d in out["deletions"]])
+    if not kept:
+        ctx.state.emit("\n".join(["test-prune: the safety check restored every accepted deletion; no branch, no PR", ""]
+                       + restored_lines(restored)))
+        return 0
+    def report(heading: str) -> list:
+        return _deletions_report(heading, kept, by_id, restored, left, ratchet)
+
+    try:
+        return _publish(ctx, base, out, branch, kept, report)
+    except Fail as exc:  # the job summary keeps what the safety check found
+        raise Fail("\n".join([f"{exc}", ""] + report(_where(repo, branch)))) from None
+
+
+def _where(repo, branch: str) -> str:
+    """Where the deletions are after a failure past the safety check."""
+    if repo.run_git("rev-parse", "--verify", "-q", f"refs/heads/{branch}").returncode:
+        return "Deletions that passed the safety check, not committed"
+    if repo.run_git("ls-remote", "--heads", "origin", branch).stdout.strip():
+        return f"Deletions on `{branch}`, pushed without a PR"
+    return f"Deletions on the unpushed branch `{branch}`"
+
+
+def _publish(ctx, base: dict, out: dict, branch: str, kept: list, report) -> int:
+    """make test, the commit, the branch, make prune-gate, then the push and the PR."""
+    repo = ctx.repo
+    repo.must_make("test")
+    subject = _commit(repo, kept, {d["test_id"]: d for d in out["deletions"]})
+    repo.git("branch", branch)
+    gate = repo.make("prune-gate", f"BASE={base['commit']}", f"HEAD={branch}")
+    log = ctx.state.save_text("prune-gate.log", gate.stdout + gate.stderr)
+    report_text = capped(gate_report(gate.stdout, gate.stderr), ctx.state.path / "prune-gate-report.md", GATE_LIMIT)
+    gate_output = f"{fenced(report_text)}\n\nThe gate's report; its full log is in `{log}`."
+    if gate.returncode:
+        ctx.state.emit("\n".join([f"test-prune: make prune-gate failed on {branch}; nothing pushed, no PR", "", gate_output, ""]
+                       + report(f"Deletions on the unpushed branch `{branch}`")))
+        return 1
+    body = "\n".join([f"Weekly test prune from `{base['branch']}` at {base['commit'][:12]}. "
+                      "Delete-only; merge it to accept the batch.", ""] + report("Deleted tests")
+                     + ["", "## Prune gate", "", gate_output]
+                     + suggestions_section(out) + equivalents_section(out["equivalents"])) + "\n"
+    repo.push(branch)
+    path, body = ctx.state.save_body("prune-pr.md", body)
+    url = repo.open_pr(base["branch"], branch, subject, path)
+    ctx.state.emit(f"Opened {url}\n\n{body}")
+    return 0