@jesdi/skills 0.0.51 → 0.0.52

package/package.json

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

package/skills/implement-spec/ARCHITECTURE.md

@@ -132,6 +132,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.
+- A finding that a correction reports in `not_addressed` goes to the fixer of the same round as kind `code`
+  (`driver_fixloop._correct` rewrites it in the findings file): the test needs a production change first, so a
+  second correction could not close it.
 - 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.

package/skills/implement-spec/README.md

@@ -117,7 +117,7 @@ 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. No correction runs after round 4. |
+| 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 that the correction reports in `not_addressed` (it needs a production change first) becomes a finding of kind `code`, with the reason as its evidence, and goes to a fix round at once; the ledger says it was not corrected. 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. |
 
@@ -176,7 +176,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. When the gate is red on the restore commit, a DONE correction lists a restored file 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. When the gate is red on the restore commit, a DONE correction lists a restored file in `locked`. Each `not_addressed[].finding` is the title of a finding of the correction; a DONE correction with each of its findings there needs no commit. |
 | 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 a full review (one with no fix range: round 1, and the review after a test-writer correction): `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

@@ -104,8 +104,9 @@ def _review(job: Job) -> list[dict]:
     return found
 
 
-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."""
+def _correct(job: Job, findings: list[dict]) -> list[dict]:
+    """One test-writer correction for the findings on the locked tests. It is outside the fix rounds. Returns the
+    findings that it did not correct, as findings of kind code for the fixer (issue #111)."""
     run, number = job.run, job.ticket.number
     if job.corrected:
         titles = "; ".join(finding["title"] for finding in findings)
@@ -120,19 +121,39 @@ def _correct(job: Job, findings: list[dict]) -> None:
         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
+        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, values, notes=notes, fix_round=job.round + 1,
-                           check={"correction": True, "restored": restored, "restore_red": bool(record)})
+                           check={"correction": True, "restored": restored, "restore_red": bool(record),
+                                  "findings": [finding["title"] for finding in findings]})
     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))
+    return _uncorrected(job, findings, report.get("not_addressed", []))
+
+
+def _uncorrected(job: Job, findings: list[dict], not_addressed: list[dict]) -> list[dict]:
+    """Log what the correction did with each finding. Returns each one it did not correct as a finding of kind
+    code, with its reason as the evidence: the test needs a production change first, so a fixer closes it."""
+    number = job.ticket.number
+    reasons = {item["finding"]: item["reason"] for item in not_addressed}
     for finding in findings:
+        result = (f"The test-writer did not correct it: {reasons[finding['title']]}. It goes to the fixer as a finding "
+                  "of kind code." if finding["title"] in reasons else f"The test-writer corrected it at {job.tip[:7]}.")
         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]}.")
+               f"{finding['title']}: {finding['evidence']}. {result}")
+    code = {finding["title"]: {**finding, "kind": "code", "evidence": f"the test-writer did not correct it: {reason}"}
+            for finding in findings if (reason := reasons.get(finding["title"]))}
+    if code:
+        # The fixer reads the findings file of this review, so the finding is of kind code there too.
+        path = OUT / number / f"findings-{job.round}.json"
+        written = [code.get(finding["title"], finding) if finding in findings else finding
+                   for finding in json.loads(path.read_text())]
+        path.write_text(json.dumps(written, indent=1) + "\n")
+    return list(code.values())
 
 
 def _fix(job: Job) -> None:
@@ -170,7 +191,7 @@ def _act_on(job: Job, found: list[dict]) -> bool:
     # 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 to_fix)
     if to_correct and not locked_file_changed:
-        _correct(job, to_correct)
+        to_fix += [finding for finding in _correct(job, to_correct) if finding["severity"] in driver_review.OPEN]
         if not to_fix:
             return False
     if not to_fix:

package/skills/implement-spec/driver_report.py

@@ -2,7 +2,7 @@
 
 context: repo (slot path), branch, start (HEAD when the role started), log, full (a full review: no fix range), 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),
+  restore_red (the gate is red on the commit of that restore), findings (the titles a correction gets),
   owners (ticket numbers, for the final fix batch), merged (locked files of merged tickets, not its own), pr (tip)."""
 from __future__ import annotations
 
@@ -81,7 +81,8 @@ def _correction_errors(report: dict, context: dict) -> list[str]:
         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
+    return errors + [f"not_addressed: {item['finding']} is not the title of a finding of this correction"
+                     for item in report.get("not_addressed", []) if item["finding"] not in context.get("findings", [])]
 
 
 def _merged_errors(report: dict, context: dict) -> list[str]:

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

@@ -3,4 +3,5 @@ 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.
+When a finding needs a production change first, so that no correct test can be green, leave the test as it is and add the finding to `not_addressed`: `finding` is its `title` as the findings file gives it, `reason` is the production change it needs. The driver sends it to the fixer as a finding of kind `code`. A correction whose findings are all in `not_addressed` may report DONE with no commit.
 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

@@ -25,9 +25,10 @@ Write one JSON report at {report} that matches this schema:
     "files": {"type": "array", "items": {"type": "string"}},
     "concerns": {"type": "array", "items": {"type": "string"}},
     "locked": {"type": "array", "items": {"type": "string"}},
-    "red": {"type": "array", "items": {"type": "object", "required": ["test", "line"], "properties": {"test": {"type": "string", "minLength": 1}, "line": {"type": "string", "minLength": 1}}}}
+    "red": {"type": "array", "items": {"type": "object", "required": ["test", "line"], "properties": {"test": {"type": "string", "minLength": 1}, "line": {"type": "string", "minLength": 1}}}},
+    "not_addressed": {"type": "array", "items": {"type": "object", "required": ["finding", "reason"], "properties": {"finding": {"type": "string", "minLength": 1}, "reason": {"type": "string", "minLength": 1}}}}
   },
-  "if": {"properties": {"status": {"enum": ["DONE", "DONE_WITH_CONCERNS"]}}},
+  "if": {"properties": {"status": {"enum": ["DONE", "DONE_WITH_CONCERNS"]}}, "not": {"required": ["not_addressed"], "properties": {"not_addressed": {"minItems": 1}}}},
   "then": {"properties": {"commits": {"minItems": 1}, "locked": {"minItems": 1}, "red": {"minItems": 1}}}
 }
 ```

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

