@jesdi/skills 0.0.34 → 0.0.35

package/package.json

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

package/skills/implement-spec/ARCHITECTURE.md

@@ -107,6 +107,8 @@ and do not know about the run, except `driver_run.py`, which the three deciding
   A timeout doubles the time of the rerun.
 - Fix rounds stop at 4, and round 3 goes to the next implementer entry. The correctness pass never runs on the
   provider of the implementer.
+- A red gate on a fixer's commit is a finding of the next round (`driver_fixloop._gate`), so it blocks only after
+  round 4.
 
 ### Questions
 

package/skills/implement-spec/README.md

@@ -82,7 +82,7 @@ Everything is under `.agent/`, which is never committed.
 | `.agent/implement/<NN>/` | One folder for each ticket. |
 | `.agent/implement/<NN>/<role>-<K>.json`, `.log`, `.prompt.md` | The report, the log and the prompt of one agent. K is the fix round. |
 | `.agent/implement/<NN>/gate-<sha7>.log` | One gate record: start, commit, status, command, output, exit, the state after the command, end. |
-| `.agent/implement/<NN>/findings-<K>.json` | The merged findings of the review after fix round K. |
+| `.agent/implement/<NN>/findings-<K>.json` | The merged findings of the review after fix round K, or the red gate of round K. |
 | `.agent/implement/final/` | The same files for the end of run, and `pr-body.md`: the pr-writer's body, then the facts of the run. |
 | `.agent/implement/pycache/` | Compiled Python of the gate, kept out of the slots. |
 | `.agent/implement-review.html` | The page with the open questions. |
@@ -119,6 +119,8 @@ Rules for each agent:
 
 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.
+
 - 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.

package/skills/implement-spec/driver_fixloop.py

@@ -30,8 +30,9 @@ class Job:
     tip: str
     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: list[str] = field(default_factory=list)  # `file:line` of each proof the last fix made due again
+    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
+    red: bool = False  # the gate of `tip` is red, so no review saw it
 
     def pointers(self, review: int) -> dict[str, str]:
         """The values of a prompt; `review` is the round whose findings the agent reads."""
@@ -39,7 +40,7 @@ class Job:
         findings = os.path.relpath(OUT / self.ticket.number / f"findings-{review}.json", self.slot)
         return {**self.values, "start_sha": self.tip, "from_sha": self.previous, "round": str(self.round),
                 "locked": " ".join(entry["locked"]), "test_writer_sha": str(entry["test_writer_sha"] or ""),
-                "findings": findings, "proofs": " ".join(self.again)}
+                "findings": findings, "proofs": " ".join(f"{file}:{line}" for file, line in sorted(self.again))}
 
 
 def entry(models: dict[str, list[str]], round: int) -> str:
@@ -129,12 +130,16 @@ def _fix(job: Job) -> None:
     with during(f"fix round {job.round}"):
         run.agent("fixer", number, job.slot, job.pointers(job.round - 1), entry=on, fix_round=job.round)
     before, job.tip = job.tip, driver_slots.head(job.slot)
-    # No review has seen a fixture correction, so the review after a fix on a corrected tip is a full one.
-    job.previous, job.corrected = "" if job.corrected else before, False
     run.state.ticket(number, tip=job.tip)
     followed = driver_review.follow(job.slot, before, job.tip, job.proofs)
-    job.proofs = set(followed)
-    job.again = [f"{file}:{line}" for (file, line), changed in sorted(followed.items()) if changed]
+    due = {proof for proof, changed in followed.items() if changed}
+    if job.red:
+        # 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.
+        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:
@@ -157,14 +162,33 @@ def _act_on(job: Job, found: list[dict]) -> bool:
     return False
 
 
+def _gate(job: Job) -> list[dict]:
+    """Gate the tip. A red gate on a fixer's commit before round 4 is a finding for the next round; any other red
+    gate blocks. Returns the findings: the red gate, or none."""
+    run, number = job.run, job.ticket.number
+    job.red = False
+    with during("the gate"):
+        if not 0 < job.round < ROUNDS or job.corrected:
+            run.gate(number, job.slot, job.tip)
+            return []
+        record = run.red_gate(number, job.slot, job.tip)
+    if not record:
+        return []
+    job.red, path = True, os.path.relpath(record, job.slot)
+    found = [{"severity": "critical", "file": path, "line": 0, "title": f"the gate is red on {job.tip[:7]}",
+              "evidence": f"the output of the gate in {path}", "kind": "code", "source": "gate"}]
+    (OUT / number / f"findings-{job.round}.json").write_text(json.dumps(found, indent=1) + "\n")
+    return _log_findings(job, found)
+
+
 def run(ticket: Ticket, slot: str, run: Run, values: dict[str, str]) -> None:
     """Gate, review and fix the ticket tip until a review leaves no finding open."""
     state = run.state.read()["tickets"][ticket.number]
     job = Job(ticket, slot, run, values, state["round"], state["tip"])
     while True:
-        with during("the gate"):
-            run.gate(ticket.number, slot, job.tip)
-        with during("the review"):
-            found = _review(job)
+        found = _gate(job)
+        if not found:
+            with during("the review"):
+                found = _review(job)
         if _act_on(job, found):
             return

package/skills/implement-spec/driver_run.py

@@ -129,8 +129,13 @@ class Run:
 
     def gate(self, number: str, slot: str, commit: str) -> None:
         """Gate `commit` in the slot, unless a green record names it already."""
