@jesdi/skills 0.0.49 → 0.0.51

package/skills/test-prune/prune_source.py

@@ -0,0 +1,237 @@
+"""Test files on the AST: find a test by id, read its assertions, and compute the delete-only edit.
+
+The edit mirrors what `make prune-gate` point 1 accepts: whole test functions (decorators, the
+comment lines directly above and the blank lines before them), a test class left with nothing but
+its docstring, and a top-level import whose every name only deleted code reads. Nothing else.
+"""
+from __future__ import annotations
+
+import ast
+
+FUNCS = (ast.FunctionDef, ast.AsyncFunctionDef)
+ASSERTING_CALLS = {"raises", "approx", "warns"}
+
+
+def split_id(test_id: str) -> tuple[str, tuple[str, ...], str]:
+    """`tests/x.py::C::f[p]` → (`tests/x.py`, (`C`,), `f`)."""
+    path, *names = test_id.split("[", 1)[0].split("::")
+    return path, tuple(names[:-1]), names[-1]
+
+
+def targets(ids) -> dict:
+    """{test file: {(classes, function)}} for the test ids."""
+    out: dict = {}
+    for test_id in ids:
+        path, classes, name = split_id(test_id)
+        out.setdefault(path, set()).add((classes, name))
+    return out
+
+
+def families(ids) -> list:
+    """Test ids grouped by test function, in order: a parametrize family is deleted, capped, bisected and
+    restored as one unit, because deleting one case deletes the function."""
+    groups: dict = {}
+    for test_id in ids:
+        groups.setdefault(test_id.split("[")[0], []).append(test_id)
+    return list(groups.values())
+
+
+def _span(node: ast.stmt) -> tuple[int, int]:
+    return min([node.lineno, *(d.lineno for d in getattr(node, "decorator_list", []))]), node.end_lineno
+
+
+def find(tree: ast.Module, classes: tuple[str, ...], name: str) -> ast.stmt | None:
+    owner = find_class(tree, classes) if classes else tree
+    return next((n for n in owner.body if isinstance(n, FUNCS) and n.name == name), None) if owner else None
+
+
+def _callee(func: ast.expr) -> str | None:
+    return func.attr if isinstance(func, ast.Attribute) else getattr(func, "id", None)
+
+
+def _asserts_by_call(node: ast.AST) -> bool:
+    return any(isinstance(n, ast.Call) and _callee(n.func) in ASSERTING_CALLS for n in ast.walk(node))
+
+
+def _is_assertion(node: ast.AST) -> bool:
+    if isinstance(node, ast.Assert):
+        return True
+    if isinstance(node, (ast.With, ast.AsyncWith)):
+        return any(_asserts_by_call(item.context_expr) for item in node.items)
+    return isinstance(node, (ast.Expr, ast.Assign, ast.AnnAssign, ast.AugAssign)) and _asserts_by_call(node)
+
+
+def describe(source: str, test_id: str) -> dict | None:
+    """{source, assertions} of the test function behind test_id, or None when the file lacks it."""
+    _, classes, name = split_id(test_id)
+    node = find(ast.parse(source), classes, name)
+    if node is None:
+        return None
+    start, end = _span(node)
+    asserts = sorted((n for n in ast.walk(node) if _is_assertion(n)), key=lambda n: (n.lineno, n.col_offset))
+    return {"source": "".join(source.splitlines(keepends=True)[start - 1:end]),
+            "assertions": [ast.get_source_segment(source, n) for n in asserts]}
+
+
+def _uses(tree: ast.Module) -> tuple[dict[str, set[int]], set[str]]:
+    """name → lines that read, take or spell it; and the names a parameter or a string carries."""
+    uses: dict[str, set[int]] = {}
+    pinned: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Name):
+            name, pin = node.id, False
+        elif isinstance(node, ast.arg):
+            name, pin = node.arg, True
+        elif isinstance(node, ast.Constant) and isinstance(node.value, str):
+            name, pin = node.value, True
+        else:
+            continue
+        uses.setdefault(name, set()).add(node.lineno)
+        if pin:
+            pinned.add(name)
+    return uses, pinned
+
+
+def undeletable(source: str, test_id: str) -> str | None:
+    """Why the prune gate would refuse deleting this test whole, or None."""
+    _, classes, name = split_id(test_id)
+    tree = ast.parse(source)
+    node = find(tree, classes, name)
+    if node is None:
+        return "not a test function defined in its file (inherited or generated), cannot be deleted whole"
+    uses = _uses(tree)[0]
+    if _named_outside(uses, node):
+        return f"the file reads or spells the name {name} outside the test"
+    named = next((cls for cls in _enclosing(tree, classes) if _named_outside(uses, cls)), None)
+    if named is not None:
+        return (f"class {named.name} is subclassed or named elsewhere in the file: deleting its test changes "
+                "what that code inherits or finds")
+    owner = find_class(tree, classes)
+    if owner is not None and owner.body[0] is node and node.decorator_list:
+        return (f"decorated first member of class {owner.name}: the prune gate reads its decorators as the "
+                "class header")
+    return None
+
+
+def _named_outside(uses: dict, node: ast.stmt) -> bool:
+    start, end = _span(node)
+    return bool(uses.get(node.name, set()) - set(range(start, end + 1)))
+
+
+def _enclosing(tree: ast.Module, classes: tuple[str, ...]) -> list:
+    """The class nodes along classes, outermost first."""
+    return [c for c in (find_class(tree, classes[:depth]) for depth in range(1, len(classes) + 1)) if c is not None]
+
+
+def find_class(tree: ast.Module, classes: tuple[str, ...]) -> ast.ClassDef | None:
+    node, body = None, tree.body
+    for cls in classes:
+        node = next((n for n in body if isinstance(n, ast.ClassDef) and n.name == cls), None)
+        if node is None:
+            return None
+        body = node.body
+    return node
+
+
+def _whole_class(node: ast.ClassDef, scope: tuple[str, ...], targets: set) -> bool:
+    body = node.body[1:] if ast.get_docstring(node) is not None else node.body
+    return bool(body) and all(isinstance(m, FUNCS) and (scope, m.name) in targets for m in body)
+
+
+def _marked(body: list[ast.stmt], scope: tuple[str, ...], floor: int, targets: set):
+    """(node, floor) for every statement to delete; floor = last line of the enclosing class header."""
+    for node in body:
+        if isinstance(node, FUNCS) and (scope, node.name) in targets:
+            yield node, floor
+        elif isinstance(node, ast.ClassDef) and _whole_class(node, scope + (node.name,), targets):
+            yield node, floor
+        elif isinstance(node, ast.ClassDef):
+            yield from _marked(node.body, scope + (node.name,), node.body[0].lineno - 1, targets)
+
+
+def _removed_classes(body: list[ast.stmt], scope: tuple[str, ...], parent, targets: set):
+    """(class, its scope, enclosing class or None) for every class the deletion removes whole."""
+    for node in body:
+        if isinstance(node, ast.ClassDef) and _whole_class(node, scope + (node.name,), targets):
+            yield node, scope, parent
+        elif isinstance(node, ast.ClassDef):
+            yield from _removed_classes(node.body, scope + (node.name,), node, targets)
+
+
+def _leaves_empty(parent: ast.ClassDef, scope: tuple[str, ...], targets: set) -> bool:
+    """Whether deleting targets leaves the class with no statement at all."""
+    def removed(m: ast.stmt) -> bool:
+        if isinstance(m, FUNCS):
+            return (scope, m.name) in targets
+        return isinstance(m, ast.ClassDef) and _whole_class(m, scope + (m.name,), targets)
+    return all(removed(m) for m in parent.body)
+
+
+def class_refusals(source: str, test_ids: list) -> dict:
+    """{test id: reason} for tests whose deletion together removes a nested class and leaves its
+    enclosing class empty (a class named outside itself is refused per test, by undeletable)."""
+    tree = ast.parse(source)
+    targets = {split_id(t)[1:] for t in test_ids}
+    out: dict = {}
+    for node, scope, parent in _removed_classes(tree.body, (), None, targets):
+        if parent is not None and _leaves_empty(parent, scope, targets):
+            path = scope + (node.name,)
+            reason = f"deleting it removes class {node.name} and leaves class {parent.name} empty"
+            out.update({t: reason for t in test_ids if split_id(t)[1][:len(path)] == path})
+    return out
+
+
+def _with_surroundings(lines: list[str], start: int, end: int, floor: int) -> set[int]:
+    """The statement's lines, the comment lines directly above, the blank lines before those; when
+    that reaches the class header or the file start, the blank lines after instead."""
+    first = start
+    while first - 1 > floor and lines[first - 2].strip().startswith("#"):
+        first -= 1
+    while first - 1 > floor and not lines[first - 2].strip():
+        first -= 1
+    last = end
+    if first - 1 == floor:
+        while last < len(lines) and not lines[last].strip():
+            last += 1
+    return set(range(first, last + 1))
+
+
+def _dead_imports(tree: ast.Module, removed: set) -> set:
+    """Lines of top-level imports whose every name is read only on removed lines (never a name a
+    parameter or a string carries: a fixture, a usefixtures marker)."""
+    uses, pinned = _uses(tree)
+    dead: set = set()
+    for node in tree.body:
+        if isinstance(node, (ast.Import, ast.ImportFrom)):
+            names = {(a.asname or a.name).split(".")[0] for a in node.names}
+            if not names & pinned and all(uses.get(n) and uses[n] <= removed for n in names):
+                dead |= set(range(node.lineno, node.end_lineno + 1))
+    return dead
+
+
+def delete_tests(source: str, targets: set[tuple[tuple[str, ...], str]]) -> str:
+    """source without the test functions in targets ({(classes, name)}), shaped for the prune gate."""
+    tree = ast.parse(source)
+    lines = source.splitlines(keepends=True)
+    removed: set[int] = set()
+    for node, floor in list(_marked(tree.body, (), 0, targets)):
+        removed |= _with_surroundings(lines, *_span(node), floor)
+    removed |= _dead_imports(tree, removed)
+    return "".join(line for number, line in enumerate(lines, 1) if number not in removed)
+
+
+def test_sources(source: str) -> dict[str, str]:
+    """`[Class::]name` → source of every test function in the file."""
+    out: dict[str, str] = {}
+    lines = source.splitlines()
+
+    def walk(body: list[ast.stmt], prefix: str) -> None:
+        for node in body:
+            if isinstance(node, FUNCS) and node.name.startswith("test"):
+                start, end = _span(node)
+                out[prefix + node.name] = "\n".join(lines[start - 1:end])
+            elif isinstance(node, ast.ClassDef):
+                walk(node.body, f"{prefix}{node.name}::")
+
+    walk(ast.parse(source).body, "")
+    return out

