@jesdi/skills 0.0.43 → 0.0.45

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

@@ -1,7 +1,7 @@
-"""Ticket 09 acceptance tests: locked tests are checked on the merge result; one driver per repository.
+"""Ticket 09 acceptance tests: locked tests are checked on the merge result; one driver per PR branch.
 
 All through `sh run.sh --runner <script> --parallel 2` on the three-ticket fixture repository (the rigs of test_review
-and test_final), and through two worktrees of one fixture repository for the run lock. Tickets are ordered with signal
+and test_final), and through two worktrees of one fixture repository, on two PR branches, for the run lock. Tickets are ordered with signal
 files and with `wait_pr_moves`, never with a sleep.
 
 Interface choices (ticket 09):
@@ -17,9 +17,8 @@ Interface choices (ticket 09):
   commit stays open until the reviewer of the other ticket ended, plus a bounded time for that ticket to reach its
   landing. Either order of the two landings is correct, and so is a driver that gives the stale merge commit up;
   a landing after the lock with the weakened file is not, and a landing that is lost is not.
-- the lock sentence is the whole stdout of the second driver, one line, and it names the lock by a path that exists
-  when it is resolved in the second worktree (an absolute path, or a path relative to that worktree).
-- "the second one starts" and "the lock is released": a driver in the other worktree runs its one ticket to exit 0.
+- a driver on another PR branch in another worktree runs its one ticket to exit 0 while the first driver runs, and
+  changes no file and no ref of the first run. The lock of the same PR branch is in test_driver.
 - "never reported as an uncommitted change": no line of `git status --short` in either worktree has `lock` in it.
 """
 import json
@@ -30,8 +29,10 @@ import time
 
 import pytest
 
+from driver_names import Names
+
 from test_cli import RUN, git, models_file, snapshot, three, ticket
-from test_final import Final, ref
+from test_final import Final
 from test_review import HOOKED, Review, cli
 from test_stops import UNATTENDED, blocked as contradicted
 from test_walk import GATE, Rig, impl, make_env, plan, tw
@@ -74,6 +75,13 @@ def refused(rig, nn, path):
     assert rig.led(nn, f"locked file changed: {path}"), rig.ledger()
 
 
+def restored(rig, nn, path):
+    """The review of ticket `nn` found its change to the locked file `path` of a merged ticket, and the restore
+    closed it."""
+    return (rig.led(f"Ticket {nn}: critical finding of kind fixture from the driver at {path}:1")
+            and rig.led(f"Ticket {nn}:", "the restore closes it"))
+
+
 def writer(nn, path, text, listed=True):
     """The test-writer of `nn` that also writes `path`, and lists it as locked or not."""
     step = tw(nn)
@@ -92,37 +100,37 @@ def seeded(rig):
 
 # ---------------------------------------------------------------- the implementer of a later ticket
 
-def test_an_implementer_that_weakens_the_locked_test_of_a_merged_ticket_does_not_land_and_nothing_is_pushed(tmp_path):
+def test_an_implementer_that_weakens_the_locked_test_of_a_merged_ticket_lands_only_with_the_test_put_back(tmp_path):
+    """The review finds the change and the driver restores the file; the gate stays green, so no correction runs."""
     rig = Final(tmp_path, three())
     weak = impl("02", files={"demo/export.py": "def fn_02():\n    return '02'\n", T01: WEAK})
     rig.run(plan(**{"02/implementer": [weak], "02/fixer": NO_REPORT}), *UNATTENDED)
-    refused(rig, "02", T01)
-    assert phase(rig, "01") == "merged" and on_pr(rig, T01) == LOCKED_01
-    assert rig.pushes() == [] and not rig.prs() and not ref(rig.origin, "refs/heads/feat/csv")
+    assert rig.code == 0 and restored(rig, "02", T01), rig.output()
+    assert len(rig.calls("02", "test-writer")) == 1 and on_pr(rig, T01) == LOCKED_01
 
 
 # ---------------------------------------------------------------- a ticket branch that takes the PR branch in
 
 def takes_in(*more):
-    """03's implementer in slot 2: it waits until the PR branch moved, merges it into ticket/03, then commits."""
+    """03's implementer in slot 2: it waits until the PR branch moved, merges it into ticket/feat%2Fcsv/03, then commits."""
     return {**impl("03", "demo/cli.py"), "wait_pr_moves": True, "git": [["merge", "-q", "--no-edit", "feat/csv"], *more]}
 
 
 def test_a_ticket_that_merged_the_pr_branch_into_itself_lands_with_the_tests_of_the_merged_ticket(tmp_path):
     rig = Review(tmp_path, three()).run(plan(**{"03/implementer": [takes_in()], "03/fixer": NO_REPORT}))
     (call,) = rig.calls("03", "implementer")
