@jesdi/skills 0.0.36 → 0.0.38

package/package.json

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

package/skills/implement-spec/ARCHITECTURE.md

@@ -12,7 +12,7 @@ A comment in the code is for a line that looks wrong or removable without it.
 |---|---|
 | `driver.py` | The command line, the checks before the first agent, the walk of the ticket graph, one ticket from its phase to merged or blocked, the landing on the PR branch, the exit code |
 | `driver_run.py` | `Run` (what all ticket threads share), one agent with its one rerun, the gate call, the ledger, `Blocked` |
-| `driver_fixloop.py` | A gated ticket tip in, a reviewed tip out: review, fixture correction, fix rounds |
+| `driver_fixloop.py` | A gated ticket tip in, a reviewed tip out: review, test-writer correction, fix rounds |
 | `driver_final.py` | The end of run: tidy, rebase, gate, final review, one fix batch, push |
 | `driver_tickets.py`, `driver_graph.py` | Ticket files in, tickets or errors out; which tickets can start now |
 | `driver_agents.py` | Model entries, the CLI command of each provider, prompt templates, the blocking launch |

package/skills/implement-spec/README.md

@@ -100,7 +100,7 @@ A ticket is ready when each ticket in its **Blocked by** line is merged and no r
 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.
 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) 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.
+   **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.
 
 Rules for each agent:
 
@@ -113,13 +113,13 @@ Rules for each agent:
 
 | Finding | What the driver does |
 |---|---|
-| kind `fixture`, any severity | One test-writer correction, outside the fix rounds. The next review is a full review. |
+| 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. |
 | `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`), then the gate 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 red gate on the commit 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. The re-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 the implementer or of a fixture correction.
+A red gate on the commit 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. The re-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 the implementer or of a test-writer correction.
 
 - 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.
