@jesdi/skills 0.0.50 → 0.0.51

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

@@ -0,0 +1,97 @@
+"""Agent-input guards and proof rules, checked in-process: each rejection names its id."""
+import json
+
+import pytest
+
+from prune_repo import BadInput, Fail, parse_ratchet, read_agent_json
+from prune_review import candidate_problems, group_problems
+from prune_strengthen import changed_tests, commit_problems, item_proof, reopened
+
+TESTS = {"tests/t.py::a", "tests/t.py::b"}
+
+
+@pytest.mark.parametrize("entry, problem", [
+    ({"verdict": "drop", "reason": "r"}, "verdict 'drop'"),
+    ({"verdict": "delete", "into": "tests/t.py::a", "reason": "r"}, "not another collected test id"),
+    ({"verdict": "strengthen", "assertion": " ", "reason": "r"}, "names no assertion"),
+    ({"verdict": "delete", "into": "tests/t.py::b"}, "no reason"),
+])
+def test_candidate_problems_name_the_candidate(entry, problem):
+    (message,) = candidate_problems("tests/t.py::a", entry, TESTS)
+    assert message.startswith("candidate tests/t.py::a:") and problem in message
+
+
+def test_a_kept_candidate_needs_no_reason():
+    assert candidate_problems("tests/t.py::a", {"verdict": "keep"}, TESTS) == []
+
+
+GROUP = {"group": "m.f", "mutant_ids": ["x_f__mutmut_1", "x_f__mutmut_2"]}
+
+
+@pytest.mark.parametrize("entry, problem", [
+    ({"verdict": "delete", "reason": "r"}, "verdict 'delete'"),
+    ({"verdict": "strengthen", "mutant_ids": [], "reason": "r"}, "non-empty list"),
+    ({"verdict": "equivalent", "mutant_ids": ["x_f__mutmut_9"], "reason": "r"}, "x_f__mutmut_9 is not one"),
+    ({"verdict": "strengthen"}, "no reason"),
+])
+def test_group_problems_name_the_group(entry, problem):
+    (message,) = group_problems(GROUP, entry)
+    assert message.startswith("weak spot m.f:") and problem in message
+
+
+@pytest.mark.parametrize("content", ["not json", "[]", '{"reviews": {}}', '{"reviews": [1]}'])
+def test_read_agent_json_rejects_malformed_files(tmp_path, content):
+    path = tmp_path / "reviews.json"
+    path.write_text(content)
+    with pytest.raises(BadInput, match="reviews"):
+        read_agent_json(str(path), "reviews")
+
+
+def test_read_agent_json_names_a_missing_file(tmp_path):
+    with pytest.raises(BadInput, match="cannot read"):
+        read_agent_json(str(tmp_path / "nope.json"), "reviews")
+    (tmp_path / "ok.json").write_text(json.dumps({"reviews": [{"id": "a"}]}))
+    assert read_agent_json(str(tmp_path / "ok.json"), "reviews") == [{"id": "a"}]
+
+
+def test_commit_problems_need_one_known_trailer_and_test_paths_only():
+    assert commit_problems("a" * 40, ["m.f"], ["backend/tests/t.py"], {"m.f"}) == []
+    trailer, outside = commit_problems("a" * 40, ["m.f", "m.g"], ["backend/services/x.py"], {"m.f"})
+    assert "exactly one" in trailer and "backend/services/x.py" in outside
+    assert commit_problems("a" * 40, [], [], {"m.f"})
+
+
+def test_item_proof_needs_survived_on_base_and_killed_on_head_per_id():
+    item = {"module": "s.py", "mutant_ids": ["m1", "m2"]}
+    base = {"s.py": {"m1": 0, "m2": 33}}
+
+    assert item_proof(base, {"s.py": {"m1": 1, "m2": 3}}, item, True)["status"] == "proven"
+    assert item_proof(base, {"s.py": {"m1": 1, "m2": 0}}, item, True)["status"] == "unproven"
+    assert item_proof(base, {"s.py": {"m1": 1, "m2": 3}}, item, False)["status"] == "unproven"
+    assert item_proof({"s.py": {"m1": 1, "m2": 0}}, {"s.py": {"m1": 1, "m2": 1}}, item, True)["status"] == "unproven"
+
+
+def test_changed_tests_lists_new_and_edited_tests():
+    before = "def test_a():\n    assert 1\n\n\ndef test_b():\n    assert 2\n"
+    after = "def test_a():\n    assert 1\n\n\ndef test_b():\n    assert 3\n\n\nclass TestC:\n    def test_c(self):\n        pass\n"
+
+    assert changed_tests(before, after, "backend/tests/t.py") == ["tests/t.py::test_b", "tests/t.py::TestC::test_c"]
+
+
+def test_a_ratchet_failure_without_survivor_counts_is_operational():
+    with pytest.raises(Fail, match="without a survivor count"):
+        parse_ratchet("  ✗ services/x.py: no mutmut results, run 'make mutation'\n", 1)
+    ratchet = parse_ratchet("  ✗ services/x.py: 23 survivors > baseline 20 (score 1.00)\n", 1)
+    assert ratchet["failed"] == ["services/x.py"] and ratchet["modules"]["services/x.py"] == [23, 20]
+
+
+def test_an_item_without_mutant_ids_is_never_proven():
+    assert item_proof({}, {}, {"module": None, "mutant_ids": []}, True)["status"] == "unproven"
+
+
+def test_commits_after_an_item_closed_are_reopenings():
+    history = [("a" * 40, ["m.f"], []), ("b" * 40, ["m.f"], []), ("c" * 40, ["m.f"], []), ("d" * 40, ["m.g"], [])]
+
+    (problem,) = reopened(history, {"m.f": "b" * 40})
+    assert problem.startswith("cccccccccccc: m.f was closed")
+    assert reopened(history, {"m.g": "start"}) and not reopened(history, {})

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

