@jesdi/skills 0.0.42 → 0.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jesdi/skills",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "description": "jesdi's agent skills (content package consumed by @jesdi/skills-cli)",
   "license": "MIT",
   "repository": {

package/skills/implement-spec/ARCHITECTURE.md

@@ -60,12 +60,23 @@ and do not know about the run, except `driver_run.py`, which the three deciding
 - The commit of the test-writer is the reference of the ticket's locked files. Before each review, a locked file
   that differs from its reference is a critical finding (`driver_review.locked_findings`).
 - A correction of the test-writer is a new reference. For that reason the driver first puts each locked file back
-  to its locked version (`Run.restore_locked_files`), and a correction may change only the files it lists, after
-  `overrule-test` and in the fix loop. Its commit becomes the reference of each file it lists. A locked file that it
-  does not list and that differs from the old reference keeps the old reference in the ticket's `held`, so a
-  change of the implementer stays a finding (`driver_review.written`).
-- The locked files of merged tickets are checked when a ticket lands (`driver_merge.refused`): the tree that lands
-  must have each of them as the PR tip has it. A ticket's test-writer may change one only when it lists it.
+  to its locked version and commits that (`Run.restore_locked_files`), and a correction may change only the files it
+  lists, after `overrule-test` and in the fix loop. Its commit becomes the reference of each file it lists. A locked
+  file that it does not list and that differs from the old reference keeps the old reference in the ticket's `held`,
+  so a change of the implementer stays a finding (`driver_review.written`).
+- The restore is a commit, not a tree change: an agent commits only its own files, and a gate refuses a tree that
+  is not clean, so a restore left in the tree would turn the next gate red and use a fix round. The correction's
+  prompt names the restored files (`prompts/restored.md`): this is the one path for a change of an earlier ticket's
+  locked test that a later ticket's interface needs.
+- The driver, not the correction, decides whether a restored file fails with the ticket's code: in the fix loop it
+  gates the restore commit, whose parent has a green gate. A red gate goes to the correction as evidence
+  (`prompts/restored-red.md`), and a DONE correction must then list a restored file. An agent's judgement of
+  "this test does not fail" missed a red file and led to a refused merge (issue #90). After `overrule-test` the
+  parent has no green gate, so a red gate proves nothing there: the next review catches the file instead.
+- The locked files of merged tickets are checked before each review (`driver_review.merged_changes`): a change is a
+  `fixture` finding, so it goes to a correction, where the restore and its gate decide. They are checked again when
+  a ticket lands (`driver_merge.refused`): the tree that lands must have each of them as the PR tip has it. A
+  ticket's test-writer may change one only when it lists it.
 - A conflict resolution, of a merge or of the rebase, may not change a locked file.
 
 ### The PR branch
@@ -114,6 +125,9 @@ and do not know about the run, except `driver_run.py`, which the three deciding
   it blocks only after round 4. A red gate on a test-writer correction blocks.
 - The implementer and each fixer get the `--gate` command and run it before they report. The gate of the driver
   stays the source of truth: an agent's run of the gate counts for nothing.
+- No test-writer correction runs after round 4 (`driver_fixloop._act_on`): its findings become `finding` questions
+  with the others. A correction there would add red locked tests that no fix round makes green, and `accept` could
+  not merge the ticket.
 
 ### Questions
 

package/skills/implement-spec/README.md

@@ -95,12 +95,13 @@ Everything is under `.agent/`, which is never committed.
 A ticket is ready when each ticket in its **Blocked by** line is merged and no running ticket touches the same place. The places are the backticked entries of the **Touches** lines: `file` or `file: function`. Two entries are the same place when they name the same file and the same function, or when one of them names the whole file. Each ready ticket takes the lowest free slot.
 
 1. **test-writer** (`prompts/test-writer.md`). It writes one black-box test for each criterion through the Seam and commits them red. Those files are locked. A ticket with Seam `none — refactor` has no test-writer.
-2. **implementer** (`prompts/implementer.md`). It starts from that commit and makes the locked tests green. Its prompt gives the `--gate` command: it runs the gate on its final commit and makes it green before it reports DONE or DONE_WITH_CONCERNS.
+2. **implementer** (`prompts/implementer.md`). It starts from that commit and makes the locked tests green. It makes the gate (`--gate`) green on its final commit before it reports DONE or DONE_WITH_CONCERNS.
 3. **Gate.** The driver runs `--gate` on the ticket tip.
-4. **Review.** The driver compares each locked file of the ticket with the test-writer commit. A file that differs is a critical finding `locked file changed: <path>`. Then the **reviewer** (`prompts/reviewer.md`) runs, and for a ticket with a **Risk** line the **correctness** pass (`prompts/correctness.md`) runs at the same time in the same slot.
+4. **Review.** The driver compares each locked file of the ticket with the test-writer commit. A file that differs is a critical finding `locked file changed: <path>`. A locked file of a merged ticket that the ticket changed since its merge base with the PR branch is a critical `fixture` finding `the ticket changed the locked file of a merged ticket: <path>`, so it goes to a correction (see **Before a correction**). Then the **reviewer** (`prompts/reviewer.md`) runs, and for a ticket with a **Risk** line the **correctness** pass (`prompts/correctness.md`) runs at the same time in the same slot.
 5. **Merge.** The driver merges the reviewed tip into the PR branch with git plumbing, then deletes the ticket branch. A conflict goes to the **conflict** agent (`prompts/conflict.md`) once. Its resolution may change no locked file of the ticket. A second conflict blocks the ticket.
-   **The landing check.** Merges are serial. Before the PR branch moves, the driver compares the tree that is about to land (the ticket tip of a fast-forward, or the merge commit) with the PR tip: each locked file of each merged ticket must be the same tree entry in both: the same blob with the same mode, so a file that became a symlink is a difference. A file that only one of them has is a difference. A file that the landing ticket lists in its own `locked` is not checked: the test-writer of a later ticket can add a test to a file that an earlier ticket locked, and must list that file. A test-writer report that changes such a file and does not list it is rejected, with the usual one rerun. A difference refuses the landing: the ticket is BLOCKED with `locked file changed: <path>` in the ledger, the PR branch does not move, and no fix round runs. The PR branch moves only from the tip that the check read; when another hand moved the branch in between, the driver makes the merge, the check and the gate again, one time. Only that case starts the landing again: a refused landing and a red merge gate block the ticket. The second try runs no conflict agent, so a conflict there blocks the ticket, and so does a branch that moved again.
-   **Before a correction.** A test-writer that corrects locked tests (after `overrule-test`, or for a `fixture` finding or a `test` finding on a locked file) starts from the locked versions: the driver puts back, in the tree, each locked file of the ticket and each locked file of a merged ticket that the ticket changed, and the ledger names each file. A file of a merged ticket goes back to the version of the PR branch.
+   **The landing check.** Merges are serial. Before the PR branch moves, the driver compares the tree that is about to land (the ticket tip of a fast-forward, or the merge commit) with the PR tip: each locked file of each merged ticket must be the same tree entry in both: the same blob with the same mode, so a file that became a symlink is a difference. A file that only one of them has is a difference. A file that the landing ticket lists in its own `locked` is not checked: the test-writer of a later ticket can add a test to a file that an earlier ticket locked, and must list that file. A test-writer report that changes such a file and does not list it is rejected, with the usual one rerun. The review finds such a change first; the landing check catches a change that no review saw, for example of a ticket that merged after the last review. A difference refuses the landing: the ticket is BLOCKED with `locked file changed: <path>` in the ledger, the PR branch does not move, and no fix round runs. The PR branch moves only from the tip that the check read; when another hand moved the branch in between, the driver makes the merge, the check and the gate again, one time. Only that case starts the landing again: a refused landing and a red merge gate block the ticket. The second try runs no conflict agent, so a conflict there blocks the ticket, and so does a branch that moved again.
+   **Before a correction.** A test-writer that corrects locked tests (after `overrule-test`, or for a `fixture` finding or a `test` finding on a locked file) starts from the locked versions: the driver puts back each locked file of the ticket and each locked file of a merged ticket that the ticket changed, commits them in one commit of its own, and the ledger names each file. A file of a merged ticket goes back to the version of the PR branch. The commit keeps the tree of the next fixer and of the gate clean, whatever files the correction commits. The correction's prompt names the restored files: when a test in one of them fails only because the ticket changed an interface that the test uses, the correction updates the file to the new interface, keeps what each test asserts, and lists the file in `locked`.
+   **The gate of the restore.** In the fix loop, the tip before the restore has a green gate, so the driver gates the restore commit and does not leave the question to the correction. A red gate means that a restored file fails with the ticket's code: the correction gets the gate record (`prompts/restored-red.md`), and a DONE correction must list a restored file in `locked`; else it reports BLOCKED with `locked test contradicts spec:`. A green gate with only driver findings to correct closes them with the restore: no test-writer runs. After `overrule-test` the driver does not gate the restore, because the tip before it has no green gate; a change that the next implementer makes to a merged ticket's file is a finding of the next review.
 
 Rules for each agent:
 
@@ -113,18 +114,18 @@ Rules for each agent:
 
 | Finding | What the driver does |
 |---|---|
-| kind `fixture`, any severity, or kind `test`, `critical` or `important`, on a locked file of the ticket | One test-writer correction, outside the fix rounds. The fixer may not edit a locked file, so a fix round cannot close a `test` finding there. The corrected files are the new locked versions, and the next review is a full review. A finding of this kind that is open after the correction blocks the ticket. |
+| kind `fixture`, any severity, or kind `test`, `critical` or `important`, on a locked file of the ticket | One test-writer correction, outside the fix rounds. The fixer may not edit a locked file, so a fix round cannot close a `test` finding there. The corrected files are the new locked versions, and the next review is a full review. A finding of this kind that is open after the correction blocks the ticket. No correction runs after round 4. |
 | `critical` or `important` | One fix round. |
 | `minor` | It stays in the ledger and in the findings file. The final reviewer gets the list. |
 
-A fix round is one **fixer** (`prompts/fixer.md`), which runs the gate on its final commit before it reports, as the implementer does, then the gate of the driver on the new tip, then a re-review of the range of the fix. A mutation proof is repeated only when the fix changed its production line.
+A fix round has three steps: the **fixer** (`prompts/fixer.md`) makes the gate green on its final commit, as the implementer does; the driver runs the gate on the new tip; a re-review reads the range of the fix. A mutation proof is repeated only when the fix changed its production line.
 
-A red gate on the commit of the implementer or of a fixer is a critical finding with source `gate`. Its file is the gate record, and the record holds the output. No review runs on that tip, and the next round starts: a red gate on the commit of the implementer starts round 1. The review after that round covers each fix since the last review and repeats each proof that one of them made due. A red gate after round 4 blocks the ticket, as does a red gate on the commit of a test-writer correction: the correction is outside the fix rounds, and a fixer may not edit the locked files.
+A red gate on the commit of the implementer or of a fixer is a critical finding with source `gate`. Its file is the gate record, and the record holds the output. No review runs on that tip, and the next round starts: a red gate on the commit of the implementer starts round 1. The review after that round covers each fix since the last review and repeats each proof that one of them made due. Two red gates block the ticket: one after round 4, and one on the commit of a test-writer correction, because the correction is outside the fix rounds and a fixer may not edit the locked files.
 
 - Rounds 1 and 2 run on the first entry of the implementer list.
 - Rounds 3 and 4 run on the second entry of the implementer list. When the list has one entry, they stay on it and the ledger says so.
 - There is no ruling at round 2.
-- Findings that are open after round 4 make the ticket BLOCKED. The run ends with exit 1, and the driver writes one question of kind `finding` for each.
+- Findings that are open after round 4 make the ticket BLOCKED. The run ends with exit 1, and the driver writes one question of kind `finding` for each. A finding that would get a test-writer correction is one of them: no correction runs after round 4, because its new locked tests would have no fix round to make them green and the merge gate would be red. So `accept` on each question merges the reviewed tip.
 
 ### End of run
 
@@ -172,7 +173,7 @@ Every report has `status` (`DONE`, `DONE_WITH_CONCERNS`, `NEEDS_CONTEXT`, `BLOCK
 
 | Role | Template | More fields | Checks after the schema |
 |---|---|---|---|
-| test-writer | `prompts/test-writer.md` | `locked` (test file paths), `red` (`test`, `line`) | The driver reads a test node id `<file>::<test>` in `locked` as its file. With DONE: one commit, one locked file and one red line or more. Each locked path is in a commit that the role made. Each `line` is in the log. A locked file of a merged ticket that the role changed is in `locked`. A correction (after `overrule-test`, or for a review finding) changes only the files that it lists in `locked` and the files that the driver restored before it. |
+| test-writer | `prompts/test-writer.md` | `locked` (test file paths), `red` (`test`, `line`) | The driver reads a test node id `<file>::<test>` in `locked` as its file. With DONE: one commit, one locked file and one red line or more. Each locked path is in a commit that the role made. Each `line` is in the log. A locked file of a merged ticket that the role changed is in `locked`. A correction (after `overrule-test`, or for a review finding) changes only the files that it lists in `locked` and the files that the driver restored before it. When the gate is red on the restore commit, a DONE correction lists a restored file in `locked`. |
 | implementer | `prompts/implementer.md` | `green` | With DONE: one commit or more. |
 | reviewer | `prompts/reviewer.md` | `findings` (`severity`, `file`, `line`, `title`, `evidence`, `kind`), `mutations` (`test`, `file`, `line`, `red`); `commits` is empty | In the first review of a tip: `mutations` is required, with a proof for each locked test file (`test` is `<locked file>::<test name>`). Each `red` is in the log. |
 | correctness | `prompts/correctness.md` | the same as the reviewer; `commits` is empty | `mutations` is optional. |
@@ -202,7 +203,7 @@ Answer with `--answer <question id>=<option id>` on the next run, or through the
 
 | Check | Where it lives |
 |---|---|
-| Locked tests with a demonstrated red | `driver_report.py` `_proof_errors`: each red line of the test-writer report must be in its log. `driver_review.py` `locked_findings`: a locked file of the ticket that differs from the test-writer commit is a critical finding, before each review. `driver_merge.py` `refused`, called from `driver.py` `_checked_landing` under the merge lock: a locked file of a merged ticket that differs between the PR tip and the tree that is about to land refuses the landing, so a later ticket cannot change the locked test of an earlier one. `driver_report.py` `_merged_errors` rejects a test-writer report that changes such a file and does not list it. |
+| Locked tests with a demonstrated red | `driver_report.py` `_proof_errors`: each red line of the test-writer report must be in its log. `driver_review.py` `locked_findings`: a locked file of the ticket that differs from the test-writer commit is a critical finding, before each review. `driver_review.py` `merged_changes`: a locked file of a merged ticket that the ticket changed is a critical `fixture` finding, before each review. `driver_merge.py` `refused`, called from `driver.py` `_checked_landing` under the merge lock: a locked file of a merged ticket that differs between the PR tip and the tree that is about to land refuses the landing, so a later ticket cannot change the locked test of an earlier one. `driver_report.py` `_merged_errors` rejects a test-writer report that changes such a file and does not list it. |
 | One mutation proof for each locked test | `prompts/reviewer.md` asks for one proof for each locked test. `driver_report.py` `_locked_errors` and `_proof_errors` reject a first review with no proof for a locked test file, or with a red line that is not in the log. `driver_review.py` `follow` finds the proofs that a fix makes due again. |
 | One independent correctness pass for each risky ticket | `driver_fixloop.py` `_review` adds the pass for a ticket with a **Risk** line. `driver_agents.py` `correctness_entry` picks the entry of another provider, and `load_models` stops the run when there is none or its CLI is not on PATH. |
 | One full gate for each candidate | `driver_gate.py` `run`, called from `driver_run.py` `Run.gate`: one record for each commit the driver is about to trust. Green is exit 0 on a tree that is clean before and after, with HEAD not moved. |

package/skills/implement-spec/driver.py

@@ -107,8 +107,9 @@ def _run_roles(ticket: Ticket, slot_number: int, run: Run) -> None:
         values["start_sha"] = start
         # A test-writer on a ticket that has locked tests is the correction after a ruling.
         check = {"correction": role == "test-writer" and bool(entry["test_writer_sha"])}
-        if check["correction"]:
-            check["restored"] = run.restore_locked_files(number, slot)
+        if check["correction"] and (restored := run.restore_locked_files(number, slot)):
+            values.update(start_sha=driver_slots.head(slot), restored=" ".join(restored))
+            notes, check["restored"] = [*notes, "restored"], restored
         with during(f"the {role}"):
             report = run.agent(role, number, slot, values, notes=notes, check=check)
         facts = {"tip": driver_slots.head(slot)}

package/skills/implement-spec/driver_fixloop.py

@@ -11,6 +11,7 @@ from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 
 import driver_agents
+import driver_merge
 import driver_review
 import driver_slots
 from driver_run import OUT, Blocked, Run, during, ledger
@@ -86,7 +87,8 @@ def _review(job: Job) -> list[dict]:
     """Review `job.tip`. Returns the findings of the driver and of each reviewer."""
     run, number = job.run, job.ticket.number
     state = run.state.ticket(number, phase="review")
-    found = _log_findings(job, driver_review.locked_findings(job.slot, state))
+    merged = driver_merge.changed(job.slot, run.tip(), driver_merge.protected(run.state.read()["tickets"], number))
+    found = _log_findings(job, driver_review.locked_findings(job.slot, state) + driver_review.merged_changes(merged))
     cast = [("reviewer", "")]
     if job.ticket.risk:
         cast.append(("correctness", driver_agents.correctness_entry(run.models)))
@@ -105,10 +107,23 @@ def _correct(job: Job, findings: list[dict]) -> None:
     if job.corrected:
         titles = "; ".join(finding["title"] for finding in findings)
         raise Blocked(f"the review: a locked-test finding is open after the test-writer correction: {titles}")
-    check = {"correction": True, "restored": run.restore_locked_files(number, job.slot)}
+    restored = run.restore_locked_files(number, job.slot)
+    job.tip = driver_slots.head(job.slot)  # the restore is a commit of the driver
+    # The gate was green on the tip before the restore, so a red gate here is a restored file that fails with the
+    # ticket's code. The driver decides that, not the correction (issue #90).
+    with during("the gate of the restore"):
+        record = run.red_gate(number, job.slot, job.tip) if restored else ""
+    if not record and all(finding["source"] == "driver" for finding in findings):
+        job.previous = ""  # no review has seen the restore commit
+        ledger(f"Ticket {number}: the code does not need the change to {', '.join(restored)}: the restore closes it, "
+               "with no correction.")
+        return
+    values = {**job.pointers(job.round), "restored": " ".join(restored),
+              "record": record and os.path.relpath(record, job.slot)}
+    notes = ["correction"] + ["restored"] * bool(restored) + ["restored-red"] * bool(record)
     with during("the test-writer correction"):
-        report = run.agent("test-writer", number, job.slot, job.pointers(job.round), notes=["correction"],
-                           fix_round=job.round + 1, check=check)
+        report = run.agent("test-writer", number, job.slot, values, notes=notes, fix_round=job.round + 1,
+                           check={"correction": True, "restored": restored, "restore_red": bool(record)})
     job.tip, job.previous, job.corrected = driver_slots.head(job.slot), "", True
     entry = run.state.read()["tickets"][number]
     run.state.ticket(number, tip=job.tip, **driver_review.written(job.slot, entry, report["locked"], job.tip))
@@ -146,8 +161,11 @@ def _act_on(job: Job, found: list[dict]) -> bool:
     """Do what the findings of a review ask for: a correction, a fix round, or a stop. True: none is open."""
     locked = job.run.state.read()["tickets"][job.ticket.number]["locked"]
     to_correct, to_fix = driver_review.route(found, locked)
+    if job.round == ROUNDS:
+        # No correction after round 4: no fix round could make its new locked tests green, so `accept` could not merge.
+        to_correct, to_fix = [], [finding for finding in found if finding in to_correct + to_fix]
     # A changed locked file is fixed first: a correction on top of it would make the changed file the reference.
-    locked_file_changed = any(finding["source"] == "driver" for finding in found)
+    locked_file_changed = any(finding["source"] == "driver" for finding in to_fix)
     if to_correct and not locked_file_changed:
         _correct(job, to_correct)
         if not to_fix:

package/skills/implement-spec/driver_merge.py

@@ -82,16 +82,21 @@ def refused(tickets: dict, number: str, old: str, new: str) -> str:
                                         if before.get(path) != after.get(path))
 
 
+def changed(slot: str, pr_tip: str, paths: list[str]) -> list[str]:
+    """Each of `paths` that the ticket changed in the tree of `slot`."""
+    # Against the merge base: a file that only the PR branch changed since then is not the ticket's change.
+    base = git(slot, "merge-base", "HEAD", pr_tip).stdout.strip() or pr_tip
+    return names(git(slot, "diff", "--name-only", "-z", base, "--", *paths).stdout) if paths else []
+
+
 def restore(slot: str, pr_tip: str, paths: list[str]) -> list[str]:
     """Put each of `paths` that the ticket changed back to the version of the PR tip, in the tree of `slot` only; a
     file the PR tip does not have is removed. Returns those paths."""
-    # Against the merge base: a file that only the PR branch changed since then is not the ticket's change.
-    base = git(slot, "merge-base", "HEAD", pr_tip).stdout.strip() or pr_tip
-    changed = names(git(slot, "diff", "--name-only", "-z", base, "--", *paths).stdout) if paths else []
-    for path in changed:
+    restored = changed(slot, pr_tip, paths)
+    for path in restored:
         if git(slot, "checkout", "-q", pr_tip, "--", path).returncode:
             git(slot, "rm", "-q", "-f", "--", path)
-    return changed
+    return restored
 
 
 def land(pr_branch: str, new: str, old: str) -> str:

package/skills/implement-spec/driver_report.py

@@ -2,6 +2,7 @@
 
 context: repo (slot path), branch, start (HEAD when the role started), log, round (1 = first review), locked,
   correction (a test-writer corrects locked tests), restored (locked files the driver put back before it),
+  restore_red (the gate is red on the commit of that restore),
   owners (ticket numbers, for the final fix batch), merged (locked files of merged tickets, not its own), pr (tip)."""
 from __future__ import annotations
 
@@ -66,8 +67,14 @@ def _correction_errors(report: dict, context: dict) -> list[str]:
         return []
     changed = _git(context["repo"], "diff", "--name-only", "-z", context["start"], context["branch"], end="\0")
     more = [path for path in changed if path not in report.get("locked", []) + context.get("restored", [])]
-    return [f"a correction may change only the files it lists in `locked`: its commits also change {', '.join(more)}"
-            ] if more else []
+    errors = [f"a correction may change only the files it lists in `locked`: its commits also change {', '.join(more)}"
+              ] if more else []
+    if context.get("restore_red") and report["status"] in ("DONE", "DONE_WITH_CONCERNS") and not (
+            set(report["locked"]) & set(context["restored"])):
+        errors.append("the gate is red on the restore commit, so a restored file fails with the code of this ticket: "
+                      "update that file and list it in `locked`, or report BLOCKED with a concern that starts with "
+                      "`locked test contradicts spec:`")
+    return errors
 
 
 def _merged_errors(report: dict, context: dict) -> list[str]:

package/skills/implement-spec/driver_review.py

@@ -38,6 +38,14 @@ def locked_changes(slot: str, sha: str | None, locked: list[str]) -> list[dict]:
              "evidence": f"git diff {sha}..HEAD -- {path}"} for path, title in titles.items()]
 
 
+def merged_changes(paths: list[str]) -> list[dict]:
+    """One critical `fixture` finding per locked file of a merged ticket that the ticket changed. A fixture finding
+    goes to a test-writer correction: the driver puts the file back before it and gates that commit."""
+    return [{"severity": "critical", "file": path, "line": 1, "kind": "fixture", "source": "driver",
+             "title": f"the ticket changed the locked file of a merged ticket: {path}",
+             "evidence": f"git diff <merge base with the PR branch> -- {path}"} for path in paths]
+
+
 def _references(entry: dict) -> list[tuple[str | None, list[str]]]:
     """(reference commit, the locked files it is the reference of): `test_writer_sha`, or the older commit that
     `held` names for a file."""

package/skills/implement-spec/driver_run.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import subprocess
 import threading
 import time
 from contextlib import contextmanager
@@ -23,7 +24,7 @@ import driver_report
 import driver_review
 import driver_slots
 import driver_state
-from driver_slots import git
+from driver_slots import git, names
 
 OUT = Path(".agent/implement")
 FINAL = "final"  # the end of run has its reports and gate records under this name, as a ticket has under its number
@@ -156,13 +157,23 @@ class Run:
 
     def restore_locked_files(self, number: str, slot: str) -> list[str]:
         """Before a test-writer correction: put each locked file the implementer changed back to its locked
-        version in the tree, so the correction's commit carries no change of the implementer. Returns the paths."""
+        version in one commit of the driver, so the correction starts from the locked versions on a clean index and
+        its commit carries no change of the implementer. Other work in the tree stays. Returns the paths."""
         tickets = self.state.read()["tickets"]
         paths = (driver_review.restore_locked(slot, tickets[number])
                  + driver_merge.restore(slot, self.tip(), driver_merge.protected(tickets, number)))
+        # A path whose change was never committed is back at HEAD already, and `git commit -- <path>` refuses it.
+        changed = names(git(slot, "diff", "--name-only", "-z", "HEAD", "--", *paths).stdout) if paths else []
+        if changed:
+            words = "implement-spec: restore the locked files before the correction"
+            made = subprocess.run(["git", "-C", slot, "commit", "-q", "--no-verify", "-m", words, "--", *changed],
+                                  capture_output=True, text=True, env={**os.environ, **driver_merge.identity("HEAD", slot)})
+            if made.returncode:
+                raise Blocked(f"the driver cannot commit the restored locked files: {made.stderr.strip()}")
+            self.state.ticket(number, tip=driver_slots.head(slot))
         for path in paths:
             ledger(f"Ticket {number}: {path} was not the locked version at the correction: the driver restored it in "
-                   "the tree, so the correction starts from the locked version.")
+                   "a commit, so the correction starts from the locked version.")
         return paths
 
 

package/skills/implement-spec/prompts/final-fixer.md

@@ -12,7 +12,7 @@ Fix each finding in the list as one batch, in one commit or in several. Leave th
 Each commit belongs to one ticket: the ticket whose criterion or code the commit changes. A fix for two tickets is two commits.
 Never edit a locked file: each one stays as it is at {start_sha}, and a locked file that differs is a critical finding of the next review.
 Use targeted tests while you work.
-Before you report DONE or DONE_WITH_CONCERNS, run the gate on your final commit, with IMPLEMENT_SPEC_BASE={pr_branch} in the environment: `{gate}`. Fix each failure, commit, and run it again until it is green. The driver runs the gate again on your final commit, and a scoped review reads your commits.
+Before you report DONE or DONE_WITH_CONCERNS, make the gate green on your final commit: run `{gate}` with IMPLEMENT_SPEC_BASE={pr_branch} in the environment, then fix, commit, and run it again until it passes. The driver runs the gate again on that commit, and a scoped review reads your commits.
 Commit your work on the checked-out PR branch and change no commit that is on it now. Do not dispatch subagents.
 In `commits`, give every commit you made with the number of its ticket: the driver names each commit `fix(NN): <your subject>` from it, and a commit with no ticket is a violation. In `green`, give the summary lines of the passing test output.
 

package/skills/implement-spec/prompts/fixer.md

@@ -11,7 +11,7 @@ Fix each finding of severity critical or important in the findings file. Leave t
 Never edit a locked file. The one exception is a finding `locked file changed`: make that file equal to its content at {test_writer_sha}.
 If a locked test contradicts the spec or the ticket, so that no fix can make it green, stop and report BLOCKED with a concern that starts with `locked test contradicts spec:`, then the test and the evidence.
 Use targeted tests while you work.
-Before you report DONE or DONE_WITH_CONCERNS, run the gate on your final commit, with IMPLEMENT_SPEC_BASE={pr_branch} in the environment: `{gate}`. Fix each failure, commit, and run it again until it is green. The driver runs the gate again on your final commit, and a re-review reads the lines you changed.
+Before you report DONE or DONE_WITH_CONCERNS, make the gate green on your final commit: run `{gate}` with IMPLEMENT_SPEC_BASE={pr_branch} in the environment, then fix, commit, and run it again until it passes. The driver runs the gate again on that commit, and a re-review reads the lines you changed.
 A finding from the `gate` is a red gate: its file is the gate record. Read the output there and make the gate green.
 Commit your work on the checked-out ticket branch. Do not dispatch subagents.
 In `ticket`, give the number of the ticket that owns your commits. In `green`, give the summary lines of the passing test output.

package/skills/implement-spec/prompts/implementer.md

@@ -9,8 +9,8 @@ Locked files: {locked}
 Make the locked tests green and meet each criterion of the ticket. For internal code, work in vertical test-first slices: one failing test, the smallest code that passes it, then the next slice.
 Never edit a locked file. If a locked test contradicts the spec or the ticket, stop and report BLOCKED with a concern that starts with `locked test contradicts spec:`, then the test and the evidence.
 Commit your work on the checked-out ticket branch. Do not dispatch subagents.
-Run targeted tests while you work.
-Before you report DONE or DONE_WITH_CONCERNS, run the gate on your final commit, with IMPLEMENT_SPEC_BASE={pr_branch} in the environment: `{gate}`. Fix each failure, commit, and run it again until it is green. The driver runs the gate again on your final commit.
+Use targeted tests while you work.
+Before you report DONE or DONE_WITH_CONCERNS, make the gate green on your final commit: run `{gate}` with IMPLEMENT_SPEC_BASE={pr_branch} in the environment, then fix, commit, and run it again until it passes. The driver runs the gate again on that commit.
 In `green`, give the summary lines of the passing test output.
 
 Write one JSON report at {report} that matches this schema:

package/skills/implement-spec/prompts/restored-red.md

@@ -0,0 +1,3 @@
+
+The driver ran the gate on that commit, {start_sha}, and the gate is red: read the output in {record}. The gate was green before the restore, so a restored file fails with the code of this ticket.
+Update each restored file that fails so that it works with the new interface: keep what each test asserts, and list the file in `locked`. When no such update can keep what a test asserts, report BLOCKED with a concern that starts with `locked test contradicts spec:`, then the test and the evidence.

package/skills/implement-spec/prompts/restored.md

@@ -0,0 +1,3 @@
+
+The driver put back these files at their locked versions, in a commit before this call, because the implementer or a fixer had changed them: {restored}.
+A fixer may not change a locked file. When a test in one of these files now fails only because this ticket changed an interface that the test uses, update that file so it works with the new interface: keep what each test asserts, and list the file in `locked`. Else leave the file as it is.

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

@@ -165,7 +165,7 @@ def two_locked():
 
 
 def restored(path):
-    return f"Ticket 01: {path} was not the locked version at the correction: the driver restored it in the tree"
+    return f"Ticket 01: {path} was not the locked version at the correction: the driver restored it in a commit"
 
 
 TWO_TESTS = "def test_x():\n    assert 01 == 'x'\n\n\ndef test_y():\n    assert 1 == 'y'\n"
@@ -330,6 +330,22 @@ def test_round_4_findings_wait_for_every_answer_before_the_ticket_merges(tmp_pat
     assert rig.code == 0 and rig.state()["tickets"]["01"]["phase"] == "merged" and len(rig.calls("01", "fixer")) == 4
 
 
+def test_a_test_finding_after_round_4_is_a_question_and_accepting_every_question_merges(tmp_path):
+    """Issue 84: after round 4 no test-writer correction runs. Its red locked tests would make `accept` a lie."""
+    locks = {**tw("01"), "files": {"tests/test_01.py": "# red lock\n"}, "commit": "test: 01 lock"}
+    rig = Inside(tmp_path, ONE, gate={"subjects": ["test: 01 lock"]})
+    vacuous = finding("VACUOUS", "critical", kind="test", file="tests/test_01.py", line=1)
+    last = review("01", [finding("STUCK"), vacuous])
+    rig.run(plan(**{"01/test-writer": [tw("01"), locks], "01/reviewer": [review("01", [finding("STUCK")])] * 4 + [last],
+                    "01/fixer": [fix("01", n) for n in (1, 2, 3, 4)]}))
+    assert rig.code == 1 and len(rig.calls("01", "test-writer")) == 1
+    assert [q["subject"] for q in rig.state()["run"]["questions"]] == ["STUCK (demo/export.py:99)",
+                                                                       "VACUOUS (tests/test_01.py:1)"]
+    rig.run({}, "--answer", "01-finding-1=accept", "--answer", "01-finding-2=accept")
+    assert rig.code == 0, rig.ledger()
+    assert rig.state()["tickets"]["01"]["phase"] == "merged"
+
+
 def test_one_answer_that_keeps_the_ticket_blocked_wins_over_an_accept():
     one = asked("finding", subject="A")
     two = asked("finding", subject="B", before=[one])

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,25 +286,27 @@ 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()
 
 
 # A correction is a test-writer: a file that it lists is its ticket's own. It must start from the locked version.
-APPEND = "--- a/tests/test_01.py\n+++ b/tests/test_01.py\n@@ -1,2 +1,3 @@\n def test_x():\n     assert True\n+# corrected\n"
-RESTORED_01 = ("Ticket 02: tests/test_01.py was not the locked version at the correction: the driver restored it in "
-               "the tree, so the correction starts from the locked version.")
+# The edit has no context lines, so it applies to the file whatever version the tree holds.
+APPEND = "--- a/tests/test_01.py\n+++ b/tests/test_01.py\n@@ -2,0 +3 @@\n+# corrected\n"
+CORRECTED_01 = LOCKED_01 + "# corrected\n"
+RESTORED_01 = ("Ticket 02: tests/test_01.py was not the locked version at the correction: the driver restored it in a "
+               "commit, so the correction starts from the locked version.")
 
 
 def appending(tmp_path, **changes):
-    """A correction of 02 that appends a line to tests/test_01.py as the implementer of 02 left it, and lists it."""
+    """A correction of 02 that appends a line to tests/test_01.py as the tree holds it, and lists it."""
     (tmp_path / "append.patch").write_text(APPEND)
-    step = {**tw("02"), "git": [["apply", str(tmp_path / "append.patch")]], "commit": "test: 02 corrected", **changes}
+    step = {**tw("02"), "git": [["apply", "--unidiff-zero", str(tmp_path / "append.patch")]], "commit": "test: 02 corrected", **changes}
     step["report"] = {**step["report"], "locked": ["tests/test_02.py", "tests/test_01.py"]}
     return step
 
@@ -325,7 +327,7 @@ def test_an_overrule_correction_starts_from_the_locked_file_of_the_merged_ticket
     rig = Inside(tmp_path, three()).run(steps)
     assert rig.code == 2, rig.ledger()
     rig.run(steps, "--answer", "02-locked-test-1=overrule-test")
-    assert on_pr(rig, "tests/test_01.py") == LOCKED_01, rig.ledger()
+    assert on_pr(rig, "tests/test_01.py") == CORRECTED_01, rig.ledger()
     assert rig.led("Ticket 02:", "restored") == [RESTORED_01] and rig.code == 0
 
 
@@ -335,10 +337,60 @@ def test_a_fixture_correction_starts_from_the_locked_file_of_the_merged_ticket(t
     correction = appending(tmp_path, files={"tests/test_02.py": "def test_x():\n    assert '02' == 'x'  # corrected\n"})
     rig = Inside(tmp_path, three()).run(plan(**{"02/implementer": [CHEAT], "02/test-writer": [tw("02"), correction],
                                                 "02/reviewer": [review("02", [stale]), proves("02", "tests/test_01.py")]}))
-    assert on_pr(rig, "tests/test_01.py") == LOCKED_01, rig.ledger()
+    assert on_pr(rig, "tests/test_01.py") == CORRECTED_01, rig.ledger()
     assert rig.led("Ticket 02:", "restored") == [RESTORED_01] and rig.code == 0
 
 
+def test_the_restore_before_a_correction_is_committed_so_the_next_fixer_and_its_gate_find_a_clean_tree(tmp_path):
+    """Issue #86: the correction and the fixer each commit only their own files. The restore of the merged ticket's
+    file must not stay in the tree, where the gate of the fixer's commit is `not clean` and burns a round."""
+    weak = finding("WEAK", kind="test", file="tests/test_02.py")
+    stronger = "def test_x():\n    assert '02' == 'x'  # stronger\n"
+    correction = {**tw("02"), "files": {"tests/test_02.py": stronger}, "commit": "test: 02 stronger",
+                  "only": ["tests/test_02.py"]}
+    rig = Inside(tmp_path, three()).run(plan(**{
+        "02/implementer": [CHEAT], "02/test-writer": [tw("02"), correction],
+        "02/reviewer": [review("02", [weak, STUCK]), review("02")], "02/fixer": [fix("02", 1, only=["demo/export.py"])]}))
+    assert rig.code == 0, rig.ledger()
+    assert rig.led("Ticket 02:", "restored") == [RESTORED_01]
+    (fixer,) = rig.calls("02", "fixer")
+    assert fixer["status"] == "" and fixer["head"] == rig.calls("02", "test-writer")[1]["sha"]
+    assert not [gate for gate in rig.folder("02").glob("gate-*.log") if "not clean" in gate.read_text()]
+    assert rig.state()["tickets"]["02"]["round"] == 1 and on_pr(rig, "tests/test_01.py") == LOCKED_01
+    # The correction is told which files the driver put back, so it may update one compatibly when it lists it.
+    prompt = rig.prompt("test-writer-1", "02")
+    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"
 
 
@@ -351,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": [{}, {}]})
@@ -360,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)
 
 

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

@@ -31,7 +31,7 @@ import time
 import pytest
 
 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 +74,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,13 +99,13 @@ 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
@@ -117,12 +124,12 @@ def test_a_ticket_that_merged_the_pr_branch_into_itself_lands_with_the_tests_of_
     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 rig.code == 0 and restored(rig, "03", T01), rig.output()
     assert phase(rig, "01") == "merged" and on_pr(rig, T01) == LOCKED_01
 
 

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

@@ -24,13 +24,16 @@ import pytest
 from test_cli import SKILL, ticket, three, git, models_file
 from test_walk import RUNNER, Rig, fix, impl, plan, tw
 
-# The fake runner of test_walk plus two hooks: `git` runs before the step's files, `git_after` right after them.
+# The fake runner of test_walk plus three hooks: `git` runs before the step's files, `git_after` right after them,
+# and `only` names the paths the commit takes, as an agent that commits its own files only.
 HOOKED = RUNNER.replace(
     'for path, text in step.get("files", {}).items():',
     'for cmd in step.get("git", []):\n    git(*cmd)\nfor path, text in step.get("files", {}).items():', 1).replace(
     'sys.stdout.write(step.get("stdout", ""))',
-    'for cmd in step.get("git_after", []):\n    git(*cmd)\nsys.stdout.write(step.get("stdout", ""))', 1)
-assert HOOKED.count("git_after") == 1 and HOOKED.count('step.get("git", [])') == 1
+    'for cmd in step.get("git_after", []):\n    git(*cmd)\nsys.stdout.write(step.get("stdout", ""))', 1).replace(
+    'git("commit", "-q", "-m", step["commit"])',
+    'git("commit", "-q", "-m", step["commit"], *(["--", *step["only"]] if "only" in step else []))', 1)
+assert HOOKED.count("git_after") == 1 and HOOKED.count('step.get("git", [])') == 1 and HOOKED.count('step["only"]') == 1
 
 ONE = {"01-export-rows.md": ticket("01", "Export rows")}
 RISKY = {"02-quote-fields.md": ticket("02", "Quote fields", risk="persistence")}

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-16T10:22:13.328Z",
+  "generatedAt": "2026-10-16T23:46:48.180Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.18",
-      "hash": "sha256-b10cd79532e2c8a33ddb8c55934ee26ee7f98d104ff7805bc3e2b819d0bb9241",
+      "version": "0.1.20",
+      "hash": "sha256-9c85f3c37deb0c2e9715172ccdfbb71ef65c066aa8e8c1505d9d2e968b84f0fd",
       "description": "Implement a specification in code."
     },
     {