@jesdi/skills 0.0.44 → 0.0.46

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-16T23:46:48.180Z",
+  "generatedAt": "2026-10-17T15:47:59.977Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.20",
-      "hash": "sha256-9c85f3c37deb0c2e9715172ccdfbb71ef65c066aa8e8c1505d9d2e968b84f0fd",
+      "version": "0.1.22",
+      "hash": "sha256-66e2dec93c2b4ca09e8ca6693307e5e92f46fe1bd9b0a44379e7d4a4bd82d3f9",
       "description": "Implement a specification in code."
     },
     {