@@ -0,0 +1,113 @@
+"""Fixer/reviewer hand-off, interactive mode and input guards (ticket 21)."""
+from prune_harness import REFERENCE, R, cand, case
+
+
+def test_reviewer_rejects_zero_weight_into_small_weight_with_the_boundary_reason(target):
+    zero, small = R + "test_zero_weight", R + "test_small_weight"
+    reason = "test_zero_weight asserts the zero-weight boundary (a full buy at 0.0); test_small_weight never checks 0"
+
+    out = target.prepare([cand(zero, small)], unattended=False, deletions={zero: small},
+                         accept=(), reasons={zero: reason}).stdout
+
+    # The fixer saw the candidate's and the container's source and assertions.
+    (fixer_cand,) = target.read_state("fixer-input.json")["candidates"]
+    assert fixer_cand["test_id"] == zero and fixer_cand["contained_by"] == [small]
+    assert "def test_zero_weight(targets):" in fixer_cand["source"]
+    assert [c["test_id"] for c in fixer_cand["containers"]] == [small]
+
+    # The reviewer sees both tests' assertions, not only coverage.
+    (proposal,) = [p for p in target.read_state("review-input.json")["proposals"] if p["id"] == zero]
+    assert proposal["kind"] == "delete"
+    assert proposal["candidate"]["test_id"] == zero and proposal["into"]["test_id"] == small
+    assert any('trades["AAA"] == pytest.approx(0.6)' in a for a in proposal["candidate"]["assertions"])
+    assert any('assert trades["AAA"] > 0' in a for a in proposal["into"]["assertions"])
+    assert any('assert set(trades) == {"AAA", "BBB"}' in a for a in proposal["into"]["assertions"])
+    assert "def test_small_weight(targets):" in proposal["into"]["source"]
+
+    batch = target.read_state("batch.json")
+    assert zero not in [d["test_id"] for d in batch["deletions"]]
+    assert {"id": zero, "kind": "delete", "reason": reason} in batch["rejected"]
+    assert zero in out and reason in out
+
+
+def test_interactive_twelve_deletions_and_three_strengthen_edit_nothing_before_approval(target):
+    tests_dir = target.root / "backend" / "tests"
+    before = {p.name: p.read_bytes() for p in tests_dir.iterdir() if p.is_file()}
+    deletions = {case(i): REFERENCE for i in range(1, 13)}
+    strengthen = {case(i): "assert herfindahl([0.25] * 4) == pytest.approx(0.25)" for i in range(13, 16)}
+
+    target.prepare([cand(case(i)) for i in range(1, 16)], unattended=False,
+                   accept=[*deletions, *strengthen], deletions=deletions, strengthen=strengthen)
+
+    batch = target.read_state("batch.json")
+    assert sorted(d["test_id"] for d in batch["deletions"]) == sorted(deletions)
+    assert sorted(s["id"] for s in batch["strengthen"] if s["kind"] == "candidate") == sorted(strengthen)
+    assert target.git("status", "--porcelain") == ""
+    assert {p.name: p.read_bytes() for p in tests_dir.iterdir() if p.is_file()} == before
+    assert target.git("rev-parse", "HEAD").strip() == target.base
+
+
+def test_interactive_apply_commits_approved_deletions_and_restores_the_culprit(target):
+    culprit = R + "test_sell_only_rebalance"
+    deletions = {case(1): REFERENCE, case(2): REFERENCE, culprit: R + "test_hold_when_on_target"}
+    target.prepare([cand(t, into) for t, into in deletions.items()], unattended=False,
+                   accept=list(deletions), deletions=deletions)
+
+    out = target.ok("apply").stdout
+
+    assert target.git("symbolic-ref", "--short", "HEAD").strip() == "main"
+    assert target.git("log", "-1", "--format=%s").strip() == "test: delete 2 redundant tests"
+    assert target.git("rev-parse", "HEAD~1").strip() == target.base
+    head_ids = target.ids_at("HEAD")
+    assert case(1) not in head_ids and case(2) not in head_ids and culprit in head_ids
+    assert target.git("status", "--porcelain") == ""
+    assert culprit in out
+
+
+def test_apply_in_an_unattended_state_exits_2(target):
+    target.prepare([cand(case(1))], accept=[case(1)], deletions={case(1): REFERENCE})
+
+    proc = target.run("apply")
+
+    assert proc.returncode == 2, proc.stdout + proc.stderr
+    assert target.git("rev-parse", "HEAD").strip() == target.base
+    assert target.git("status", "--porcelain") == ""
+
+
+def test_prune_in_an_interactive_state_exits_2(target):
+    target.prepare([cand(case(1))], unattended=False, accept=[case(1)], deletions={case(1): REFERENCE})
+
+    proc = target.run("prune")
+
+    assert proc.returncode == 2, proc.stdout + proc.stderr
+    assert target.remote_branches() == {"main"}
+    assert target.log("gh") == []
+    assert target.git("status", "--porcelain") == ""
+
+
+def test_collect_on_a_dirty_tracked_tree_exits_2(target):
+    path = target.root / "backend" / "tests" / "test_rebalancer.py"
+    path.write_text(path.read_text() + "\n# local edit\n")
+    target.set_candidates([cand(case(1))])
+
+    proc = target.run("collect")
+
+    assert proc.returncode == 2, proc.stdout + proc.stderr
+    assert "test_rebalancer.py" in proc.stdout + proc.stderr
+    assert target.log("mutation") == []
+
+
+def test_invalid_proposals_exit_2_naming_the_ids(target):
+    target.set_candidates([cand(case(1)), cand(case(2))])
+    target.ok("collect")
+
+    missing = target.proposals(deletions={case(1): REFERENCE})
+    missing["candidates"] = [c for c in missing["candidates"] if c["test_id"] != case(2)]
+    proc = target.review_input(missing)
+    assert proc.returncode == 2, proc.stdout + proc.stderr
+    assert case(2) in proc.stdout + proc.stderr
+
+    nope = "tests/test_concentration.py::test_nope"
+    proc = target.review_input(target.proposals(deletions={case(1): nope}))
+    assert proc.returncode == 2, proc.stdout + proc.stderr
+    assert nope in proc.stdout + proc.stderr

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

