@jesdi/skills 0.0.37 → 0.0.39

package/package.json

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

package/skills/implement-spec/ARCHITECTURE.md

@@ -60,7 +60,10 @@ 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.
+  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.
 - A conflict resolution, of a merge or of the rebase, may not change a locked file.

package/skills/implement-spec/README.md

@@ -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`. 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. |
 | 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. |

package/skills/implement-spec/driver_fixloop.py

@@ -105,10 +105,10 @@ 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}")
-    run.restore_locked_files(number, job.slot)
+    check = {"correction": True, "restored": run.restore_locked_files(number, job.slot)}
     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)
+                           fix_round=job.round + 1, check=check)
     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))

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_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

@@ -3,4 +3,4 @@ This call is a correction of the locked tests, not a new test set. Read in {find
 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.
+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/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

@@ -244,6 +244,45 @@ def test_a_correction_of_its_own_file_leaves_the_work_in_the_tree_to_the_impleme
     assert git(rig.repo, "show", f"feat/csv:{OTHER}") == OTHER_TEST
 
 
+def proved(findings=()):
+    """A reviewer step with a mutation proof for each of the two locked files."""
+    step = review("01", findings)
+    red = "FAILED tests/test_01b.py::test_y - AssertionError at demo/export.py:1"
+    step["report"]["mutations"].append(dict(test=f"{OTHER}::test_y", file="demo/export.py", line=1, red=red))
+    return {**step, "stdout": step["stdout"] + red + "\n"}
+
+
+STRONGER = "def test_x():\n    assert '01' == '01'  # stronger\n"
+
+
+@pytest.mark.parametrize("cheat", [False, True])
+def test_a_second_correction_of_a_locked_file_is_its_new_reference(tmp_path, capsys, cheat):
+    # Issue #75: the review correction (#70) changes tests/test_01.py and first lists only the other file. Before
+    # the fix it was accepted, `held` kept the overrule commit as the reference, and each review after a fix that
+    # did not touch the file found "locked file changed". A correction now lists each file it changes.
+    vacuous = finding("VACUOUS", "critical", kind="test", file="tests/test_01.py")
+    files = {"tests/test_01.py": STRONGER.replace("stronger", "draft"), OTHER: OTHER_TEST + "# stronger\n"}
+    unlisted = {**correction(), "files": files, "commit": "test: 01 stronger"}
+    unlisted["report"] = {**unlisted["report"], "locked": [OTHER], "files": [OTHER]}
+    # The rerun lists both files: the commit of the rejected attempt is in its commits too.
+    listed = {**unlisted, "files": {"tests/test_01.py": STRONGER}}
+    listed["report"] = {**unlisted["report"], "locked": ["tests/test_01.py", OTHER]}
+    gutted = fix("01", 1, files={"demo/export.py": "x = 1\n", "tests/test_01.py": "# gutted\n"})
+    fixes = [gutted, fix("01", 2, files={"demo/export.py": "x = 2\n", "tests/test_01.py": STRONGER})] if cheat else [
+        fix("01", 1)]
+    scenario = plan(**{"01/test-writer": [two_locked(), correction(), unlisted, listed],
+                       "01/implementer": [blocked(), impl("01")], "01/fixer": fixes,
+                       "01/reviewer": [proved([vacuous]), proved([finding("STUCK")])] + [proved()] * 3})
+    rig = Inside(tmp_path, ONE).run(scenario)
+    rig.run(scenario, "--answer", f"{Q1}=overrule-test")
+    assert rig.code == 0, rig.ledger()
+    assert rig.led("BLOCKED", "correction") == [] and rig.led("its commits also change tests/test_01.py")
+    entry = rig.state()["tickets"]["01"]
+    assert entry["held"] == {} and entry["test_writer_sha"] == rig.calls("01", "test-writer")[3]["sha"]
+    assert len(rig.led("locked file changed: tests/test_01.py")) == cheat, "only a fixer's change is a finding"
+    assert git(rig.repo, "show", "feat/csv:tests/test_01.py") == STRONGER
+
+
 def test_a_locked_file_keeps_its_old_reference_until_a_test_writer_lists_it(repo, tmp_path):
     def commit(name, text):
         (tmp_path / name).write_text(text)

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

@@ -177,6 +177,19 @@ def test_a_test_finding_on_a_locked_file_gets_the_test_writer_correction_not_a_f
     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"}

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-15T20:18:35.299Z",
+  "generatedAt": "2026-10-15T23:43:23.097Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.13",
-      "hash": "sha256-43cd1d984937142c01661ba2ba43f8f68f163de0d880b1961383677a6e3d609e",
+      "version": "0.1.15",
+      "hash": "sha256-22559be058dfe337417851a3116ec6a05d9272e7c65510e3f3d02467d1c5c8ca",
       "description": "Implement a specification in code."
     },
     {