package/skills/test-prune/prune_strengthen.py

@@ -0,0 +1,301 @@
+"""strengthen-start, strengthen-verify and strengthen-finish: prove each strengthen item kills the
+mutant ids it names (surviving on the base, killed on the head), keep what the reviewer accepts,
+lower the baseline, and (unattended) open the strengthen PR from the base commit."""
+from __future__ import annotations
+
+import json
+
+from prune_repo import KILLED, SURVIVING, BadInput, Fail, Repo, ratchet_lines
+from prune_review import check_reviews, equivalents_section, suggestions_section
+from prune_source import test_sources
+
+TRAILER = "Test-Prune-Item"
+BASELINE = "backend/mutation_baseline.json"
+
+
+def _branch(ctx) -> str:
+    return f"chore/test-strengthen-{ctx.date}"
+
+
+def _work_item(item: dict) -> dict:
+    candidate = item.get("candidate") or {}
+    return {"id": item["id"], "kind": item["kind"], "mutant_ids": item.get("mutant_ids", []),
+            "module": item.get("module"), "function": item.get("function"),
+            "test": item.get("test") or item.get("test_id"), "assertion": item.get("assertion"),
+            "source": candidate.get("source"), "reason": item.get("fixer_reason"), "review": item["reason"]}
+
+
+def strengthen_start(ctx) -> int:
+    repo, base = ctx.repo, ctx.base()
+    out = ctx.state.load("batch.json")
+    items = [i for i in out["strengthen"] if i["kind"] == "weak_spot"]
+    if not items:
+        ctx.state.emit("\n".join(["nothing to strengthen"] + suggestions_section(out)
+                                  + equivalents_section(out["equivalents"], shown=5)))
+        ctx.finished = True
+        return 0
+    if base["mode"] == "unattended":
+        repo.detach_at(base, _branch(ctx), "strengthen-start")
+    else:
+        repo.require_clean()
+    start = repo.head()
+    work = [_work_item(i) for i in items]
+    ctx.state.save("strengthen.json", {"start": start, "verified": False, "items": work,
+                                       "status": {i["id"]: "open" for i in work}, "closed": {}})
+    path = ctx.state.save("strengthen-input.json", {"start": start, "items": work})
+    ctx.state.emit(f"{len(work)} strengthen items → {path}\nCommit each item test-first on top of {start[:12]}: one or more "
+         f"commits per item, each touching only backend/tests/ and ending with the trailer `{TRAILER}: <item id>`.")
+    return 0
+
+
+def _history(repo, start: str) -> list:
+    """[(sha, trailer values, paths)] for every commit since start, oldest first."""
+    out = []
+    for sha in repo.git("rev-list", "--reverse", f"{start}..HEAD").split():
+        values = repo.git("log", "-1", f"--format=%(trailers:key={TRAILER},valueonly)", sha).split("\n")
+        paths = repo.git("diff-tree", "--no-commit-id", "--name-only", "-r", sha).split()
+        out.append((sha, [v.strip() for v in values if v.strip()], paths))
+    return out
+
+
+def commit_problems(sha: str, items: list, paths: list, known: set) -> list:
+    problems = [f"{sha[:12]}: touches {p}, outside backend/tests/" for p in paths if not p.startswith("backend/tests/")]
+    if len(items) != 1 or items[0] not in known:
+        problems.insert(0, f"{sha[:12]}: needs exactly one `{TRAILER}` trailer naming a strengthen item, has {items}")
+    return problems
+
+
+def reopened(history: list, closed: dict) -> list:
+    """Commits naming an item after test-prune closed it (reverted or rejected at the recorded commit)."""
+    position = {sha: i for i, (sha, _, _) in enumerate(history)}
+    return [f"{sha[:12]}: {items[0]} was closed at {closed[items[0]][:12]}; new commits for it are refused"
+            for i, (sha, items, _) in enumerate(history)
+            if len(items) == 1 and items[0] in closed and i > position.get(closed[items[0]], -1)]
+
+
+def _commits(repo, st: dict) -> list:
+    """[(sha, item id)] since start; every commit must name a known, open item and touch only backend/tests/."""
+    start = st["start"]
+    if repo.run_git("merge-base", "--is-ancestor", start, "HEAD").returncode:
+        raise BadInput(f"HEAD does not descend from the strengthen start {start}")
+    errors = ["merge commits since the strengthen start"] if repo.git(
+        "rev-list", "--min-parents=2", f"{start}..HEAD").strip() else []
+    history = _history(repo, start)
+    known = {i["id"] for i in st["items"]}
+    for sha, items, paths in history:
+        errors += commit_problems(sha, items, paths, known)
+    errors += reopened(history, st["closed"])
+    if errors:
+        raise BadInput("strengthen commits rejected:\n" + "\n".join(errors))
+    return [(sha, items[0]) for sha, items, _ in history]
+
+
+def _revert(repo, item_id: str, commits: list, why: str) -> None:
+    shas = [sha for sha, item in reversed(commits) if item == item_id]
+    if not shas:
+        return
+    if repo.run_git("revert", "--no-commit", *shas).returncode:
+        repo.run_git("revert", "--abort")
+        raise Fail(f"reverting strengthen item {item_id} conflicts with a later item's commits")
+    repo.git("commit", "-q", "--allow-empty", "-m", f"Revert test-prune item {item_id}", "-m", why,
+             "-m", f"{TRAILER}: {item_id}")
+
+
+def _close(repo, st: dict, item_id: str, commits: list, status: str, why: str) -> None:
+    """Revert the item's commits and record where it closed: later commits for it are refused."""
+    _revert(repo, item_id, commits, why)
+    st["status"][item_id] = status
+    st["closed"][item_id] = repo.head()
+
+
+def item_proof(base_codes: dict, codes: dict, item: dict, has_commits: bool) -> dict:
+    """Per mutant id the base and head exit codes; proven when the item names at least one id, every id
+    survived on the base and is killed on the head, and the item has a commit."""
+    module = item.get("module")
+    mutants = {m: {"base": base_codes.get(module, {}).get(m), "head": codes.get(module, {}).get(m)}
+               for m in item["mutant_ids"]}
+    proven = has_commits and bool(mutants) and all(e["base"] in SURVIVING and e["head"] in KILLED for e in mutants.values())
+    return {"status": "proven" if proven else "unproven", "module": module, "mutants": mutants}
+
+
+def _judge(ctx, base: dict, st: dict, proof: dict, commits: list) -> list:
+    """One cold run; records each open item's proof and returns the unproven ones."""
+    ctx.repo.cold_mutation()
+    codes = ctx.repo.mutant_codes()
+    items = {i["id"]: i for i in st["items"]}
+    failing = []
+    for item_id in [i for i, s in st["status"].items() if s in ("open", "proven")]:
+        proof[item_id] = item_proof(base["mutants"], codes, items[item_id], any(c[1] == item_id for c in commits))
+        st["status"][item_id] = proof[item_id]["status"]
+        if st["status"][item_id] == "unproven":
+            failing.append(item_id)
+    return failing
+
+
+def _prove(ctx, base: dict, st: dict) -> dict:
+    """Cold runs until every remaining item is proven; unproven items are reverted between runs."""
+    path = ctx.state.path / "strengthen-proof.json"
+    proof = json.loads(path.read_text())["items"] if path.exists() else {}
+    while True:
+        commits = _commits(ctx.repo, st)
+        failing = _judge(ctx, base, st, proof, commits)
+        for item_id in failing:
+            _close(ctx.repo, st, item_id, commits, "reverted",
+                   "Its mutant ids are not all killed on the head while surviving on the base.")
+            proof[item_id]["status"] = "reverted"
+        ctx.state.save("strengthen.json", st)
+        ctx.state.save("strengthen-proof.json", {"start": st["start"], "head": ctx.repo.head(), "items": proof})
+        if not failing:
+            return proof
+
+
+def _proof_lines(proof: dict) -> list:
+    lines = []
+    for item_id, entry in proof.items():
+        lines.append(f"- {item_id}: {entry['status']}")
+        lines += [f"    {m}: base exit code {e['base']}, head exit code {e['head']}" for m, e in entry["mutants"].items()]
+    return lines
+
+
+def strengthen_verify(ctx) -> int:
+    base = ctx.base()
+    st = ctx.state.load("strengthen.json")
+    ctx.repo.require_clean()
+    proof = _prove(ctx, base, st)
+    st["verified"] = True
+    ctx.state.save("strengthen.json", st)
+    ctx.state.emit("\n".join(["Strengthen proof (survives on the base, killed on the head, per mutant id):"] + _proof_lines(proof)))
+    return 0
+
+
+def changed_tests(before: str, after: str, path: str) -> list:
+    """Test ids in the file at path that are new or changed from before to after."""
+    old, rel = test_sources(before), path[len(Repo.test_path("")):]
+    return [f"{rel}::{name}" for name, text in test_sources(after).items() if old.get(name) != text]
+
+
+def _commit_tests(repo, sha: str) -> list:
+    paths = repo.git("diff-tree", "--no-commit-id", "--name-only", "-r", sha).split()
+    return [t for path in paths if path.endswith(".py")
+            for t in changed_tests(repo.show(f"{sha}^", path) or "", repo.show(sha, path) or "", path)]
+
+
+def _item_tests(repo, commits: list, item_id: str) -> list:
+    changed: list = []
+    for sha in (sha for sha, item in commits if item == item_id):
+        changed += [t for t in _commit_tests(repo, sha) if t not in changed]
+    return changed
+
+
+def _guard_equivalents(repo, base: dict, new: dict) -> None:
+    gained = {m: sorted(set(e.get("equivalent", {})) - set(base["baseline"].get(m, {}).get("equivalent", {})))
+              for m, e in new.items()}
+    gained = {m: ids for m, ids in gained.items() if ids}
+    if gained:
+        repo.git("checkout", "-q", "HEAD", "--", BASELINE)
+        raise Fail("guard: the baseline update gained equivalent ids test-prune never declares: "
+                   + "; ".join(f"{m}: {', '.join(ids)}" for m, ids in gained.items()))
+
+
+def _test_lines(items: dict, accepted: list, tests: dict) -> list:
+    lines = []
+    for item_id in accepted:
+        ids = items[item_id]["mutant_ids"]
+        kills = f"now kills {', '.join(f'`{m}`' for m in ids)}" if ids else f"adds `{items[item_id]['assertion']}`"
+        lines += [f"- `{t}` ({item_id}) {kills}" for t in tests[item_id]] or [f"- {item_id}: {kills}"]
+    return lines
+
+
+def _body(base: dict, st: dict, proof: dict, accepted: list, tests: dict, new: dict, ratchet: str, out: dict) -> str:
+    lines = [f"Strengthened tests from `{base['branch']}` at {base['commit'][:12]}, independent of the prune PR. "
+             "Every mutant id listed survived the cold mutation run on the base and is killed by the cold run on "
+             "this branch.", "", "## Changed tests", ""]
+    lines += _test_lines({i["id"]: i for i in st["items"]}, accepted, tests)
+    lines += ["", "## Proof per mutant id", ""]
+    lines += [f"- `{m}` ({proof[i]['module']}): survived the base run (exit code {e['base']}), killed on this "
+              f"branch (exit code {e['head']})" for i in accepted for m, e in proof[i]["mutants"].items()]
+    lines += ["", "## Baseline survivors", ""]
+    lines += [f"- {m}: {base['baseline'].get(m, {}).get('survivors', 'new')} → {e['survivors']}" for m, e in new.items()]
+    lines += ["", "## Mutation ratchet", "", "```", ratchet.strip(), "```"]
+    return "\n".join(lines + suggestions_section(out) + equivalents_section(out["equivalents"])) + "\n"
+
+
+def _finish_reviews(ctx, st: dict) -> dict:
+    """Preconditions: verified, clean, HEAD still the proven head, a new branch name, valid reviews."""
+    if not st["verified"]:
+        raise BadInput("run strengthen-verify first")
+    ctx.repo.require_clean()
+    proven_head = ctx.state.load("strengthen-proof.json")["head"]
+    if ctx.repo.head() != proven_head:
+        raise BadInput(f"HEAD moved since strengthen-verify proved {proven_head[:12]}: run strengthen-verify again")
+    if ctx.base()["mode"] == "unattended":
+        ctx.repo.require_new_branch(_branch(ctx))
+    return check_reviews(ctx.reviews(), [i for i, s in st["status"].items() if s == "proven"])
+
+
+def strengthen_finish(ctx) -> int:
+    repo, base = ctx.repo, ctx.base()
+    st = ctx.state.load("strengthen.json")
+    unattended = base["mode"] == "unattended"
+    leave = unattended
+    try:
+        code = _finish(ctx, base, st, _finish_reviews(ctx, st), unattended)
+    except BadInput:
+        leave = False  # HEAD stays at the proven head: fix the input and rerun
+        raise
+    finally:
+        if leave:
+            repo.leave_on(base["branch"], base["commit"])
+    ctx.finished = code == 0
+    return code
+
+
+def _keep_accepted(ctx, base: dict, st: dict, reviews: dict) -> tuple[dict, list]:
+    rejected = [i for i, review in reviews.items() if review["verdict"] == "reject"]
+    if rejected:  # a revert changes the head: prove the rest again, cold
+        commits = _commits(ctx.repo, st)
+        for item_id in rejected:
+            _close(ctx.repo, st, item_id, commits, "rejected", f"Rejected by the reviewer: {reviews[item_id]['reason']}")
+        proof = _prove(ctx, base, st)
+    else:
+        proof = ctx.state.load("strengthen-proof.json")["items"]
+    return proof, [i for i, s in st["status"].items() if s == "proven"]
+
+
+def _lower_baseline(repo, base: dict) -> tuple[str, dict]:
+    """The ratchet, test and crap targets, then the baseline update behind the equivalent guard."""
+    ratchet = repo.must_make("mutation-check")
+    repo.must_make("test")
+    repo.must_make("crap")
+    repo.must_make("mutation-baseline")
+    repo.own(BASELINE)  # only once the target passed: after a failure its bytes are not provably the run's
+    new = json.loads((repo.root / BASELINE).read_text())
+    _guard_equivalents(repo, base, new)
+    if repo.git("status", "--porcelain", "--", BASELINE).strip():
+        repo.git("add", "--", BASELINE)
+        repo.git("commit", "-q", "-m", "test: lower the mutation baseline",
+                 "-m", "The strengthened tests kill mutants that survived on the base.")
+    return "\n".join(ratchet_lines({"output": ratchet})), new
+
+
+def _finish(ctx, base: dict, st: dict, reviews: dict, unattended: bool) -> int:
+    repo = ctx.repo
+    proof, accepted = _keep_accepted(ctx, base, st, reviews)
+    if not accepted:
+        ctx.state.emit("test-prune: nothing proven and accepted to strengthen; no branch, no PR")
+        return 0
+    ratchet, new = _lower_baseline(repo, base)
+    commits = [(sha, items[0]) for sha, items, _ in _history(repo, st["start"]) if items]
+    tests = {i: _item_tests(repo, commits, i) for i in accepted}
+    body = _body(base, st, proof, accepted, tests, new, ratchet, ctx.state.load("batch.json"))
+    if not unattended:
+        ctx.state.emit(f"Strengthen commits kept on {repo.branch()}:\n\n{body}")
+        return 0
+    branch = _branch(ctx)
+    repo.git("branch", branch)
+    repo.push(branch)
+    title = f"test: strengthen {len(accepted)} weak spot{'' if len(accepted) == 1 else 's'}"
+    path, body = ctx.state.save_body("strengthen-pr.md", body)
+    url = repo.open_pr(base["branch"], branch, title, path)
+    ctx.state.emit(f"Opened {url}\n\n{body}")
+    return 0

package/skills/test-prune/tests/conftest.py

@@ -0,0 +1,15 @@
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # the prune modules are one folder up
+
+from prune_harness import Target  # noqa: E402
+
+collect_ignore = ["testdata"]
+
+
+@pytest.fixture
+def target(tmp_path):
+    return Target(tmp_path)