@@ -0,0 +1,84 @@
+"""Deletion-shape edges the fixture repo does not reach, checked in-process (prune_source)."""
+from prune_source import class_refusals, delete_tests, describe, undeletable
+from prune_source import test_sources as sources
+
+EDGES = '''"""Edges."""
+import os
+import json as j
+from typing import Any
+from helpers import make_thing, other
+
+
+class TestFirst:
+    def test_first(self):
+        assert os.sep
+
+    def test_second(self):
+        assert True
+
+
+def test_uses_param(other):
+    assert other
+
+
+def test_anno(x: "Any"):
+    assert make_thing()
+    assert j.dumps({}) == "{}"
+
+
+def test_kept():
+    with pytest.raises(ValueError):
+        int("x")
+'''
+
+
+def test_first_class_member_takes_the_blank_lines_after_it_and_pinned_imports_stay():
+    out = delete_tests(EDGES, {(("TestFirst",), "test_first"), ((), "test_uses_param"), ((), "test_anno")})
+
+    assert "class TestFirst:\n    def test_second(self):" in out
+    assert "import os\n" not in out and "import json as j\n" not in out  # read only by deleted tests
+    assert "from typing import Any\n" in out  # a string carries Any
+    assert "from helpers import make_thing, other\n" in out  # a parameter carries other
+    assert out.endswith('        int("x")\n')
+
+
+def test_undeletable_names_what_the_prune_gate_would_refuse():
+    decorated = "import pytest\n\n\nclass TestX:\n    @pytest.mark.slow\n    def test_a(self):\n        assert 1\n"
+    named = "def test_a():\n    assert 1\n\n\nALIAS = test_a\n"
+
+    assert "decorated first member" in undeletable(decorated, "tests/t.py::TestX::test_a")
+    assert "reads or spells the name test_a" in undeletable(named, "tests/t.py::test_a")
+    assert "cannot be deleted whole" in undeletable(named, "tests/t.py::test_missing")
+    assert undeletable(EDGES, "tests/t.py::TestFirst::test_second") is None
+
+
+def test_describe_lists_raises_blocks_and_misses_unknown_tests():
+    found = describe(EDGES, "tests/t.py::test_kept")
+
+    assert found["assertions"] == ['with pytest.raises(ValueError):\n        int("x")']
+    assert describe(EDGES, "tests/t.py::TestNope::test_kept") is None
+
+
+def test_a_test_in_a_class_named_elsewhere_is_undeletable():
+    subclassed = "class TestBase:\n    def test_a(self):\n        assert 1\n\n    def test_b(self):\n        assert 2\n\n\nclass TestChild(TestBase):\n    def test_c(self):\n        assert 3\n"
+    spelled = "class TestA:\n    def test_a(self):\n        assert 1\n\n\ndef test_b():\n    assert 'TestA'\n"
+
+    assert "class TestBase is subclassed" in undeletable(subclassed, "tests/t.py::TestBase::test_a")  # partial
+    assert "class TestA is subclassed or named" in undeletable(spelled, "tests/t.py::TestA::test_a")
+    assert undeletable(subclassed, "tests/t.py::TestChild::test_c") is None
+
+
+def test_class_refusals_keep_an_enclosing_class_non_empty():
+    nested = "class TestOuter:\n    class TestInner:\n        def test_a(self):\n            assert 1\n"
+    documented = 'class TestOuter:\n    """Doc."""\n\n    class TestInner:\n        def test_a(self):\n            assert 1\n'
+    inner = "tests/t.py::TestOuter::TestInner::test_a"
+
+    assert "leaves class TestOuter empty" in class_refusals(nested, [inner])[inner]
+    assert class_refusals(documented, [inner]) == {}
+
+
+def test_a_new_parametrize_case_changes_the_test_source():
+    before = "@pytest.mark.parametrize('x', [1])\ndef test_x(x):\n    assert x\n"
+    after = before.replace("[1]", "[1, 2]")
+
+    assert sources(before)["test_x"] != sources(after)["test_x"]

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