@@ -172,7 +172,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` (paths), `red` (`test`, `line`) | 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`. |
+| 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`. |
 | 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. |
@@ -190,7 +190,7 @@ A question is a bounded choice for the operator. `driver_decisions.py` `KINDS` h
 
 | Kind | Question id | Asked when | Run exit | Options |
 |---|---|---|---|---|
-| `locked-test` | `<NN>-locked-test-<n>` | An implementer reports BLOCKED with a concern that starts with `locked test contradicts spec:`. | 2 | `overrule-test`: the test-writer corrects the test, then the implementer runs again. `overrule-implementer` (recommended): the implementer runs again. |
+| `locked-test` | `<NN>-locked-test-<n>` | An implementer or a fixer reports BLOCKED with a concern that starts with `locked test contradicts spec:`. | 2 | `overrule-test`: the test-writer corrects the test from that report, then the implementer runs again, and the fix rounds count from 0: the corrected tests are a new contract. `overrule-implementer` (recommended): the implementer runs again. |
 | `finding` | `<NN>-finding-<n>` | A finding is open after fix round 4. One question for each finding. | 1 | `accept`: close the finding; the ticket merges when each of its findings is accepted. `split` (recommended) and `redesign`: the ticket stays BLOCKED, with the ruling in the ledger. |
 | `final-finding` | `final-finding-<n>` | A finding is open after the second round of the final review. | 2 | `fix` (recommended): the finding stays open and nothing is pushed. `accept`: close the finding. |
 

package/skills/implement-spec/driver.py

@@ -69,13 +69,20 @@ def _check_out_ticket(ticket: Ticket, slot_number: int, entry: dict, run: Run) -
     return driver_slots.head(slot)
 
 
+def _blocked_report(number: str, run: Run) -> str:
+    """The report of the last `locked-test` stop of the ticket: an implementer's or a fixer's."""
+    asked = [q["evidence"][0] for q in run.state.read()["run"]["questions"]
+             if (q["ticket"], q["kind"]) == (number, "locked-test")]
+    return asked[-1] if asked else str(OUT / number / "implementer-0.json")
+
+
 def _prompt_values(ticket: Ticket, slot: str, run: Run) -> dict[str, str]:
     """The pointers every prompt of the ticket gets. An agent works in its slot, so paths are relative to it."""
     folder = OUT / ticket.number
     return {"spec": os.path.relpath(run.args.spec, slot), "seam": ticket.seam, "pr_branch": run.pr,
             "branch": f"ticket/{ticket.number}", "ticket": os.path.relpath(Path(run.args.tickets) / ticket.file, slot),
             "correctness": str(driver_review.CORRECTNESS),
-            "blocked_report": os.path.relpath(folder / "implementer-0.json", slot),
+            "blocked_report": os.path.relpath(_blocked_report(ticket.number, run), slot),
             "writer_report": os.path.relpath(folder / "test-writer-0.json", slot)}
 
 

package/skills/implement-spec/driver_decisions.py

@@ -37,7 +37,7 @@ KINDS = {
         {"overrule-test": Option(
             "The test is wrong. The test-writer corrects it in one correction run, then the implementer runs again.",
             "Ruling: {ticket} locked test overruled: the test-writer corrects {subject}, then the implementer runs "
-            "again.", {"phase": "test-writer", "note": "overruled"}),
+            "again.", {"phase": "test-writer", "note": "overruled", "round": 0}),  # new tests, new fix rounds
          "overrule-implementer": Option(
             "The test is right. The implementer runs again and makes the test green as it is.",
             "Ruling: {ticket} locked test stands: the implementer is overruled on {subject} and runs again.",
@@ -73,8 +73,9 @@ KINDS = {
 
 
 def contradicted(role: str, report: dict) -> str:
-    """The locked tests an implementer's BLOCKED report says contradict the spec; "" when it is not that stop."""
-    if role != "implementer" or report.get("status") != "BLOCKED":
+    """The locked tests that a BLOCKED report of an implementer or a fixer says contradict the spec; "" when it is not
+    that stop."""
+    if role not in ("implementer", "fixer") or report.get("status") != "BLOCKED":
         return ""
     return "; ".join(filter(None, (concern[len(CONTRADICTS):].strip() for concern in report["concerns"]
                                    if concern.startswith(CONTRADICTS))))

package/skills/implement-spec/driver_fixloop.py

@@ -1,7 +1,7 @@
-"""A gated ticket tip in, a reviewed tip out: the review, the fixture corrections and the fix rounds.
+"""A gated ticket tip in, a reviewed tip out: the review, the test-writer corrections and the fix rounds.
 
 Reports of a ticket are `<role>-<K>.json`: K is the fix round the agent follows (reviewer, correctness) or is
-(fixer). A fixture correction after the review of round K is `test-writer-<K+1>.json`.
+(fixer). A test-writer correction after the review of round K is `test-writer-<K+1>.json`.
 """
 from __future__ import annotations
 
@@ -31,7 +31,7 @@ class Job:
     previous: str = ""  # the tip before the last fix; "" makes the next review a full one
     proofs: set[tuple[str, int]] = field(default_factory=set)  # mutation proofs so far, at `tip`
     again: set[tuple[str, int]] = field(default_factory=set)  # each proof at `tip` that a fix made due again
-    corrected: bool = False  # the last step was a fixture correction
+    corrected: bool = False  # the last step was a test-writer correction
     red: bool = False  # the gate of `tip` is red, so no review saw it
 
     def pointers(self, review: int) -> dict[str, str]:
@@ -99,21 +99,21 @@ def _review(job: Job) -> list[dict]:
     return found
 
 
-def _correct_fixture(job: Job, fixture: list[dict]) -> None:
-    """One test-writer correction for the fixture findings. It is outside the fix rounds."""
+def _correct(job: Job, findings: list[dict]) -> None:
+    """One test-writer correction for the findings on the locked tests. It is outside the fix rounds."""
     run, number = job.run, job.ticket.number
     if job.corrected:
-        titles = "; ".join(finding["title"] for finding in fixture)
-        raise Blocked(f"the review: a fixture finding is open after the test-writer correction: {titles}")
+        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}")
     run.restore_locked_files(number, job.slot)
-    with during("the fixture correction"):
+    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)
     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))
-    for finding in fixture:
-        ledger(f"Ticket {number}: fixture correction in {finding['file']}, outside the fix rounds: "
+    for finding in findings:
+        ledger(f"Ticket {number}: {finding['kind']} correction in {finding['file']}, outside the fix rounds: "
                f"{finding['title']}: {finding['evidence']}. The test-writer corrected it at {job.tip[:7]}.")
 
 
@@ -137,18 +137,19 @@ def _fix(job: Job) -> None:
         # No review saw `before`: the next review covers the fix before it too, and its due proofs stay due.
         due |= set(driver_review.follow(job.slot, before, job.tip, job.again))
     else:
-        # No review has seen a fixture correction, so the review after a fix on a corrected tip is a full one.
+        # No review has seen a test-writer correction, so the review after a fix on a corrected tip is a full one.
         job.previous = "" if job.corrected else before
     job.corrected, job.proofs, job.again = False, set(followed), due
 
 
 def _act_on(job: Job, found: list[dict]) -> bool:
-    """Do what the findings of a review ask for: a fixture correction, a fix round, or a stop. True: none is open."""
-    fixture, to_fix = driver_review.route(found)
+    """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)
     # 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)
-    if fixture and not locked_file_changed:
-        _correct_fixture(job, fixture)
+    if to_correct and not locked_file_changed:
+        _correct(job, to_correct)
         if not to_fix:
             return False
     if not to_fix:

package/skills/implement-spec/driver_report.py

@@ -100,6 +100,11 @@ def _locked_errors(report: dict, context: dict) -> list[str]:
             if not any(test.startswith(path) for test in tests)]
 
 
+def locked_files(listed: list[str]) -> list[str]:
+    """The files of a `locked` list: a test node id `<file>::<test>` names its file. In order, each file once."""
+    return list(dict.fromkeys(entry.partition("::")[0] for entry in listed))
+
+
 def validate(role: str, path: str, context: dict) -> list[str]:
     try:
         report = json.loads(Path(path).read_text())
@@ -111,5 +116,7 @@ def validate(role: str, path: str, context: dict) -> list[str]:
         return [f"{'.'.join(map(str, e.path)) or 'report'}: {e.message}" for e in found]
     # The schema types only the role's own fields: any other field of the report is dropped.
     report = {name: value for name, value in report.items() if name in rules["properties"]}
+    if "locked" in report:
+        report["locked"] = locked_files(report["locked"])
     return (_commit_errors(report, context) + _owner_errors(report, context) + _correction_errors(report, context)
             + _merged_errors(report, context) + _proof_errors(report, context) + _locked_errors(report, context))

package/skills/implement-spec/driver_review.py

@@ -76,10 +76,13 @@ def written(slot: str, entry: dict, listed: list[str], tip: str) -> dict:
     return {"test_writer_sha": tip, "locked": list(dict.fromkeys(entry["locked"] + listed)), "held": held}
 
 
-def route(findings: list[dict]) -> tuple[list[dict], list[dict]]:
-    """(the fixture findings, whatever their severity; the other findings that are severe enough for a fix round)."""
-    fixture = [finding for finding in findings if finding["kind"] == "fixture"]
-    return fixture, [finding for finding in findings if finding["kind"] != "fixture" and finding["severity"] in OPEN]
+def route(findings: list[dict], locked: list[str]) -> tuple[list[dict], list[dict]]:
+    """(the findings for a test-writer correction; the other findings that are severe enough for a fix round).
+    A correction gets each fixture finding, whatever its severity, and each severe test finding on a `locked` file:
+    the fixer may not edit a locked file, so a fix round cannot close it."""
+    correct = [finding for finding in findings if finding["kind"] == "fixture"
+               or (finding["kind"] == "test" and finding["file"] in locked and finding["severity"] in OPEN)]
+    return correct, [finding for finding in findings if finding not in correct and finding["severity"] in OPEN]
 
 
 def _hunks(slot: str, old: str, new: str, file: str) -> list[tuple[int, int, int, int]]:

package/skills/implement-spec/driver_run.py

@@ -100,6 +100,8 @@ class Run:
             merged = driver_merge.protected(self.state.read()["tickets"], number)
             options["check"] = {**(options.get("check") or {}), "merged": merged, "pr": self.tip()}
         report = _attempts(self, role, number, slot, values, **options)
+        if role == "test-writer":
+            report["locked"] = driver_report.locked_files(report["locked"])  # as validate read it
         if subject := driver_decisions.contradicted(role, report):
             # The implementer's commits stay: after the ruling the ticket goes on from them.
             evidence = OUT / number / f"{role}-{options.get('fix_round', 0)}.json"

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

@@ -1,4 +1,6 @@
 
-This call is a fixture correction, not a new test. The review found that a locked test encodes a stale path, format, fixture layout or setup detail: read each finding of kind `fixture` in {findings}.
-Correct only that detail in the locked test file and keep what each test asserts. For this you may read the implementation.
-The implementation exists, so a corrected test is green: for `red`, break the production line that the test protects, run the test, print its failing output, then revert the edit. In `locked`, list each test file you corrected.
+This call is a correction of the locked tests, not a new test set. Read in {findings} each finding of kind `fixture` and each critical or important finding of kind `test` on a locked file.
+A `fixture` finding: a locked test encodes a stale path, format, fixture layout or setup detail. Correct only that detail and keep what each test asserts.
+A `test` finding: a locked test is too weak, for example it stays green when the production line it protects is broken. Make the test assert the behavior of its criterion so that it fails on that break. Do not remove an assertion.
+For this you may read the implementation.
+The implementation exists, so a corrected test is green: for `red`, break the production line that the test protects, run the test, print its failing output, then revert the edit. In `locked`, list each test file you corrected: test file paths only, not test node ids. Unlike `mutations[].test` of the reviewer, `locked` takes no `::<test name>`.

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

@@ -12,7 +12,7 @@ The output section of the checks file does not apply here: your findings go into
 Read file content from git at {start_sha} (`git diff`, `git show {start_sha}:<path>`), never from the working tree, and run no tests: another agent makes temporary edits in this worktree while you work.
 The one exception is the input of the driver, which git can lack because `.agent/` is ignored: read the spec, the ticket and the findings file from the working tree. The other agent does not edit them.
 Report only a defect that you can show with a concrete sequence of events. `mutations` is optional for this pass.
-Give each finding a severity (critical, important or minor), the file and line, a title, the evidence, and a kind: `code`, `test`, or `fixture` when a locked test encodes a stale path, format or setup detail.
+Give each finding a severity (critical, important or minor), the file and line, a title, the evidence, and a kind: `fixture` when a locked test encodes a stale path, format or setup detail; `test` when a test is weak or missing, as a locked test that stays green when you break the line it protects; `code` for anything else. The test-writer corrects each `fixture` finding and each critical or important `test` finding on a locked file, and the fixer gets the rest.
 Do not commit and do not dispatch subagents. Leave the tree as you found it.
 
 Write one JSON report at {report}. When your sandbox is read-only, give the JSON as your whole final message and the driver saves it there. The report matches this schema:

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

@@ -7,8 +7,9 @@ Branch: {branch}, at commit {start_sha}
 Locked files: {locked}
 Findings of the review: {findings}
 
-Fix each finding of severity critical or important in the findings file. Leave the minor findings: the final review gets them. Leave each finding of kind `fixture`: the test-writer corrects those.
+Fix each finding of severity critical or important in the findings file. Leave the minor findings: the final review gets them. Leave each finding of kind `fixture` and each finding of kind `test` on a locked file: the test-writer corrects those.
 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. The driver runs the gate on your final 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.

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

@@ -7,7 +7,7 @@ Start commit, which holds the locked tests when the ticket has them: {start_sha}
 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 the evidence in `concerns`.
+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. The driver runs the gate on your final commit.
 In `green`, give the summary lines of the passing test output.

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

@@ -1,5 +1,5 @@
 
-This call is a correction after a ruling, not a new test set. The implementer reported that a locked test contradicts the spec or the ticket, and the operator ruled that the test is wrong: read `concerns` in {blocked_report}.
+This call is a correction after a ruling, not a new test set. The implementer or the fixer reported that a locked test contradicts the spec or the ticket, and the operator ruled that the test is wrong: read `concerns` in {blocked_report}.
 Correct only the tests that those concerns name, so that they state what the spec and the ticket require. Keep each other test as it is.
 The branch can hold commits of the implementer, and the tree can hold its uncommitted work: change neither, and commit only the test files you correct.
 A corrected test fails because the behavior is missing: run it and print that failing output. In `locked`, list each test file you corrected.

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

@@ -11,7 +11,7 @@ Check the diff against the ticket and the spec, then for quality. Check that eac
 In round 1, for each locked test, break the production line the test protects, run the test, print its failing output, then revert the edit. A test that stays green is a critical finding. Run again each mutation that the test-writer report names in `concerns`.
 A mutation proof is keyed to its test and its production line: a later round repeats it only when that line changed.
 In `mutations`, give for each proof the test as `<locked file>::<test name>`, the production file and line, and one failure line copied exactly from the output you printed.
-Give each finding a severity (critical, important or minor), the file and line, a title, the evidence, and a kind: `code`, `test`, or `fixture` when a locked test encodes a stale path, format or setup detail.
+Give each finding a severity (critical, important or minor), the file and line, a title, the evidence, and a kind: `fixture` when a locked test encodes a stale path, format or setup detail; `test` when a test is weak or missing, as a locked test that stays green when you break the line it protects; `code` for anything else. The test-writer corrects each `fixture` finding and each critical or important `test` finding on a locked file, and the fixer gets the rest.
 Do not commit and do not dispatch subagents. Leave the tree as you found it.
 
 Write one JSON report at {report}. When your sandbox is read-only, give the JSON as your whole final message and the driver saves it there. The report matches this schema:

package/skills/implement-spec/prompts/test-writer.md

@@ -10,7 +10,7 @@ Write one black-box acceptance test for each criterion of the ticket, through th
 Run each test and confirm that it fails because the behavior is missing, not because of an import error or a syntax error. Print that failing output.
 A test that is green before any implementation is not a proof. Rewrite it until it fails, or name in `concerns` the production-code mutation that turns it red.
 Commit the tests red on the checked-out branch. Do not write implementation code and do not dispatch subagents.
-In `locked`, list each test file of your commit. In `red`, give for each test one failure line, copied exactly from the output you printed.
+In `locked`, list each test file of your commit: test file paths only, not test node ids (`tests/x.py`, not `tests/x.py::test_a`). In `red`, give for each test one failure line, copied exactly from the output you printed.
 
 Write one JSON report at {report} that matches this schema:
 

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

@@ -353,10 +353,11 @@ def test_a_template_of_another_shape_is_an_error_and_every_text_of_a_question_is
 
 # ---------------------------------------------------------------- questions
 
-def test_only_an_implementer_blocked_on_the_contradiction_concern_is_a_stop():
+def test_only_an_implementer_or_a_fixer_blocked_on_the_contradiction_concern_is_a_stop():
     report = {"status": "BLOCKED", "concerns": [CONTRA, "other", "locked test contradicts spec: b::c", driver_decisions.CONTRADICTS]}
     assert driver_decisions.contradicted("implementer", report) == "tests/test_01.py::test_x; b::c"
-    assert driver_decisions.contradicted("fixer", report) == ""
+    assert driver_decisions.contradicted("fixer", report) == "tests/test_01.py::test_x; b::c"
+    assert driver_decisions.contradicted("reviewer", report) == ""
     assert driver_decisions.contradicted("implementer", {**report, "status": "DONE"}) == ""
     assert driver_decisions.contradicted("implementer", {}) == "", "a rejected report is no report"
     assert driver_decisions.contradicted("implementer", {"status": "BLOCKED", "concerns": [driver_decisions.CONTRADICTS]}) == ""

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

@@ -127,7 +127,7 @@ def test_a_changed_locked_file_is_fixed_before_a_fixture_finding_is_corrected(tm
     assert (entry["round"], entry["test_writer_sha"]) == (1, rig.calls("01", "test-writer")[1]["sha"])
     assert entry["locked"] == ["tests/test_01.py"] and (rig.folder() / "test-writer-2.json").exists()
     assert rig.led("fixture correction in tests/test_01.py, outside the fix rounds: STALE: STALE.")
-    assert "This call is a fixture correction" in rig.prompt("test-writer-2") and "findings-1.json" in rig.prompt("test-writer-2")
+    assert "This call is a correction of the locked tests" in rig.prompt("test-writer-2") and "findings-1.json" in rig.prompt("test-writer-2")
 
 
 def test_a_locked_file_check_that_git_cannot_make_is_a_finding(tmp_path):
@@ -141,7 +141,7 @@ def test_a_fixture_finding_that_comes_back_after_its_correction_blocks_the_ticke
     stale = finding("STALE", kind="fixture", file="tests/test_01.py")
     correction = {**tw("01"), "files": {"tests/test_01.py": "# corrected\n"}, "commit": "test: 01 fixture fix"}
     rig = Inside(tmp_path).run(plan(**{"01/test-writer": [tw("01"), correction], "01/reviewer": [review("01", [stale])] * 2}))
-    assert blocked(rig).endswith("BLOCKED at the review: a fixture finding is open after the test-writer correction: STALE.")
+    assert blocked(rig).endswith("BLOCKED at the review: a locked-test finding is open after the test-writer correction: STALE.")
     assert len(rig.calls("01", "test-writer")) == 2 and rig.state()["tickets"]["01"]["round"] == 0
 
 
@@ -160,10 +160,78 @@ def test_an_open_finding_survives_the_fixture_correction_of_its_review_and_start
     assert [gate["commit"] for gate in rig.walk_gates()] == [rig.sha("01", "implementer"), rig.sha("01", "fixer")]
 
 
+def test_a_test_finding_on_a_locked_file_gets_the_test_writer_correction_not_a_fix_round(tmp_path):
+    # A failed mutation proof: the fixer may not edit the locked file, so a fix round could never close it.
+    vacuous = finding("VACUOUS", "critical", kind="test", file="tests/test_01.py")
+    correction = {**tw("01"), "files": {"tests/test_01.py": "# stronger\n"}, "commit": "test: 01 stronger test"}
+    rig = Inside(tmp_path).run(plan(**{"01/test-writer": [tw("01"), correction],
+                                       "01/reviewer": [review("01", [vacuous]), review("01")]}))
+    assert rig.code == 0, rig.ledger()
+    order = [call["role"] for call in rig.calls("01")]
+    assert order == ["test-writer", "implementer", "reviewer", "test-writer", "reviewer"]
+    entry = rig.state()["tickets"]["01"]
+    assert (entry["round"], entry["test_writer_sha"]) == (0, rig.calls("01", "test-writer")[1]["sha"])
+    assert rig.led("correction in tests/test_01.py, outside the fix rounds: VACUOUS: VACUOUS.")
+    # Only a severe finding of kind `test` on a locked file goes to the test-writer.
+    minor, elsewhere = finding("M", "minor", kind="test", file="tests/test_01.py"), finding("E", kind="test")
+    assert driver_review.route([vacuous, minor, elsewhere], ["tests/test_01.py"]) == ([vacuous], [elsewhere])
+
+
+def test_a_test_writer_that_lists_test_node_ids_in_locked_locks_their_files(tmp_path):
+    # Issue #71: a node id `<file>::<test>` in `locked` names its file, for the first run and for a correction.
+    vacuous = finding("VACUOUS", "critical", kind="test", file="tests/test_01.py")
+    ids = ["tests/test_01.py::test_x", "tests/test_01.py::test_y"]
+    first = {**tw("01"), "report": {**tw("01")["report"], "locked": ids}}
+    correction = {**first, "files": {"tests/test_01.py": "# stronger\n"}, "commit": "test: 01 stronger test"}
+    rig = Inside(tmp_path).run(plan(**{"01/test-writer": [first, correction],
+                                       "01/reviewer": [review("01", [vacuous]), review("01")]}))
+    assert rig.code == 0, rig.ledger()
+    assert [call["role"] for call in rig.calls("01")].count("test-writer") == 2  # no rerun
+    assert rig.state()["tickets"]["01"]["locked"] == ["tests/test_01.py"]
+
+
+CONTRA = "locked test contradicts spec: tests/test_01.py::test_x"
+OVERRULED = {**tw("01"), "files": {"tests/test_01.py": "def test_x():\n    assert '01' == '01'\n"},
+             "commit": "test: 01 overruled"}
+AGAIN = impl("01", text="def fn_01():\n    return 'again'\n")
+
+
+def fixer_stops():
+    return {"report": {"status": "BLOCKED", "commits": [], "files": [], "concerns": [CONTRA], "green": [], "ticket": "01"}}
+
+
+def test_a_fixer_that_reports_a_wrong_locked_test_opens_the_locked_test_question(tmp_path):
+    steps = plan(**{"01/reviewer": [review("01", [STUCK]), review("01")], "01/fixer": [fixer_stops()],
+                    "01/test-writer": [tw("01"), OVERRULED], "01/implementer": [impl("01"), AGAIN]})
+    rig = Inside(tmp_path).run(steps)
+    assert rig.code == 2, rig.ledger()
+    (asked,) = rig.state()["run"]["questions"]
+    assert (asked["id"], asked["evidence"][0]) == ("01-locked-test-1", ".agent/implement/01/fixer-1.json")
+    rig.run(steps, "--answer", "01-locked-test-1=overrule-test")
+    assert rig.code == 0, rig.ledger()
+    order = [call["role"] for call in rig.calls("01")]
+    assert order == ["test-writer", "implementer", "reviewer", "fixer", "test-writer", "implementer", "reviewer"]
+    # The correction reads the concerns of the fixer that stopped, not those of the implementer.
+    assert "01/fixer-1.json" in rig.prompt("test-writer-0") and "implementer-0.json" not in rig.prompt("test-writer-0")
+
+
+def test_the_fix_rounds_count_from_0_after_an_overruled_test(tmp_path):
+    stuck = review("01", [STUCK])
+    steps = plan(**{"01/reviewer": [stuck] * 5 + [review("01")],
+                    "01/fixer": [fix("01", 1), fix("01", 2), fix("01", 3), fixer_stops(), fix("01", 5)],
+                    "01/test-writer": [tw("01"), OVERRULED], "01/implementer": [impl("01"), AGAIN]})
+    rig = Inside(tmp_path).run(steps)
+    assert rig.code == 2 and rig.state()["tickets"]["01"]["round"] == 4, rig.ledger()
+    rig.run(steps, "--answer", "01-locked-test-1=overrule-test")
+    # The corrected tests are a new contract: the first finding on them gets a fix round, not the round-4 stop.
+    assert rig.code == 0, rig.ledger()
+    assert rig.state()["tickets"]["01"]["round"] == 1 and not rig.led("after round 4")
+
+
 def test_a_fixture_correction_that_is_rejected_blocks_the_ticket(tmp_path):
     stale = finding("STALE", kind="fixture", file="tests/test_01.py")
     rig = Inside(tmp_path).run(plan(**{"01/test-writer": [tw("01"), {}, {}], "01/reviewer": [review("01", [stale])]}))
-    assert "BLOCKED at the fixture correction: report .agent/implement/01/test-writer-1.json is not" in blocked(rig)
+    assert "BLOCKED at the test-writer correction: report .agent/implement/01/test-writer-1.json is not" in blocked(rig)
 
 
 # ---------------------------------------------------------------- the locked files of the merged tickets

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-15T17:11:47.113Z",
+  "generatedAt": "2026-10-15T21:59:51.763Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.12",
-      "hash": "sha256-d50cbfcb02b148c9f122d16333274b2d758efc8a1b35e0cf54eb831f34eba6de",
+      "version": "0.1.14",
+      "hash": "sha256-79c7cae6498225802c8d12a8e5c58c74ec0f2ef3b8889bc1e529b3115407e3e9",
       "description": "Implement a specification in code."
     },
     {