+        if record := self.red_gate(number, slot, commit):
+            raise Blocked(f"the gate is red on {commit[:7]}, record {record}")
+
+    def red_gate(self, number: str, slot: str, commit: str) -> str:
+        """`gate`, for a caller that acts on a red gate: returns its record, or "" when the gate is green."""
         if commit in _gate_record(self.state.read(), number)["green_gates"]:
-            return
+            return ""
         at = driver_slots.head(slot)
         if at != commit:
             raise Blocked(f"the slot is at {at[:7]}, not at {commit[:7]}: the gate did not run")
@@ -143,8 +148,9 @@ class Run:
 
         self.state.update(count)
         if not green:
-            raise Blocked(f"the gate is red on {commit[:7]}, record {record}")
+            return str(record)
         ledger(f"{_owner(number)}: the gate is green on {commit[:7]}, record {record}.")
+        return ""
 
     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

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

@@ -10,6 +10,7 @@ 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.
 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}.
 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.
 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/tests/test_fixloop.py

@@ -311,6 +311,34 @@ def test_four_rounds_then_blocked_with_the_escalation_at_round_3(tmp_path):
     assert rig.state()["tickets"]["03"]["phase"] == "merged"
 
 
+def test_a_red_gate_on_a_fixer_commit_starts_the_next_round_with_the_record_as_evidence(tmp_path):
+    """Issue 64: the gate of a fix round is red. That is a finding for the next round, not a BLOCKED ticket."""
+    rig = Inside(tmp_path, gate={"subjects": ["fix: 01 round 1"]})
+    rig.run(plan(**{"01/reviewer": [review("01", [STUCK], lines=(2,)), review("01", lines=(2,))],
+                    "01/fixer": [fix("01", 1), fix("01", 2, files={"demo/other.py": "x = 1\n"})]}))
+    assert rig.code == 0, rig.ledger()
+    assert [call["role"] for call in rig.calls("01")] == ["test-writer", "implementer", "reviewer", "fixer", "fixer",
+                                                         "reviewer"]
+    first, second = (call["sha"] for call in rig.calls("01", "fixer"))
+    record = f".agent/implement/01/gate-{first[:7]}.log"
+    (gate,) = json.loads((rig.folder() / "findings-1.json").read_text())
+    assert (gate["source"], gate["severity"], gate["kind"]) == ("gate", "critical", "code")
+    assert gate["title"] == f"the gate is red on {first[:7]}" and record in gate["evidence"]
+    assert rig.led(f"Ticket 01: critical finding of kind code from the gate at {record}:0: the gate is red on {first[:7]}.")
+    assert "findings-1.json" in rig.prompt("fixer-2") and rig.state()["tickets"]["01"]["round"] == 2
+    # No review saw the red tip: the re-review covers both fixes, and the proof that round 1 made due stays due.
+    again = rig.prompt("reviewer-2")
+    assert f"The fix is {rig.sha('01', 'implementer')}..{second}" in again and "demo/export.py:2" in again
+
+
+def test_a_red_gate_on_the_fixer_commit_of_round_4_blocks_the_ticket(tmp_path):
+    rig = Inside(tmp_path, gate={"subjects": ["fix: 01 round 4"]})
+    rig.run(plan(**{"01/reviewer": [review("01", [STUCK])] * 4, "01/fixer": [fix("01", n) for n in (1, 2, 3, 4)]}))
+    last = rig.calls("01", "fixer")[-1]["sha"]
+    assert f"BLOCKED at the gate: the gate is red on {last[:7]}" in blocked(rig)
+    assert len(rig.calls("01", "reviewer")) == 4 and not (rig.folder() / "findings-4.json").exists()
+
+
 def test_round_3_stays_on_its_entry_when_the_implementer_has_no_next_entry(tmp_path):
     rig = Inside(tmp_path, ONE, {"implementer": [OPUS]})
     rig.run(plan(**{"01/reviewer": [review("01", [STUCK])] * 3 + [review("01")], "01/fixer": [fix("01", n) for n in (1, 2, 3)]}))

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

@@ -102,7 +102,8 @@ def git(*a):
 conf = json.loads((rig / "gate.json").read_text())
 (rig / "gates").mkdir(exist_ok=True)
 branch = git("rev-parse", "--abbrev-ref", "HEAD")
-code = 1 if conf.get("all") or branch in conf.get("red", []) else 0
+subject = git("log", "-1", "--format=%s")
+code = 1 if conf.get("all") or branch in conf.get("red", []) or subject in conf.get("subjects", []) else 0
 rec = dict(t0=time.time(), cwd=os.path.realpath(os.getcwd()), commit=git("rev-parse", "HEAD"), branch=branch,
            status=git("status", "--short"), base=os.environ.get("IMPLEMENT_SPEC_BASE"),
            pycache=os.environ.get("PYTHONPYCACHEPREFIX"), exit=code)

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-15T16:47:59.098Z",
+  "generatedAt": "2026-10-15T17:09:44.505Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.10",
-      "hash": "sha256-a0c42688cad43aece79d51d9e09644cc879518858781bf5563e6f8388d009a0c",
+      "version": "0.1.11",
+      "hash": "sha256-c58d05ad78d3d1ae1381c02a96f4e5ca64f6387cea2b16ac5e1997bf52767467",
       "description": "Implement a specification in code."
     },
     {