-    assert call["cwd"] == str(rig.slot2) and holds(rig, rig.sha("01", "implementer"), call["sha"]), "01 is in ticket/03"
+    assert call["cwd"] == str(rig.slot2) and holds(rig, rig.sha("01", "implementer"), call["sha"]), "01 is in ticket/feat%2Fcsv/03"
     assert not rig.led("locked file changed"), rig.ledger()
     assert rig.code == 0, rig.output()
     assert phase(rig, "03") == "merged" and on_pr(rig, T01) == LOCKED_01 and on_pr(rig, T03) == LOCKED_03
 
 
-def test_a_ticket_that_merged_the_pr_branch_and_deleted_a_locked_test_of_the_merged_ticket_does_not_land(tmp_path):
+def test_a_ticket_that_merged_the_pr_branch_and_deleted_a_locked_test_of_the_merged_ticket_lands_with_it_put_back(tmp_path):
     rig = Review(tmp_path, three())
     rig.run(plan(**{"03/implementer": [takes_in(["rm", "-q", T01])], "03/fixer": NO_REPORT}))
     (call,) = rig.calls("03", "implementer")
-    assert holds(rig, rig.sha("01", "implementer"), call["sha"]), "01 is in ticket/03"
-    refused(rig, "03", T01)
+    assert holds(rig, rig.sha("01", "implementer"), call["sha"]), "01 is in ticket/feat%2Fcsv/03"
+    assert rig.code == 0 and restored(rig, "03", T01), rig.output()
     assert phase(rig, "01") == "merged" and on_pr(rig, T01) == LOCKED_01
 
 
@@ -290,44 +298,46 @@ def until(done, seconds=30):
         time.sleep(0.02)
 
 
-def world(*rigs):
-    """Every file of each worktree, and every ref and worktree HEAD of the one repository."""
-    return ([snapshot(r.repo) for r in rigs], git(rigs[0].repo, "for-each-ref"), git(rigs[0].repo, "worktree", "list"))
-
-
 def no_lock_is_dirty(*rigs):
     for rig in rigs:
         status = git(rig.repo, "status", "--short")
         assert "lock" not in status, status
 
 
-def test_a_second_driver_in_another_worktree_exits_3_naming_the_lock_and_starts_when_the_first_ended(tmp_path):
+def first_run_refs(rig):
+    """The refs of the run on feat/csv: its PR branch, its ticket branches and its recovery ref."""
+    names = Names("feat/csv")
+    refs = git(rig.repo, "for-each-ref", "--format=%(refname) %(objectname)").splitlines()
+    return [ref for ref in refs if ref.split()[0] in ("refs/heads/feat/csv", names.recovery)
+            or ref.startswith(f"refs/heads/{names.ticket('')}")]
+
+
+def test_a_driver_on_another_pr_branch_in_another_worktree_runs_while_the_first_runs(tmp_path):
+    """Runs on different PR branches share no state.json, no slot and no ref: the second one ends while the first
+    holds both its slots, and leaves each file and each ref of the first as it was."""
     first, second = pair(tmp_path)
     held = {f"{nn}/test-writer": [{**tw(nn), "wait": ["go"]}] for nn in ("01", "03")}
     proc = start(first, plan(**held))
     try:
         until(lambda: len(first.calls(role="test-writer")) == 2)  # the first driver holds both its slots in a role
