@jesdi/skills 0.0.43 → 0.0.45

package/skills/implement-spec/tests/test_driver.py

@@ -4,6 +4,7 @@ import fcntl
 import json
 import os
 import subprocess
+import sys
 import time
 from pathlib import Path
 
@@ -13,6 +14,7 @@ import pytest
 import driver
 import driver_agents
 import driver_report
+import driver_state
 
 from conftest import GIT, ticket
 
@@ -33,7 +35,7 @@ def test_a_run_without_dry_run_needs_the_spec(repo, capsys):
     repo(t01=ticket("01"))
     assert driver.main(["--gate", "make check"]) == 3
     assert capsys.readouterr().out == "--spec is required: the spec file the prompts point at\n"
-    assert "ticket/01" not in subprocess.run(["git", "branch"], capture_output=True, text=True).stdout
+    assert "ticket/feat%2Fx/01" not in subprocess.run(["git", "branch"], capture_output=True, text=True).stdout
 
 
 def test_every_environment_and_ticket_error_is_listed_together(repo, capsys):
@@ -158,7 +160,7 @@ def ledger_of(tmp_path):
 
 def walked(*short):
     """The PR tip as the tickets left it: the recovery point of the tidy when there is one, else the tip of feat/x."""
-    made = subprocess.run(["git", "rev-parse", *short, "-q", "--verify", "refs/implement/recovery"], capture_output=True, text=True)
+    made = subprocess.run(["git", "rev-parse", *short, "-q", "--verify", "refs/implement-spec/feat%2Fx/recovery"], capture_output=True, text=True)
     return made.stdout.strip() or subprocess.run(["git", "rev-parse", *short, "feat/x"], capture_output=True, text=True).stdout.strip()
 
 
