@jesdi/skills 0.0.38 → 0.0.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jesdi/skills",
-  "version": "0.0.38",
+  "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` (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`. |
+| 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/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-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-15T21:59:51.763Z",
+  "generatedAt": "2026-10-15T23:43:23.097Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.14",
-      "hash": "sha256-79c7cae6498225802c8d12a8e5c58c74ec0f2ef3b8889bc1e529b3115407e3e9",
+      "version": "0.1.15",
+      "hash": "sha256-22559be058dfe337417851a3116ec6a05d9272e7c65510e3f3d02467d1c5c8ca",
       "description": "Implement a specification in code."
     },
     {