-        before = world(first, second)
+        before = (snapshot(first.repo), first_run_refs(first))
+        assert [ref for ref in before[1] if "/ticket/" in ref], before[1]  # the first run has its ticket branches
         second.run(OTHER)
-        assert second.code == 3, second.output()
-        (sentence,) = second.out.splitlines()
-        named = [word.rstrip(".,;:") for word in sentence.split() if "/" in word or word.rstrip(".,;:").endswith("lock")]
-        assert "lock" in sentence and any((second.repo / word).is_file() for word in named), sentence
-        assert world(first, second) == before and not second.calls()
+        assert second.code == 0 and second.calls("04", "implementer"), second.output()
+        assert (snapshot(first.repo), first_run_refs(first)) == before
+        assert not git(second.repo, "branch", "--list", "ticket/feat%2Fother/*")  # the merge deleted ticket 04's branch
         no_lock_is_dirty(first, second)
         (first.rig / "sig/go").touch()
         out, _ = proc.communicate(timeout=120)
     finally:
         ended(proc)
     assert proc.returncode == 0, out
-    second.run(OTHER)
-    assert second.code == 0 and second.calls("04", "implementer"), second.output()
     no_lock_is_dirty(first, second)
 
 
 ENDS = {
     0: (plan(), {}, ()),
-    1: (plan(), {"red": ["ticket/01"]}, ()),
+    1: (plan(), {"red": ["ticket/feat%2Fcsv/01"]}, ()),
     2: (plan(**{"01/implementer": [contradicted()]}), {}, ()),
     3: (plan(), {}, ("--prepare", "false")),  # slot 2 cannot be made: the run has started and holds the lock
     130: (plan(**{"01/test-writer": [{**tw("01"), "wait": ["never"]}]}), {}, ()),

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

@@ -0,0 +1,139 @@
+"""The names of a run, and the take-over of a run that an older driver started (driver_names, driver_legacy)."""
+import subprocess
+
+import driver_legacy
+import driver_state
+from conftest import GIT
+from driver_names import Names
+
+
+def sha(ref="HEAD"):
+    return subprocess.run(["git", "rev-parse", "-q", "--verify", ref], capture_output=True, text=True).stdout.strip()
+
+
+def test_the_names_of_a_run_carry_its_pr_branch_as_one_ref_component(repo, tmp_path):
+    """Structure review: git refs are a tree, so `ticket/feat/01` and `ticket/feat/01/02` cannot both exist. The PR
+    branch is one escaped component, so runs on two PR branches never collide."""
+    names = Names("feat/x")
+    assert (names.ticket("01"), names.recovery) == ("ticket/feat%2Fx/01", "refs/implement-spec/feat%2Fx/recovery")
+    assert names.lock_file(tmp_path) == tmp_path / "implement-spec/feat%2Fx.lock"
+    assert Names("a%2Fb").ticket("01") != Names("a/b").ticket("01")
+    repo()
+    for name in (Names("feat").ticket("01"), Names("feat/01").ticket("02"), Names("x/recovery").ticket("01")):
+        subprocess.run(["git", "branch", name], check=True)
+    subprocess.run(["git", "update-ref", "refs/implement/recovery", "HEAD"], check=True)  # of an older driver
+    for pr in ("feat", "feat/recovery", "recovery"):
+        subprocess.run(["git", "update-ref", Names(pr).recovery, "HEAD"], check=True)
+    assert sha(Names("feat/recovery").recovery) == sha()
+
+
+def older_run(repo, tmp_path):
+    """A repository with the start of a run, its recorded tip on `ticket/01` and the state.json of an older driver:
+    no `schema`."""
+    repo()
+    start = sha()
+    subprocess.run([*GIT, "commit", "-q", "--allow-empty", "-m", "work"], check=True)
+    tip = sha()
+    subprocess.run(["git", "branch", "ticket/01", tip], check=True)
+    state = driver_state.State(tmp_path / ".agent/implement/state.json")
+    state.update(lambda s: s.update(
+        run={"pr_branch": "feat/x", "start": start, "final": {"recovery": None}},
+        tickets={"01": {"phase": "review", "tip": tip}, "02": {"phase": "pending", "tip": None}}))
+    return state, start, tip
+
+
+def resume(state, tmp_path):
+    """driver_legacy.resume; (the errors, the ledger lines)."""
+    errors = driver_legacy.resume(state)
+    ledger = tmp_path / ".agent/implement/ledger.md"
+    return errors, ledger.read_text().splitlines() if ledger.exists() else []
+
+
+def edit(state, ticket=None, **run):
+    """Change the record of the run and of ticket 01, and take the `schema` away: the run is the older driver's
+    again."""
+    state.update(lambda s: (s["run"].update(run), s["run"].pop("schema", None), s["tickets"]["01"].update(ticket or {})))
+
+
+def test_resume_renames_the_ticket_branches_of_this_run_only_and_marks_the_run(repo, tmp_path):
+    """A `ticket/NN` is this run's only when it holds the start of the run and the recorded tip: a `ticket/NN` of
+    another run stays as it is."""
+    state, start, tip = older_run(repo, tmp_path)
+    subprocess.run(["git", "branch", "-f", "ticket/01", start], check=True)
+    assert resume(state, tmp_path) == ([], [])  # it does not hold the recorded tip
+    subprocess.run([*GIT, "checkout", "-q", "--orphan", "other"], check=True)
+    subprocess.run([*GIT, "commit", "-q", "--allow-empty", "-m", "other run"], check=True)
+    subprocess.run(["git", "branch", "-f", "ticket/01", "other"], check=True)
+    edit(state, {"tip": None})
+    assert resume(state, tmp_path) == ([], [])  # it does not hold the start of the run
+    subprocess.run(["git", "branch", "-f", "ticket/01", tip], check=True)
+    for phase in ("pending", "merged"):
+        edit(state, {"tip": tip, "phase": phase})
+        assert resume(state, tmp_path) == ([], [])
+    edit(state, {"phase": "review"})
+    assert resume(state, tmp_path) == (
+        [], ["Ticket 01: renamed the branch ticket/01 of an older driver to ticket/feat%2Fx/01."])
+    assert (sha("refs/heads/ticket/01"), sha("refs/heads/ticket/feat%2Fx/01")) == ("", tip)
+    assert state.read()["run"]["schema"] == driver_state.SCHEMA
+    subprocess.run(["git", "branch", "ticket/01", tip], check=True)
+    assert resume(state, tmp_path)[0] == [] and sha("refs/heads/ticket/01") == tip  # a marked run is not touched
+
+
+def test_resume_keeps_a_ticket_branch_that_a_worktree_outside_the_run_has_checked_out(repo, tmp_path):
+    """Correctness review: a common start does not prove whose branch it is. A `ticket/NN` that another worktree has
+    checked out is that worktree's."""
+    state, _, tip = older_run(repo, tmp_path)
+    subprocess.run(["git", "worktree", "add", "-q", str(tmp_path.parent / f"{tmp_path.name}-other"), "ticket/01"],
+                   check=True)
+    assert resume(state, tmp_path) == ([], []) and sha("refs/heads/ticket/01") == tip
+    edit(state)
+    subprocess.run(["git", "worktree", "remove", "--force", str(tmp_path.parent / f"{tmp_path.name}-other")],
+                   check=True)
+    subprocess.run(["git", "worktree", "add", "-q", str(tmp_path / ".agent/worktrees/slot-2"), "ticket/01"],
+                   check=True)
+    assert resume(state, tmp_path)[1] == ["Ticket 01: renamed the branch ticket/01 of an older driver to "
+                                          "ticket/feat%2Fx/01."]  # a slot of this run
+
+
+def test_resume_stops_on_a_rename_that_git_refuses_and_loses_nothing(repo, tmp_path):
+    state, _, _ = older_run(repo, tmp_path)
+    subprocess.run(["git", "branch", "ticket/feat%2Fx"], check=True)  # a branch where the folder of the new name goes
+    errors, ledger = resume(state, tmp_path)
+    assert ledger == [] and len(errors) == 1 and "schema" not in state.read()["run"]
+    assert errors[0].startswith("cannot rename the branch ticket/01 of an older driver to ticket/feat%2Fx/01: ")
+    assert sha("refs/heads/ticket/01")
+
+
+def test_resume_moves_the_recovery_ref_that_this_run_recorded(repo, tmp_path):
+    state, start, tip = older_run(repo, tmp_path)
+    subprocess.run(["git", "branch", "-D", "-q", "ticket/01"], check=True)
+    subprocess.run(["git", "update-ref", "refs/implement/recovery", start], check=True)
+    edit(state, final={"recovery": tip})
+    assert resume(state, tmp_path) == ([], [])  # it holds another commit: not this run's
+    edit(state, final={"recovery": start})
+    assert resume(state, tmp_path) == (
+        [], ["Recovery point: moved refs/implement/recovery of an older driver to refs/implement-spec/feat%2Fx/recovery."])
+    assert (sha("refs/implement/recovery"), sha("refs/implement-spec/feat%2Fx/recovery")) == ("", start)
+
+
+def test_resume_keeps_the_recovery_ref_when_git_refuses_the_new_one(repo, tmp_path):
+    state, start, _ = older_run(repo, tmp_path)
+    subprocess.run(["git", "branch", "-D", "-q", "ticket/01"], check=True)
+    subprocess.run(["git", "update-ref", "refs/implement/recovery", start], check=True)
+    subprocess.run(["git", "update-ref", "refs/implement-spec/feat%2Fx", start], check=True)  # a file where a folder goes
+    edit(state, final={"recovery": start})
+    errors, ledger = resume(state, tmp_path)
+    assert ledger == [] and errors[0].startswith("cannot move refs/implement/recovery of an older driver to ")
+    assert sha("refs/implement/recovery") == start
+
+
+def test_the_lock_of_an_older_driver_is_shared_by_newer_drivers_and_excludes_an_older_one(tmp_path):
+    """Correctness review: an older driver holds `implement-spec.lock` alone for its whole run."""
+    (one, _), (two, _) = driver_legacy.lock(tmp_path), driver_legacy.lock(tmp_path)
+    with one, two:
+        assert driver_state.lock(tmp_path / "implement-spec.lock") is None
+    older = driver_state.lock(tmp_path / "implement-spec.lock")
+    assert older is not None and driver_legacy.lock(tmp_path) == (None, (
+        f"a driver of an older version runs in this repository: it holds the lock {tmp_path / 'implement-spec.lock'}. "
+        "Wait until it ends, then run the driver again."))
+    older.close()

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

@@ -266,7 +266,7 @@ def test_unattended_rerun_with_a_submitted_answers_file_at_the_current_revision_
 
 def test_unattended_blocked_ticket_ends_with_stage_json_blocked_naming_it_and_exit_1(tmp_path):
     from test_final import Final
-    rig = Final(tmp_path, gate={"red": ["ticket/01"]})
+    rig = Final(tmp_path, gate={"red": ["ticket/feat%2Fcsv/01"]})
     rig.run(plan(), *UNATTENDED)
     assert rig.code == 1, rig.output()
     assert stage(rig) == {"stage": "implement", "status": "blocked", "blocked": ["01"]}

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

@@ -78,7 +78,7 @@ def test_a_local_run_stops_before_the_push_and_a_push_rerun_pushes_and_opens_the
     assert [(r["subject"], r["body"].strip()) for r in rows] == [
         (f"feat({nn}): {TITLES[nn]}", f"Ticket: {FILES[nn]}") for nn in order] and order[2] == "02"
     assert len(rig.commits(rig.start, rig.recovery())) == 6
-    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}")
     assert rig.led("Recovery point: feat/csv was at " + rig.recovery(), ref(rig.repo, "feat/csv^{tree}"))
     assert rig.led("End of run: final-reviewer ran on", FABLE) and rig.led("End of run: the gate is green on " + tip[:7])
     assert {nn: e["tip"] for nn, e in rig.state()["tickets"].items()} == {nn: r["sha"] for nn, r in zip(order, rows)}