@@ -0,0 +1,183 @@
+"""Strengthen PR, equivalent proposals and cold mutation runs (ticket 21)."""
+import json
+import re
+
+from prune_harness import PRUNE_BRANCH, REFERENCE, STRENGTHEN_BRANCH, R, arg, cand, case
+
+COMPUTE = "rebalancer.compute_trades"
+DRIFT = "rebalancer.apply_drift"
+HERFINDAHL = "concentration.herfindahl"
+IDS_7_9 = ["x_compute_trades__mutmut_7", "x_compute_trades__mutmut_9"]
+EQUIVALENT_ID = "x_herfindahl__mutmut_9"
+EQUIVALENT_REASON = "the <= mutant only differs on an empty weight list, which herfindahl never receives"
+
+COMPUTE_TEST = '''
+def test_compute_trades_rounding(targets):
+    trades = compute_trades({"AAA": 0.333, "BBB": 0.667}, targets)
+    assert round(trades["AAA"], 3) == 0.267
+'''
+DRIFT_TEST = '''
+def test_apply_drift_new():
+    assert apply_drift(-0.5) == 0
+'''  # kills x_apply_drift__mutmut_2 only, not _4
+
+
+def strengthen_group(ids, reason="fixer: no test pins this"):
+    return {"verdict": "strengthen", "mutant_ids": ids, "test": "tests/test_rebalancer.py", "reason": reason}
+
+
+def codes_for(proof, mutant_id):
+    """(base code, head code) of mutant_id anywhere in strengthen-proof.json."""
+    found = []
+
+    def walk(node):
+        if isinstance(node, dict):
+            if mutant_id in node and isinstance(node[mutant_id], dict):
+                found.append(node[mutant_id])
+            if mutant_id in (node.get("mutant_id"), node.get("id")):
+                found.append(node)
+            for value in node.values():
+                walk(value)
+        elif isinstance(node, list):
+            for value in node:
+                walk(value)
+
+    walk(proof)
+    assert found, f"{mutant_id} not in strengthen-proof.json: {proof}"
+    entry = found[0]
+    base = next(v for k, v in entry.items() if k.startswith("base"))
+    head = next(v for k, v in entry.items() if k.startswith("head"))
+    return base, head
+
+
+def baseline_at(target, ref):
+    return json.loads(target.show(ref, "backend/mutation_baseline.json"))
+
+
+def strengthen(target, agent_tests, finish_accept, env=None, before=lambda: None):
+    """strengthen-start → agent commits → strengthen-verify → strengthen-finish; returns the finish run."""
+    before()
+    target.ok("strengthen-start", env=env)
+    assert target.git("rev-parse", "HEAD").strip() == target.base
+    for item, source in agent_tests:
+        target.commit_test(item, source)
+    before()
+    target.ok("strengthen-verify", env=env)
+    before()
+    return target.run("strengthen-finish", "--reviews",
+                      str(target.reviews(finish_accept, ids=list(finish_accept))), env=env)
+
+
+def strengthen_pr(target):
+    (create,) = [c for c in target.pr_creates() if arg(c["argv"], "--head") == STRENGTHEN_BRANCH]
+    assert arg(create["argv"], "--base") == "main"
+    return create["body"]
+
+
+def test_strengthen_pr_names_ids_7_and_9_killed_proves_them_surviving_before_and_lowers_the_baseline_by_2(target):
+    target.prepare([cand(case(1))], accept=[case(1), COMPUTE], deletions={case(1): REFERENCE},
+                   groups={COMPUTE: strengthen_group(IDS_7_9)})
+    target.ok("prune")
+    prune_head = target.remote_sha(PRUNE_BRANCH)
+
+    finish = strengthen(target, [(COMPUTE, COMPUTE_TEST)], [COMPUTE])
+
+    assert finish.returncode == 0, finish.stdout + finish.stderr
+    assert all(i in (target.state / "strengthen-input.json").read_text() for i in IDS_7_9)
+    proof = target.read_state("strengthen-proof.json")
+    for mutant_id in IDS_7_9:
+        base_code, head_code = codes_for(proof, mutant_id)
+        assert base_code in (0, 5, 33) and head_code in (1, 3), (mutant_id, base_code, head_code)
+
+    head = target.remote_sha(STRENGTHEN_BRANCH)
+    assert baseline_at(target, target.base)["services/rebalancer.py"]["survivors"] == 20
+    assert baseline_at(target, head)["services/rebalancer.py"]["survivors"] == 18
+    assert "def test_compute_trades_rounding(targets):" in target.show(head, "backend/tests/test_rebalancer.py")
+    # Branched from the base commit, independent of the prune branch.
+    assert target.git("merge-base", head, prune_head).strip() == target.base
+    for path in target.git("diff", "--name-only", target.base, head).split():
+        assert path.startswith("backend/tests/") or path == "backend/mutation_baseline.json", path
+
+    body = strengthen_pr(target)
+    assert "test_compute_trades_rounding" in body
+    for mutant_id in IDS_7_9:
+        assert mutant_id in body
+    assert re.search(r"surviv", body, re.I)
+    assert re.search(r"services/rebalancer\.py\D*\b20\b\D+\b18\b", body), body
+    assert not [c for c in target.log("gh") if c["argv"][:2] == ["pr", "merge"]]
+    assert target.git("rev-parse", "main").strip() == target.base == target.remote_sha("main")
+    assert target.git("symbolic-ref", "--short", "HEAD").strip() == "main"
+
+
+def test_strengthen_item_whose_ids_are_not_all_killed_is_reverted_and_left_out_of_the_pr(target):
+    drift_ids = ["x_apply_drift__mutmut_2", "x_apply_drift__mutmut_4"]
+    target.prepare([cand(case(1))], accept=[COMPUTE, DRIFT],
+                   groups={COMPUTE: strengthen_group(IDS_7_9), DRIFT: strengthen_group(drift_ids)})
+
+    finish = strengthen(target, [(COMPUTE, COMPUTE_TEST), (DRIFT, DRIFT_TEST)], [COMPUTE])
+
+    assert finish.returncode == 0, finish.stdout + finish.stderr
+    head = target.remote_sha(STRENGTHEN_BRANCH)
+    source = target.show(head, "backend/tests/test_rebalancer.py")
+    assert "def test_compute_trades_rounding(targets):" in source
+    assert "test_apply_drift_new" not in source
+    assert baseline_at(target, head)["services/rebalancer.py"]["survivors"] == 18
+    body = strengthen_pr(target)
+    assert "test_apply_drift_new" not in body
+    assert all(i not in body for i in drift_ids)
+    assert all(i in body for i in IDS_7_9)
+
+
+def test_unattended_equivalent_proposals_are_listed_in_the_pr_bodies_and_never_written(target):
+    target.prepare([cand(case(1))], accept=[case(1), COMPUTE, HERFINDAHL], deletions={case(1): REFERENCE},
+                   groups={COMPUTE: strengthen_group(IDS_7_9),
+                           HERFINDAHL: {"verdict": "equivalent", "mutant_ids": [EQUIVALENT_ID],
+                                        "test": "tests/test_concentration.py", "reason": EQUIVALENT_REASON}})
+    equivalents = target.read_state("batch.json")["equivalents"]
+    assert [(e["group"], e["mutant_ids"]) for e in equivalents] == [(HERFINDAHL, [EQUIVALENT_ID])]
+
+    target.ok("prune")
+    finish = strengthen(target, [(COMPUTE, COMPUTE_TEST)], [COMPUTE])
+
+    assert finish.returncode == 0, finish.stdout + finish.stderr
+    (prune_pr,) = [c for c in target.pr_creates() if arg(c["argv"], "--head") == PRUNE_BRANCH]
+    for body in (prune_pr["body"], strengthen_pr(target)):
+        assert EQUIVALENT_ID in body and EQUIVALENT_REASON in body
+    head = target.remote_sha(STRENGTHEN_BRANCH)
+    for module, entry in baseline_at(target, head).items():
+        assert entry["equivalent"] == {}, module
+    assert (target.root / "backend" / "mutation_baseline.json").read_text() == \
+        target.show(target.base, "backend/mutation_baseline.json")
+
+
+def test_equivalent_guard_trips_when_the_baseline_update_gains_an_equivalent_id(target):
+    target.prepare([cand(case(1))], accept=[COMPUTE], groups={COMPUTE: strengthen_group(IDS_7_9)})
+
+    finish = strengthen(target, [(COMPUTE, COMPUTE_TEST)], [COMPUTE],
+                        env={"FAKE_SNEAK_EQUIVALENT": f"services/concentration.py:{EQUIVALENT_ID}"})
+
+    assert finish.returncode == 1, finish.stdout + finish.stderr
+    assert EQUIVALENT_ID in finish.stdout + finish.stderr
+    assert target.log("mutation-baseline"), "the guard must run after make mutation-baseline"
+    assert STRENGTHEN_BRANCH not in target.remote_branches()
+    assert target.pr_creates() == []
+    assert target.git("rev-parse", "main").strip() == target.base == target.remote_sha("main")
+
+
+def test_every_post_batch_mutation_run_starts_from_an_empty_mutants_directory(target):
+    culprit = R + "test_sell_only_rebalance"
+    keep_cache = {"KEEP_CACHE": "1"}
+    deletions = {case(1): REFERENCE, culprit: R + "test_hold_when_on_target"}
+    target.prepare([cand(i, into) for i, into in deletions.items()], accept=[*deletions, COMPUTE],
+                   deletions=deletions, groups={COMPUTE: strengthen_group(IDS_7_9)},
+                   env=keep_cache, before=target.junk_mutants)
+    target.junk_mutants()
+    target.ok("prune", env=keep_cache)
+    finish = strengthen(target, [(COMPUTE, COMPUTE_TEST)], [COMPUTE], env=keep_cache, before=target.junk_mutants)
+    assert finish.returncode == 0, finish.stdout + finish.stderr
+
+    runs = target.log("mutation")
+    assert len(runs) >= 4, runs  # collect, prune (batch + after the restore), strengthen-verify
+    assert all(r["mutants"] in ("absent", "empty") for r in runs), runs
+    assert all(r["KEEP_CACHE"] is None for r in runs), runs
+    assert culprit in target.ids_at(target.remote_sha(PRUNE_BRANCH))