@@ -242,7 +244,7 @@ def test_a_moved_head_prompt_line_comes_from_its_template(repo, tmp_path, capsys
     repo()
     tip = subprocess.run(["git", "rev-parse", "HEAD"], capture_output=True, text=True).stdout.strip()
     agents(tmp_path, capsys, "git checkout -q --detach\n")
-    line = (driver_report.PROMPTS / "moved.md").read_text().replace("{branch}", "ticket/01").replace("{tip}", tip)
+    line = (driver_report.PROMPTS / "moved.md").read_text().replace("{branch}", "ticket/feat%2Fx/01").replace("{tip}", tip)
     assert line in prompt_of(tmp_path) and prompt_of(tmp_path).rstrip().endswith("one ref store.")
 
 
@@ -307,10 +309,10 @@ def test_a_timeout_doubles_the_limit_and_a_second_one_blocks(repo, tmp_path, cap
 
 
 @pytest.mark.parametrize("move, problem", [
-    ("git checkout -q feat/x", "HEAD is on feat/x instead of ticket/01"),
-    ("git checkout -q --detach", "HEAD is on a detached commit instead of ticket/01"),
-    ("git checkout -q --detach; git branch -q -D ticket/01", "branch ticket/01 is missing"),
-    ("git checkout -q -B ticket/01 HEAD~1", "ticket/01 no longer holds"),
+    ("git checkout -q feat/x", "HEAD is on feat/x instead of ticket/feat%2Fx/01"),
+    ("git checkout -q --detach", "HEAD is on a detached commit instead of ticket/feat%2Fx/01"),
+    ("git checkout -q --detach; git branch -q -D ticket/feat%2Fx/01", "branch ticket/feat%2Fx/01 is missing"),
+    ("git checkout -q -B ticket/feat%2Fx/01 HEAD~1", "ticket/feat%2Fx/01 no longer holds"),
 ])
 def test_a_moved_head_resets_the_slot_and_reruns(repo, tmp_path, capsys, move, problem):
     repo()
@@ -326,7 +328,7 @@ def test_a_moved_head_resets_the_slot_and_reruns(repo, tmp_path, capsys, move, p
 
 def test_an_existing_ticket_branch_stops_the_run(repo, tmp_path, capsys):
     repo()
-    subprocess.run(["git", "branch", "ticket/01"], check=True)
+    subprocess.run(["git", "branch", "ticket/feat%2Fx/01"], check=True)
     assert agents(tmp_path, capsys, "exit 0\n") == (3, [])
 
 
@@ -357,7 +359,7 @@ echo "$role $nn" >> "${FILE:-work-$nn.txt}"; git add -A; git commit -q -m "$role
 echo "$nn $PWD" >> "$0.calls"
 """
 # Ticket 01 waits until ticket 02 has its branch, so both start from the same PR tip.
-TOGETHER = """[ "$nn" != 01 ] || until git rev-parse -q --verify refs/heads/ticket/02 > /dev/null; do sleep 0.02; done\n"""
+TOGETHER = """[ "$nn" != 01 ] || until git rev-parse -q --verify refs/heads/ticket/feat%2Fx/02 > /dev/null; do sleep 0.02; done\n"""
 REFACTOR = {"seam": "none — refactor"}
 # A fixer that cannot make the red gate green: the ticket blocks at fix round 1.
 GIVE_UP = """[ $role != fixer ] || { printf '{"status": "BLOCKED", "commits": [], "files": [], "concerns": ["the gate stays red"], "green": [], "ticket": "01"}' > "$report"; exit 0; }\n"""
@@ -437,7 +439,7 @@ def test_a_conflict_agent_that_does_not_resolve_blocks_the_ticket_and_keeps_its_
     assert f"BLOCKED at the merge: the conflict agent: report .agent/implement/{number}/conflict-0.json is not" in line
     assert len([line for line in ledger if "conflict ran on" in line]) == 2  # the one rerun of a violation
     assert state_of(tmp_path)["tickets"][number]["phase"] == "blocked"
-    assert f"ticket/{number}" in branches() and f"Ticket {number} is not merged: its phase is blocked." in out
+    assert f"ticket/feat%2Fx/{number}" in branches() and f"Ticket {number} is not merged: its phase is blocked." in out
     for slot in (".", ".agent/worktrees/slot-2"):  # the driver's open merge is gone
         assert out_of("git", "-C", slot, "status", "--porcelain") == ""
         assert out_of("git", "-C", slot, "rev-parse", "-q", "--verify", "MERGE_HEAD") == ""
@@ -450,7 +452,7 @@ def test_a_conflict_cli_that_fails_stops_the_run_and_leaves_no_open_merge(repo,
     assert code == 4 and "with no report: ERROR: not signed in" in out, out
     assert not [line for line in ledger if "BLOCKED" in line]
     (number,) = [n for n, entry in state_of(tmp_path)["tickets"].items() if entry["phase"] == "merge"]
-    assert f"ticket/{number}" in branches()
+    assert f"ticket/feat%2Fx/{number}" in branches()
     for slot in (".", ".agent/worktrees/slot-2"):
         assert out_of("git", "-C", slot, "status", "--porcelain") == ""
         assert out_of("git", "-C", slot, "rev-parse", "-q", "--verify", "MERGE_HEAD") == ""
@@ -459,7 +461,7 @@ def test_a_conflict_cli_that_fails_stops_the_run_and_leaves_no_open_merge(repo,
 def test_a_red_gate_is_a_finding_and_the_ticket_it_blocks_never_starts(repo, tmp_path, capsys):
     two(repo, second="01")
     code, ledger, out = walk(tmp_path, capsys, GIVE_UP + WORK + REPORT, gate="echo CHECK-OUTPUT; exit 1")
-    tip = out_of("git", "rev-parse", "--short=7", "ticket/01")
+    tip = out_of("git", "rev-parse", "--short=7", "ticket/feat%2Fx/01")
     assert code == 1 and ledger[-1] == GAVE_UP, out
     assert ledger[1] == (f"Ticket 01: critical finding of kind code from the gate at "
                          f".agent/implement/01/gate-{tip}.log:0: the gate is red on {tip}.")
@@ -487,7 +489,7 @@ def test_a_tree_that_is_not_clean_is_a_red_gate_and_the_slot_keeps_the_work(repo
     assert code == 1 and "from the gate at .agent/implement/01/gate-" in ledger[-3] and ledger[-1] == GAVE_UP, out
     record = next((tmp_path / ".agent/implement/01").glob("gate-*.log")).read_text()
     assert "status: not clean\n    ?? junk.txt\n" in record and "exit: not run" in record and "\nNEVER\n" not in record
-    assert out_of("git", "symbolic-ref", "--short", "HEAD") == "ticket/01" and (tmp_path / "junk.txt").exists()
+    assert out_of("git", "symbolic-ref", "--short", "HEAD") == "ticket/feat%2Fx/01" and (tmp_path / "junk.txt").exists()
     code, _, out = walk(tmp_path, capsys, "exit 9\n")
     assert code == 3 and "uncommitted change: junk.txt" in out
 
@@ -524,7 +526,7 @@ def test_a_resumed_tip_that_is_not_on_the_branch_returns_the_ticket_to_implement
     base = out_of("git", "rev-parse", "feat/x")
     code, ledger, out = walk(tmp_path, capsys, WORK + REPORT)
     assert code == 0, out
-    assert "Ticket 01: returned to implement from the PR tip: the recorded tip 1111111 is not on ticket/01." in ledger
+    assert "Ticket 01: returned to implement from the PR tip: the recorded tip 1111111 is not on ticket/feat%2Fx/01." in ledger
     assert out_of("git", "rev-parse", "feat/x~1") == base  # the earlier, untrusted commit is not in the PR branch
 
 
@@ -537,10 +539,102 @@ def test_a_resumed_ticket_with_a_settled_gate_merges_without_a_gate_or_an_agent(
     (tmp_path / ".agent/implement/state.json").write_text(json.dumps(state))
     # A gate on the ticket branch is still red, so a second gate for the settled commit would block the ticket. The
     # one new gate is that of the end of run, on the PR branch.
-    code, ledger, out = walk(tmp_path, capsys, "exit 9\n", gate='[ "$(git rev-parse --abbrev-ref HEAD)" != ticket/01 ]')
+    code, ledger, out = walk(tmp_path, capsys, "exit 9\n", gate='[ "$(git rev-parse --abbrev-ref HEAD)" != ticket/feat%2Fx/01 ]')
     assert code == 0 and walked() == tip and "| gates run | 2 |" in out
 
 
+def as_older_driver(tmp_path, *numbers):
+    """Make the run in tmp_path one that an older driver started: no `schema`, and the old names of its ticket
+    branches and of its recovery ref."""
+    state = state_of(tmp_path)
+    del state["run"]["schema"]
+    (tmp_path / ".agent/implement/state.json").write_text(json.dumps(state))
+    for nn in numbers:
+        subprocess.run(["git", "branch", "-m", f"ticket/feat%2Fx/{nn}", f"ticket/{nn}"], check=True)
+    if recovery := out_of("git", "rev-parse", "-q", "--verify", "refs/implement-spec/feat%2Fx/recovery"):
+        subprocess.run(["git", "update-ref", "refs/implement/recovery", recovery], check=True)
+        subprocess.run(["git", "update-ref", "-d", "refs/implement-spec/feat%2Fx/recovery"], check=True)
+    return recovery
+
+
+def test_a_run_of_an_older_driver_resumes_on_its_renamed_ticket_branch(repo, tmp_path, capsys):
+    """An older driver named the ticket branch `ticket/NN`. The resume renames it and trusts the recorded tip."""
+    entry = blocked_then_edited(repo, tmp_path, capsys, phase="merge")
+    state = state_of(tmp_path)
+    state["tickets"]["01"]["green_gates"] = [entry["tip"]]
+    (tmp_path / ".agent/implement/state.json").write_text(json.dumps(state))
+    as_older_driver(tmp_path, "01")
+    code, ledger, out = walk(tmp_path, capsys, "exit 9\n")
+    assert code == 0, out
+    assert "Ticket 01: renamed the branch ticket/01 of an older driver to ticket/feat%2Fx/01." in ledger
+    assert not any("returned to implement" in line for line in ledger) and walked() == entry["tip"]
+    assert branches() == ["feat/x"]
+
+
+def test_a_run_of_an_older_driver_on_a_contradicted_ticket_branch_returns_the_ticket_to_implement(repo, tmp_path,
+                                                                                               capsys):
+    """Spec review: slot 1 is on `ticket/NN` of an older driver, and git contradicts the recorded tip, so the branch
+    keeps its old name. The resume accepts slot 1 there, as the older driver did, and starts the ticket again."""
+    blocked_then_edited(repo, tmp_path, capsys, phase="review", tip="1" * 40)
+    as_older_driver(tmp_path, "01")
+    subprocess.run(["git", "checkout", "-q", "ticket/01"], check=True)
+    code, ledger, out = walk(tmp_path, capsys, WORK + REPORT)
+    assert code == 0, out
+    assert "Ticket 01: returned to implement from the PR tip: the recorded tip 1111111 is not on ticket/feat%2Fx/01." in ledger
+    assert not [line for line in ledger if "renamed" in line]
+
+
+def test_a_ticket_branch_of_an_older_driver_that_git_cannot_rename_stops_the_run(repo, tmp_path, capsys):
+    blocked_then_edited(repo, tmp_path, capsys)
+    as_older_driver(tmp_path, "01")
+    subprocess.run(["git", "branch", "ticket/feat%2Fx"], check=True)  # a branch where the folder of the new name goes
+    code, ledger, out = walk(tmp_path, capsys, "exit 9\n")
+    assert code == 3 and out.startswith("implement-spec: cannot rename the branch ticket/01 of an older driver to "
+                                        "ticket/feat%2Fx/01: "), out
+    assert "ticket/01" in branches() and not [line for line in ledger if "renamed" in line]
+
+
+def test_a_finished_run_of_an_older_driver_gets_the_new_name_of_its_recovery_ref(repo, tmp_path, capsys):
+    """Spec review: the recovery ref moves through the driver, before the end of run reads it."""
+    repo(t01=ticket("01", **REFACTOR))
+    assert walk(tmp_path, capsys, WORK + REPORT)[0] == 0
+    recovery = as_older_driver(tmp_path)
+    assert recovery
+    code, _, out = walk(tmp_path, capsys, "exit 9\n")
+    assert code == 0, out
+    assert ("Recovery point: moved refs/implement/recovery of an older driver to refs/implement-spec/feat%2Fx/recovery."
+            in (tmp_path / ".agent/implement/ledger.md").read_text().splitlines())
+    assert out_of("git", "rev-parse", "-q", "--verify", "refs/implement/recovery") == "" and walked() == recovery
+
+
+def test_no_older_driver_starts_while_a_newer_driver_runs(repo, tmp_path, capsys):
+    """Spec review: the newer driver holds the lock of an older driver, shared, for its whole run. The agent tries to
+    take that lock as an older driver does, alone, and cannot."""
+    repo(t01=ticket("01", **REFACTOR))
+    old_lock = Path(out_of("git", "rev-parse", "--git-common-dir")).resolve() / "implement-spec.lock"
+    probe = tmp_path.parent / f"{tmp_path.name}-probe"
+    older = (f'"{sys.executable}" -c "import fcntl; fcntl.flock(open(\'{old_lock}\', \'a\'), '
+             f'fcntl.LOCK_EX | fcntl.LOCK_NB)" 2>/dev/null; echo $? > {probe}\n')
+    code, _, out = walk(tmp_path, capsys, older + WORK + REPORT)
+    assert code == 0 and probe.read_text() == "1\n", out
+
+
+@pytest.mark.parametrize("older_run", [False, True])
+def test_a_newer_driver_waits_while_an_older_driver_runs(repo, tmp_path, capsys, older_run):
+    """Correctness review: an older driver holds only `implement-spec.lock`, so a newer driver waits for that lock,
+    on a run of its own and on a run that an older driver started."""
+    blocked_then_edited(repo, tmp_path, capsys)
+    if older_run:
+        as_older_driver(tmp_path, "01")
+    old_lock = Path(out_of("git", "rev-parse", "--git-common-dir")).resolve() / "implement-spec.lock"
+    with hold(old_lock):
+        code, ledger, out = walk(tmp_path, capsys, "exit 9\n")
+    assert code == 3 and out == ("implement-spec: a driver of an older version runs in this repository: it holds the "
+                                 f"lock {old_lock}. Wait until it ends, then run the driver again.\n")
+    assert ("ticket/01" if older_run else "ticket/feat%2Fx/01") in branches()
+    assert not [line for line in ledger if "renamed" in line] and state_of(tmp_path)["tickets"]["01"]["phase"] == "blocked"
+
+
 def test_an_unknown_phase_fails_the_resume(repo, tmp_path, capsys):
     blocked_then_edited(repo, tmp_path, capsys, phase="polish")
     code, _, out = walk(tmp_path, capsys, "exit 9\n")
@@ -567,12 +661,23 @@ def test_a_first_run_on_a_detached_head_or_with_no_slot_is_refused(repo, tmp_pat
     assert code == 3 and "the PR worktree is on a detached HEAD" in out
 
 
+def test_a_first_run_in_a_slot_of_another_run_is_refused(repo, tmp_path, capsys):
+    """Correctness review: a slot has no state.json of its own, so its ticket branch would name a lock of its own,
+    and two drivers would control one worktree."""
+    repo(t01=ticket("01", **REFACTOR))
+    subprocess.run(["git", "checkout", "-q", "-b", "ticket/feat%2Fx/01"], check=True)
+    code, ledger, out = walk(tmp_path, capsys, "exit 9\n")
+    assert (code, ledger) == (3, []) and out == (
+        "the PR worktree is on the ticket branch ticket/feat%2Fx/01 of a run: check out the PR branch\n")
+    assert not (tmp_path / ".agent/implement").exists()
+
+
 def test_a_ticket_branch_that_cannot_be_checked_out_blocks_the_ticket(repo, tmp_path, capsys):
     """A slot of an earlier run with more slots still holds the branch."""
     blocked_then_edited(repo, tmp_path, capsys, phase="implement")
-    subprocess.run(["git", "worktree", "add", "-q", str(tmp_path.parent / f"{tmp_path.name}-other"), "ticket/01"], check=True)
+    subprocess.run(["git", "worktree", "add", "-q", str(tmp_path.parent / f"{tmp_path.name}-other"), "ticket/feat%2Fx/01"], check=True)
     code, ledger, _ = walk(tmp_path, capsys, "exit 9\n")
-    assert code == 1 and "BLOCKED at the start: cannot check out ticket/01 in slot 1" in ledger[-1]
+    assert code == 1 and "BLOCKED at the start: cannot check out ticket/feat%2Fx/01 in slot 1" in ledger[-1]
 
 
 def test_an_interrupt_kills_the_running_agents_and_stops_the_driver_at_once(repo, tmp_path, capsys, monkeypatch):
@@ -599,15 +704,62 @@ def test_an_interrupt_kills_the_running_agents_and_stops_the_driver_at_once(repo
     assert "interrupted; run it again to resume" in capsys.readouterr().out
 
 
-def test_a_second_driver_on_the_same_repository_exits_3_and_changes_nothing(repo, tmp_path, capsys):
+def hold(lock: Path):
+    """The lock of another driver: it holds the kernel lock while it runs."""
+    lock.parent.mkdir(parents=True, exist_ok=True)
+    held = lock.open("w")
+    fcntl.flock(held, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    return held
+
+
+def test_a_driver_on_another_pr_branch_does_not_stop_the_run(repo, tmp_path, capsys):
+    """Runs on different PR branches share no state.json, no slot and no ref, so the lock of one stops no other."""
+    repo(t01=ticket("01", **REFACTOR))
+    locks = Path(out_of("git", "rev-parse", "--git-common-dir")).resolve() / "implement-spec"
+    with hold(locks / "feat%2Fother.lock"), hold(locks / "feat.lock"):
+        code, _, out = walk(tmp_path, capsys, WORK + REPORT)
+    assert code == 0 and "1 of 1 tickets are merged into feat/x." in out
+    assert branches() == ["feat/x"]  # the merge deleted ticket/feat%2Fx/01
+
+
+def test_a_driver_that_starts_while_the_first_starts_its_run_locks_the_branch_of_that_run(repo, monkeypatch):
+    """Correctness review: right after the second driver reads HEAD, the first one writes state.json and puts slot 1
+    on a ticket branch. The PR branch that the second driver locks is still the one of that run."""
+    repo(t01=ticket("01", **REFACTOR))
+    real = driver.driver_slots.on_branch
+
+    def first_driver_moves(slot):
+        here = real(slot)
+        driver.STATE.parent.mkdir(parents=True, exist_ok=True)
+        driver.STATE.write_text(json.dumps({"run": {"pr_branch": "feat/x"}}))
+        subprocess.run(["git", "checkout", "-q", "-b", "ticket/feat%2Fx/01"], check=True)
+        return here
+    monkeypatch.setattr(driver.driver_slots, "on_branch", first_driver_moves)
+    assert driver._run_branch() == "feat/x"
+
+
+def test_a_run_that_leaves_its_branch_while_the_driver_takes_the_lock_exits_3(repo, tmp_path, capsys, monkeypatch):
+    repo(t01=ticket("01", **REFACTOR))
+    real = driver_state.lock
+
+    def lock_while_another_run_starts(path, shared=False):
+        driver.STATE.parent.mkdir(parents=True, exist_ok=True)
+        driver.STATE.write_text(json.dumps({"run": {"pr_branch": "feat/other", "schema": driver_state.SCHEMA}}))
+        return real(path, shared)
+    monkeypatch.setattr(driver_state, "lock", lock_while_another_run_starts)
+    code, ledger, out = walk(tmp_path, capsys, WORK + REPORT)
+    assert (code, ledger) == (3, []) and out == (
+        "implement-spec: the run in this worktree left feat/x while the driver took its lock: run the driver again\n")
+
+
+def test_a_second_driver_on_the_same_pr_branch_exits_3_and_changes_nothing(repo, tmp_path, capsys):
     """Final review, correctness 1: two drivers on one state.json lose updates and move the same refs. Ticket 09:
     the lock is in the git common directory, so it is the same file in every worktree of the repository."""
     repo(t01=ticket("01", **REFACTOR))
-    lock = Path(out_of("git", "rev-parse", "--git-common-dir")).resolve() / "implement-spec.lock"
-    with lock.open("w") as other:  # the first driver: it holds the kernel lock while it runs
-        fcntl.flock(other, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    lock = Path(out_of("git", "rev-parse", "--git-common-dir")).resolve() / "implement-spec/feat%2Fx.lock"
+    with hold(lock):
         code, ledger, out = walk(tmp_path, capsys, WORK + REPORT)
-        assert (code, out) == (3, "implement-spec: another driver runs in this repository: it holds the lock "
+        assert (code, out) == (3, "implement-spec: another driver runs on feat/x: it holds the lock "
                                   f"{lock}. Wait until it ends, then run the driver again.\n")
         assert ledger == [] and not (tmp_path / ".agent/implement").exists() and branches() == ["feat/x"]
         assert not Path(f"{tmp_path}-runner.calls").exists()
@@ -755,7 +907,11 @@ def test_a_merged_ticket_whose_commits_left_the_pr_branch_is_not_merged_on_a_rer
     assert code == 1 and f"End of run: BLOCKED at feat/x does not hold the tidied tip {tip}" in out, out
 
 
-def test_a_rerun_after_an_interrupt_keeps_the_work_in_each_slot_and_reruns_the_role(repo, tmp_path, capsys, monkeypatch):
+@pytest.mark.parametrize("older_driver", [False, True])
+def test_a_rerun_after_an_interrupt_keeps_the_work_in_each_slot_and_reruns_the_role(repo, tmp_path, capsys, monkeypatch,
+                                                                                      older_driver):
+    """With `older_driver`, the interrupted run is one whose driver named the ticket branches `ticket/NN` (spec
+    review): the resume renames each one, also in the slot that has it, and the slot keeps its work."""
     two(repo)
     mark = f"{tmp_path.parent}/{tmp_path.name}-started"
 
@@ -776,6 +932,8 @@ def test_a_rerun_after_an_interrupt_keeps_the_work_in_each_slot_and_reruns_the_r
             walk(tmp_path, capsys, hang)
     slot2 = tmp_path / ".agent/worktrees/slot-2"
     assert (tmp_path / "wip-01.txt").exists() and (slot2 / "wip-02.txt").exists()
+    if older_driver:
+        as_older_driver(tmp_path, "01", "02")
     resume = ('grep -q "was interrupted" "$prompt" || exit 9\nnn=$(basename "$(dirname "$report")")\n'
               '[ "$(cat wip-$nn.txt)" = half ] || exit 8\n')
     code, ledger, out = walk(tmp_path, capsys, resume + WORK + REPORT)
@@ -785,6 +943,8 @@ def test_a_rerun_after_an_interrupt_keeps_the_work_in_each_slot_and_reruns_the_r
     assert out_of("git", "show", "feat/x:wip-01.txt") == "half" and out_of("git", "show", "feat/x:wip-02.txt") == "half"
     assert [line for line in ledger if "Ticket 02: resumed in slot 2 with the work the interrupted implementer left" in line]
     assert out_of("git", "status", "--porcelain") == "" and branches() == ["feat/x"]
+    renamed = [f"Ticket {nn}: renamed the branch ticket/{nn} of an older driver to ticket/feat%2Fx/{nn}." for nn in ("01", "02")]
+    assert [line for line in ledger if "renamed the branch" in line] == (renamed if older_driver else [])
 
 
 def test_the_preflight_asks_each_used_entry_once_and_names_each_cli_that_fails(tmp_path, monkeypatch):

package/skills/implement-spec/tests/test_final.py

@@ -10,7 +10,7 @@ Interface choices (ticket 06):
   the rebase and the push (ticket 08): test_amendments.py holds those tests.
 - its agents report into `.agent/implement/final/`, so the fake runner keys them `final/final-reviewer`,
   `final/fixer` and `final/conflict`; gate records there are `gate-<first 7 hex>.log`.
-- recovery point: before the rebase the driver sets `refs/implement/recovery` to the PR tip and writes the ledger
+- recovery point: before the rebase the driver sets `refs/implement-spec/feat%2Fcsv/recovery` to the PR tip and writes the ledger
   sentence "Recovery point: ... <sha>". An ended run leaves the ref in place.
 - a tidied commit has the subject `feat(NN): <ticket title>` and a body line `Ticket: <ticket file name>`.
 - the final fixer's `commits` hold `{"sha", "ticket"}` objects, and the driver renames each fixer commit to
@@ -44,7 +44,7 @@ if step.get("hold"):
     before = git("rev-parse", "feat/csv")
     time.sleep(step["hold"])
     rec["held"] = dict(before=before, after=git("rev-parse", "feat/csv"),
-                       recovery=git("rev-parse", "--verify", "-q", "refs/implement/recovery"))
+                       recovery=git("rev-parse", "--verify", "-q", "refs/implement-spec/feat%2Fcsv/recovery"))
 for cmd in step.get("git", []):''', 1).replace(
     'sha = ""\nif "commit" in step:',
     '''sha = ""
@@ -142,7 +142,7 @@ class Final(Review):
         return ref(self.repo, "feat/csv")
 
     def recovery(self):
-        return ref(self.repo, "refs/implement/recovery")
+        return ref(self.repo, "refs/implement-spec/feat%2Fcsv/recovery")
 
     def commits(self, base, tip="feat/csv"):
         raw = git(self.repo, "log", "--reverse", "--no-merges", "--format=%H%x1f%s%x1f%b%x1e", f"{base}..{tip}")
@@ -223,7 +223,7 @@ def test_seven_commits_in_merge_order_are_tidied_into_three_ticket_commits_with_
     rows = rig.commits(rig.start)
     assert [r["subject"] for r in rows] == [f"feat({nn}): {TITLES[nn]}" for nn in ("01", "03", "02")]
     assert all(f"Ticket: {FILES[nn]}" in r["body"] for nn, r in zip(("01", "03", "02"), rows))
-    assert ref(rig.repo, "feat/csv^{tree}") == ref(rig.repo, "refs/implement/recovery^{tree}")
+    assert ref(rig.repo, "feat/csv^{tree}") == ref(rig.repo, "refs/implement-spec/feat%2Fcsv/recovery^{tree}")
 
 
 def test_one_gate_record_exists_for_the_tidied_tip_and_the_final_reviewer_is_pointed_at_it(story):
@@ -440,7 +440,7 @@ def test_unattended_with_everything_validated_pushes_once_opens_the_pr_and_write
 
 
 def test_unattended_with_a_blocked_ticket_pushes_nothing_and_exits_1(tmp_path):
-    rig = Final(tmp_path, THREE, gate={"red": ["ticket/01"]})
+    rig = Final(tmp_path, THREE, gate={"red": ["ticket/feat%2Fcsv/01"]})
     rig.run(plan(), *UNATTENDED)
     assert rig.code == 1, rig.output()
     assert rig.pushes() == [] and not rig.prs() and not ref(rig.origin, "refs/heads/feat/csv")

package/skills/implement-spec/tests/test_fixloop.py

@@ -238,7 +238,6 @@ def test_a_fixture_correction_that_is_rejected_blocks_the_ticket(tmp_path):
 
 WEAK = "def test_x():\n    assert True\n"
 LOCKED_01 = tw("01")["files"]["tests/test_01.py"]
-REFUSED_01 = "Ticket 02: BLOCKED at the merge: locked file changed: tests/test_01.py."
 CHEAT = impl("02", files={"demo/export.py": "def fn_02():\n    return '02'\n", "tests/test_01.py": WEAK})
 
 
@@ -246,14 +245,15 @@ def on_pr(rig, path):
     return subprocess.run(["git", "-C", str(rig.repo), "show", f"feat/csv:{path}"], capture_output=True, text=True).stdout
 
 
-def test_a_later_ticket_that_weakens_a_locked_test_of_a_merged_ticket_does_not_land(tmp_path):
+def test_a_later_ticket_that_weakens_a_locked_test_of_a_merged_ticket_lands_only_with_the_test_put_back(tmp_path):
     """Final review, correctness 3: ticket 02 replaced the locked assertion of ticket 01, merged and was pushed.
-    Ticket 09: the check is at the landing, on the tree that is about to land, so the review has no such finding."""
+    Issue #90: the review finds the change; the restore keeps the gate green, so it closes the finding alone."""
     rig = Inside(tmp_path, three()).run(plan(**{"02/implementer": [CHEAT]}))
-    assert blocked(rig, "02") == REFUSED_01 and rig.led("locked file changed") == [REFUSED_01], rig.ledger()
-    assert json.loads((rig.folder("02") / "findings-0.json").read_text()) == [] and not rig.calls("02", "fixer")
-    assert on_pr(rig, "tests/test_01.py") == LOCKED_01 and "feat: 02 rows" not in rig.pr_subjects()
-    assert [rig.state()["tickets"][nn]["phase"] for nn in ("01", "03")] == ["merged", "merged"]
+    assert rig.code == 0, rig.ledger()
+    assert rig.led("Ticket 02: critical finding of kind fixture from the driver at tests/test_01.py:1")
+    assert rig.led("Ticket 02:", "the restore closes it") and not rig.led("locked file changed")
+    assert len(rig.calls("02", "test-writer")) == 1 and not rig.calls("02", "fixer")
+    assert on_pr(rig, "tests/test_01.py") == LOCKED_01 and "feat: 02 rows" in rig.pr_subjects()
 
 
 def extends(text, listed):
@@ -286,11 +286,11 @@ def test_the_test_writer_of_a_later_ticket_may_extend_the_locked_file_of_a_merge
 
 
 def test_a_refactor_ticket_may_not_change_a_locked_test_of_a_merged_ticket(tmp_path):
-    """It has no test-writer and no locked file of its own: the landing check is the one that protects ticket 01."""
+    """It has no test-writer and no locked file of its own: the review finds the change, and the restore closes it."""
     files = three(**{"02-quote-fields.md": test_review.ticket("02", "Quote fields", "01", seam="none — refactor", criteria=())})
     rig = Inside(tmp_path, files).run(plan(**{"02/implementer": [CHEAT]}))
-    assert blocked(rig, "02") == REFUSED_01 and not rig.calls("02", "test-writer"), rig.ledger()
-    assert on_pr(rig, "tests/test_01.py") == LOCKED_01
+    assert rig.code == 0 and not rig.calls("02", "test-writer"), rig.ledger()
+    assert rig.led("Ticket 02:", "the restore closes it") and on_pr(rig, "tests/test_01.py") == LOCKED_01
     clean = Inside(under(tmp_path, "clean"), files).run(plan())
     assert clean.code == 0 and not clean.led("locked file changed"), clean.ledger()
 
@@ -362,6 +362,35 @@ def test_the_restore_before_a_correction_is_committed_so_the_next_fixer_and_its_
     assert "The driver put back these files at their locked versions" in prompt and "tests/test_01.py" in prompt
 
 
+ADAPTED_01 = LOCKED_01 + "# adapted to the interface of 02\n"
+ADAPTS = impl("02", files={"demo/export.py": "def fn_02():\n    return '02'\n", "tests/test_01.py": ADAPTED_01})
+RESTORE = "implement-spec: restore the locked files before the correction"
+
+
+def writes(nn, text, subject):
+    """A test-writer correction that writes tests/test_<nn>.py and lists it."""
+    return {**tw(nn), "files": {f"tests/test_{nn}.py": text}, "commit": subject}
+
+
+def test_a_restored_locked_file_of_a_merged_ticket_that_fails_with_the_new_code_must_be_updated_by_the_correction(tmp_path):
+    """Issue #90: ticket 02 changes an interface that the locked file of merged ticket 01 uses, and its implementer
+    adapts that file. The review finds the change, the driver puts the file back in a commit and gates it: red. The
+    correction gets that gate record, and a correction that leaves the file as it is is rejected."""
+    leaves = writes("02", "def test_x():\n    assert '02' == 'x'  # stronger\n", "test: 02 stronger")
+    updates = writes("01", ADAPTED_01, "test: 01 adapted to 02")
+    updates["report"] = {**updates["report"], "locked": ["tests/test_01.py", "tests/test_02.py"]}  # both attempts' files
+    rig = Inside(tmp_path, three(), gate={"subjects": [RESTORE]}).run(
+        plan(**{"02/implementer": [ADAPTS], "02/test-writer": [tw("02"), leaves, updates]}))
+    assert rig.code == 0, rig.ledger()
+    assert rig.led("Ticket 02: critical finding of kind fixture from the driver at tests/test_01.py:1")
+    assert not rig.calls("02", "fixer")
+    (restore,) = [gate["commit"] for gate in rig.gates() if gate["exit"]]
+    first, second = rig.calls("02", "test-writer")[1:]
+    assert f".agent/implement/02/gate-{restore[:7]}.log" in first["prompt"] and first["head"] == restore
+    assert "the gate is red on the restore commit" in second["prompt"]  # the rejection of the first attempt
+    assert on_pr(rig, "tests/test_01.py") == ADAPTED_01 and "tests/test_01.py" in rig.state()["tickets"]["02"]["locked"]
+
+
 ACCENT = "tests/tést.py"
 
 
@@ -374,7 +403,7 @@ def accented(tmp_path, name, **steps):
     return Inside(under(tmp_path, name), three()).run(plan(**{"01/test-writer": [writer], "01/reviewer": proofs, **steps}))
 
 
-def test_a_locked_file_with_a_name_that_git_quotes_is_protected_at_review_and_at_the_landing(tmp_path):
+def test_a_locked_file_with_a_name_that_git_quotes_is_protected_at_review_for_its_ticket_and_a_later_one(tmp_path):
     """Review round 1, I2: the quoted form of the path matched nothing, so no check saw the file."""
     own = impl("01", files={"demo/export.py": "def fn_01():\n    return '01'\n", ACCENT: WEAK})
     rig = accented(tmp_path, "review", **{"01/implementer": [own], "01/fixer": [{}, {}]})
@@ -383,7 +412,7 @@ def test_a_locked_file_with_a_name_that_git_quotes_is_protected_at_review_and_at
     later = impl("02", files={"demo/export.py": "def fn_02():\n    return '02'\n", ACCENT: WEAK})
     rig = accented(tmp_path, "landing", **{"02/implementer": [later]})
     assert rig.state()["tickets"]["01"]["locked"] == ["tests/test_01.py", ACCENT], rig.ledger()
-    assert blocked(rig, "02") == f"Ticket 02: BLOCKED at the merge: locked file changed: {ACCENT}."
+    assert rig.code == 0 and rig.led(f"Ticket 02: critical finding of kind fixture from the driver at {ACCENT}:1")
     assert "assert 1 == 'y'" in on_pr(rig, ACCENT)
 
 
@@ -397,7 +426,7 @@ def test_four_rounds_then_blocked_with_the_escalation_at_round_3(tmp_path):
     assert rig.ledger().count(f"Ticket 01 round 3: escalated to {FABLE}.") == 1
     assert [len(rig.led("fixer ran on", entry)) for entry in (OPUS, FABLE)] == [2, 2]
     tips = [rig.sha("01", "implementer")] + [call["sha"] for call in rig.calls("01", "fixer")]
-    assert [gate["commit"] for gate in rig.gates() if gate["branch"] == "ticket/01"] == tips
+    assert [gate["commit"] for gate in rig.gates() if gate["branch"] == "ticket/feat%2Fcsv/01"] == tips
     assert rig.state()["tickets"]["01"]["tip"] == tips[-1] and not rig.calls("02")
     assert rig.state()["tickets"]["03"]["phase"] == "merged"
 
@@ -504,13 +533,13 @@ def test_a_timed_out_read_only_role_is_restored_only_when_no_other_agent_is_in_t
 
 DIRTY = [({"files": {"junk.txt": "x\n", "demo/export.py": "mutated\n"}},
           "the tree is not as the review found it: demo/export.py, junk.txt"),
-         ({"git": [["checkout", "-q", "--detach"]]}, "the slot is no longer on ticket/01 at "),
-         ({"commit": "sneak", "files": {"demo/export.py": "x = 2\n"}}, "the slot is no longer on ticket/01 at ")]
+         ({"git": [["checkout", "-q", "--detach"]]}, "the slot is no longer on ticket/feat%2Fcsv/01 at "),
+         ({"commit": "sneak", "files": {"demo/export.py": "x = 2\n"}}, "the slot is no longer on ticket/feat%2Fcsv/01 at ")]
 
 
 def slot_state(rig):
     git = lambda *args: subprocess.run(["git", "-C", str(rig.repo), *args], capture_output=True, text=True).stdout.strip()
-    return git("status", "--porcelain"), git("rev-parse", "ticket/01")
+    return git("status", "--porcelain"), git("rev-parse", "ticket/feat%2Fcsv/01")
 
 
 @pytest.mark.parametrize("step, left", DIRTY)
@@ -521,7 +550,7 @@ def test_a_reviewer_that_changes_the_slot_is_run_once_more_on_the_restored_tip(t
     (line,) = rig.led("Ticket 01: a read-only role broke its rule:")
     assert left in line and line.endswith(f"the driver restored the slot to {tip[:7]} and runs the review again.")
     first, second = rig.calls("01", "reviewer")
-    assert (second["branch"], second["head"], second["status"]) == ("ticket/01", tip, "")
+    assert (second["branch"], second["head"], second["status"]) == ("ticket/feat%2Fcsv/01", tip, "")
     assert rig.tip() == tip and not (rig.repo / "junk.txt").exists()