@@ -177,6 +177,56 @@ 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])
 
 
+NEEDS_CODE = "needs production code: the code has no multi-PR view"
+
+
+def not_addressing(*titles, **report):
+    """A correction of tests/test_01.py that reports `titles` under `not_addressed`."""
+    step = {**tw("01"), "files": {"tests/test_01.py": "# corrected\n"}, "commit": "test: 01 fixture fix"}
+    reasons = [{"finding": title, "reason": NEEDS_CODE} for title in titles]
+    return {**step, "report": {**step["report"], **report, "not_addressed": reasons}}
+
+
+def test_a_test_finding_the_correction_did_not_address_goes_to_the_fixer_as_a_code_finding(tmp_path):
+    # Issue #111: the ledger said "corrected it at <sha>" for every finding, and the finding came back each review.
+    stale = finding("STALE", kind="fixture", file="tests/test_01.py")
+    vacuous = finding("VACUOUS", "critical", kind="test", file="tests/test_01.py")
+    rig = Inside(tmp_path).run(plan(**{"01/test-writer": [tw("01"), not_addressing("VACUOUS")],
+                                       "01/fixer": [fix("01", 1)],
+                                       "01/reviewer": [review("01", [stale, 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", "fixer", "reviewer"]
+    assert rig.led("STALE: STALE. The test-writer corrected it at")
+    assert rig.led("VACUOUS", "corrected it at") == []
+    assert rig.led(f"test correction in tests/test_01.py, outside the fix rounds: VACUOUS: VACUOUS. The test-writer "
+                   f"did not correct it: {NEEDS_CODE}. It goes to the fixer as a finding of kind code.")
+    # The fixer reads the finding as one of kind code, with the reason of the test-writer as its evidence.
+    (routed,) = [f for f in json.loads((rig.folder() / "findings-0.json").read_text()) if f["title"] == "VACUOUS"]
+    assert (routed["kind"], routed["evidence"]) == ("code", f"the test-writer did not correct it: {NEEDS_CODE}")
+    assert rig.state()["tickets"]["01"]["round"] == 1 and "findings-0.json" in rig.prompt("fixer-1")
+
+
+def test_a_correction_that_addresses_no_finding_needs_no_commit(tmp_path):
+    vacuous = finding("VACUOUS", "critical", kind="test", file="tests/test_01.py")
+    none = not_addressing("VACUOUS", commits=[], files=[], locked=[], red=[])
+    del none["commit"], none["files"]
+    rig = Inside(tmp_path).run(plan(**{"01/test-writer": [tw("01"), none], "01/fixer": [fix("01", 1)],
+                                       "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.led("VACUOUS. The test-writer did not correct it") and rig.state()["tickets"]["01"]["round"] == 1
+
+
+def test_a_correction_that_names_a_finding_it_was_not_given_is_rerun(tmp_path):
+    vacuous = finding("VACUOUS", "critical", kind="test", file="tests/test_01.py")
+    rig = Inside(tmp_path).run(plan(**{"01/test-writer": [tw("01"), not_addressing("OTHER"), not_addressing()],
+                                       "01/reviewer": [review("01", [vacuous]), review("01")]}))
+    assert rig.code == 0, rig.ledger()
+    assert "not_addressed: OTHER is not the title of a finding of this correction" in rig.prompt("test-writer-1")
+    assert rig.led("VACUOUS: VACUOUS. The test-writer corrected it at")
+
+
 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")

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-19T10:48:11.958Z",
+  "generatedAt": "2026-10-19T11:13:23.574Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.26",
-      "hash": "sha256-40637f9172d94edb3ef009f91f58e27f7cd400ed15935c5a62654822a57208c5",
+      "version": "0.1.27",
+      "hash": "sha256-5cd78074157850b0abb3de812a51a911486bd5da29fe5f553a4838b25e61d30b",
       "description": "Implement a specification in code."
     },
     {