@@ -111,7 +111,7 @@ def test_a_local_run_stops_before_the_push_and_a_push_rerun_pushes_and_opens_the
 
 
 def test_the_final_review_does_not_start_while_a_ticket_is_not_merged_and_the_ledger_says_so_once(tmp_path):
-    rig = Inside(tmp_path, THREE, gate={"red": ["ticket/01"]})
+    rig = Inside(tmp_path, THREE, gate={"red": ["ticket/feat%2Fcsv/01"]})
     rig.run(plan())
     rig.run(plan(), *UNATTENDED)
     assert rig.code == 1 and not rig.final_calls("final-reviewer") and not rig.recovery()

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

@@ -12,7 +12,7 @@ Interface choices (ticket 03):
   `green_gates` holds full SHAs (a dict with a `commit` key is accepted too).
 
 Ticket 08: this fixture has no `origin`, and a run that merges every ticket now ends with the tidy, one gate on the
-tidied tip and the final review. The history as the walk made it is at `refs/implement/recovery`: `Rig.walked()` is
+tidied tip and the final review. The history as the walk made it is at `refs/implement-spec/feat%2Fcsv/recovery`: `Rig.walked()` is
 that tip, `Rig.pr_subjects()` reads it, and `Rig.walk_gates()` leaves out the one gate of the end of run.
 """
 import json
@@ -234,7 +234,7 @@ class Rig:
 
     def walked(self):
         """The PR tip as the walk left it: the recovery point of the end-of-run tidy, or the branch with no tidy."""
-        out = subprocess.run(["git", "rev-parse", "--verify", "-q", "refs/implement/recovery"], cwd=self.repo,
+        out = subprocess.run(["git", "rev-parse", "--verify", "-q", "refs/implement-spec/feat%2Fcsv/recovery"], cwd=self.repo,
                              capture_output=True, text=True).stdout.strip()
         return out or git(self.repo, "rev-parse", "feat/csv").strip()
 
@@ -247,7 +247,7 @@ class Rig:
         return git(self.repo, "log", "--format=%s", self.walked()).splitlines()
 
     def branches(self):
-        return git(self.repo, "branch", "--list", "ticket/*").split()
+        return git(self.repo, "branch", "--list", "ticket/feat%2Fcsv/*").split()
 
     def output(self):
         return f"exit {self.code}\n{self.out}{self.err}"
@@ -271,9 +271,9 @@ def std(tmp_path_factory):
 
 @pytest.fixture(scope="module")
 def blocked(tmp_path_factory):
-    """The default scenario with a red gate on ticket/01 that four fix rounds do not make green."""
+    """The default scenario with a red gate on ticket/feat%2Fcsv/01 that four fix rounds do not make green."""
     fixes = [fix("01", n) for n in (1, 2, 3, 4)]
-    return Rig(tmp_path_factory.mktemp("blocked"), gate={"red": ["ticket/01"]}).run(plan(**{"01/fixer": fixes}))
+    return Rig(tmp_path_factory.mktemp("blocked"), gate={"red": ["ticket/feat%2Fcsv/01"]}).run(plan(**{"01/fixer": fixes}))
 
 
 def test_01_starts_in_slot_1_03_in_slot_2_and_02_after_the_merge_of_01(std):
@@ -281,7 +281,7 @@ def test_01_starts_in_slot_1_03_in_slot_2_and_02_after_the_merge_of_01(std):
     first = lambda nn: std.calls(nn)[0]
     assert first("01")["cwd"] == str(std.repo.resolve()) and first("03")["cwd"] == str(std.slot2)
     assert "feat: 01 rows" in first("02")["pr_log"] and "feat: 01 rows" in first("02")["log"]
-    assert first("02")["t0"] > std.calls("01")[-1]["t1"] and first("02")["branch"] == "ticket/02"
+    assert first("02")["t0"] > std.calls("01")[-1]["t1"] and first("02")["branch"] == "ticket/feat%2Fcsv/02"
 
 
 def test_touches_overlap_holds_03_until_01_is_merged(tmp_path):
@@ -349,7 +349,7 @@ def test_red_gate_blocks_the_ticket_after_round_4_names_the_record_and_launches_
     assert [l for l in blocked.ledger() if "01" in l and "BLOCKED" in l and f"gate-{last[:7]}.log" in l], blocked.ledger()
     assert [c["role"] for c in blocked.calls("01")] == ["test-writer", "implementer"] + ["fixer"] * 4
     assert blocked.state()["tickets"]["01"]["phase"] == "blocked"
-    assert "ticket/01" in blocked.branches() and "feat: 01 rows" not in blocked.pr_subjects()
+    assert "ticket/feat%2Fcsv/01" in blocked.branches() and "feat: 01 rows" not in blocked.pr_subjects()
 
 
 def test_blocked_ticket_stops_only_the_tickets_it_blocks(blocked):
@@ -372,7 +372,7 @@ def test_non_fast_forward_merge_is_a_plumbing_merge_commit_gated_once(tmp_path):
     commits = [g["commit"] for g in rig.walk_gates()]
     assert sorted(commits) == sorted([a01, a03, tip]), commits
     waited = rig.calls("01", "implementer")[0]
-    assert waited["after_wait"]["branch"] == "ticket/01" and waited["after_wait"]["head"] == waited["head"]
+    assert waited["after_wait"]["branch"] == "ticket/feat%2Fcsv/01" and waited["after_wait"]["head"] == waited["head"]
     assert waited["after_wait"]["status"] == ""
     assert git(rig.repo, "rev-parse", "--abbrev-ref", "HEAD").strip() == "feat/csv"
     assert git(rig.repo, "status", "--short") == "" and (rig.repo / "demo/cli.py").exists()
@@ -439,7 +439,7 @@ def test_resume_returns_a_ticket_with_an_unverifiable_tip_to_implement_from_the_
                                                            commit="feat: 01 again")]})
     assert rig.code == 0, rig.output()
     again = rig.calls("01", "implementer")[1]
-    assert (again["branch"], again["head"]) == ("ticket/01", tw_sha) and len(rig.calls("01", "test-writer")) == 1
+    assert (again["branch"], again["head"]) == ("ticket/feat%2Fcsv/01", tw_sha) and len(rig.calls("01", "test-writer")) == 1
     assert [l for l in rig.ledger()[len(before):] if "01" in l and fake[:7] in l], rig.ledger()
     assert "feat: 01 again" in rig.pr_subjects()
 
@@ -450,7 +450,7 @@ def test_resume_keeps_a_settled_gate_and_runs_no_gate_again(tmp_path):
     state["tickets"]["01"].update(phase="merge", tip=a1, green_gates=[a1])
     (rig.repo / ".agent/implement/state.json").write_text(json.dumps(state))
     gates_before = len(rig.gates())
-    rig.gate_conf(red=["ticket/01"])  # any gate run on the ticket would block it; the end of run gates feat/csv
+    rig.gate_conf(red=["ticket/feat%2Fcsv/01"])  # any gate run on the ticket would block it; the end of run gates feat/csv
     rig.run(plan())
     assert rig.code == 0, rig.output()
     assert len(rig.walk_gates()) == gates_before and rig.walked() == a1

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-16T22:28:03.132Z",
+  "generatedAt": "2026-10-17T06:40:10.976Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.19",
-      "hash": "sha256-42055b9530838eca23d48593e153ff5064a601e3c60240fb68f23b1793ae7223",
+      "version": "0.1.21",
+      "hash": "sha256-ffca735547ff5f7664f80fe98071d1956f839858ee4f1964ef9b7957af41a4cc",
       "description": "Implement a specification in code."
     },
     {