@jesdi/skills 0.0.34 → 0.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jesdi/skills",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "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.
@@ -172,8 +174,8 @@ Every report has `status` (`DONE`, `DONE_WITH_CONCERNS`, `NEEDS_CONTEXT`, `BLOCK
 |---|---|---|---|
 | 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`. |
 | 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`) | In the first review of a tip: `mutations` is required, with a proof for each locked test file. Each `red` is in the log. |
-| correctness | `prompts/correctness.md` | the same as the reviewer | `mutations` is optional. |
+| 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. |
 | fixer | `prompts/fixer.md` | `green`, `ticket` | With DONE: one commit or more. |
 | final-reviewer | `prompts/final-reviewer.md` | `findings` | None. |
 | pr-writer | `prompts/pr-writer.md` | `body`; `commits` is empty | None. |
@@ -212,6 +214,6 @@ The driver enforces the mutation proof for each locked test file, not for each l
 
 - **A `codex` agent cannot commit.** A role that commits (test-writer, implementer, fixer, conflict) on an `openai` entry runs with `--sandbox workspace-write`, and that sandbox cannot run `git commit`. In the default `models.json` this is the second implementer entry, so fix rounds 3 and 4 fail. What to do: give a `--models` file with no `openai` entry in the `implementer`, `test-writer`, `fixer` and `conflict` lists.
 - **A `codex` reviewer cannot make a mutation proof.** A reviewer on an `openai` entry runs with `--sandbox read-only` and cannot make the temporary edit. The default `models.json` has such an entry first for the reviewer, and the first review needs the proofs. What to do: give a `--models` file whose reviewer list starts with an `anthropic` entry.
-- **The correctness pass reads a tree that the reviewer changes.** The two agents share one slot, and the reviewer makes temporary edits. `prompts/correctness.md` tells the pass to read from git at the reviewed commit and to run no tests. That sentence is the only guard: the driver cannot enforce it, so a pass that ignores it can report a false finding and start a fix round. What to do: when a correctness finding looks wrong, compare it with `git show <reviewed commit>:<file>` before you rule on it.
+- **The correctness pass reads a tree that the reviewer changes.** The two agents share one slot, and the reviewer makes temporary edits. `prompts/correctness.md` tells the pass to read from git at the reviewed commit and to run no tests. It reads only the spec, the ticket and the findings file from the working tree, because git can lack them: `.agent/` is ignored. That rule is the only guard: the driver cannot enforce it, so a pass that ignores it can report a false finding and start a fix round. What to do: when a correctness finding looks wrong, compare it with `git show <reviewed commit>:<file>` before you rule on it.
 - **A ticket that is not merged stops the end of run.** While one ticket is BLOCKED, there is no tidy and no final review of the merged tickets.
 - **A published PR branch keeps its history.** See "End of run".

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/correctness.md

@@ -10,6 +10,7 @@ Checks: {correctness}
 Read the checks file and apply each of its checks to the diff of the range, with the Risk line of the ticket first: races, idempotency, time, authorization, persistence keys and identities, migrations, error paths.
 The output section of the checks file does not apply here: your findings go into the report.
 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.
 Do not commit and do not dispatch subagents. Leave the tree as you found it.
@@ -22,11 +23,11 @@ Write one JSON report at {report}. When your sandbox is read-only, give the JSON
   "required": ["status", "commits", "files", "concerns", "findings"],
   "properties": {
     "status": {"enum": ["DONE", "DONE_WITH_CONCERNS", "NEEDS_CONTEXT", "BLOCKED"]},
-    "commits": {"type": "array", "items": {"type": "string", "pattern": "^[0-9a-f]{7,40}$"}},
+    "commits": {"description": "Only the commits you created. A review creates none, so this list is empty: never list a commit of the range.", "type": "array", "items": {"type": "string", "pattern": "^[0-9a-f]{7,40}$"}},
     "files": {"type": "array", "items": {"type": "string"}},
     "concerns": {"type": "array", "items": {"type": "string"}},
     "findings": {"type": "array", "items": {"type": "object", "required": ["severity", "file", "line", "title", "evidence", "kind"], "properties": {"severity": {"enum": ["critical", "important", "minor"]}, "file": {"type": "string"}, "line": {"type": "integer"}, "title": {"type": "string", "minLength": 1}, "evidence": {"type": "string", "minLength": 1}, "kind": {"enum": ["code", "fixture", "test"]}}}},
-    "mutations": {"type": "array", "items": {"type": "object", "required": ["test", "file", "line", "red"], "properties": {"test": {"type": "string", "minLength": 1}, "file": {"type": "string", "minLength": 1}, "line": {"type": "integer"}, "red": {"type": "string", "minLength": 1}}}}
+    "mutations": {"description": "Optional for this pass.", "type": "array", "items": {"type": "object", "required": ["test", "file", "line", "red"], "properties": {"test": {"type": "string", "minLength": 1}, "file": {"type": "string", "minLength": 1}, "line": {"type": "integer"}, "red": {"type": "string", "minLength": 1}}}}
   }
 }
 ```

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/prompts/reviewer.md

@@ -10,7 +10,7 @@ Test-writer report, when the ticket has a test-writer: {writer_report}
 Check the diff against the ticket and the spec, then for quality. Check that each criterion has a locked test. Test each suspicion that the ticket names in its Suspicions line.
 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, the production file and line, and one failure line copied exactly from the output you printed.
+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.
 Do not commit and do not dispatch subagents. Leave the tree as you found it.
 
@@ -22,11 +22,11 @@ Write one JSON report at {report}. When your sandbox is read-only, give the JSON
   "required": ["status", "commits", "files", "concerns", "findings"],
   "properties": {
     "status": {"enum": ["DONE", "DONE_WITH_CONCERNS", "NEEDS_CONTEXT", "BLOCKED"]},
-    "commits": {"type": "array", "items": {"type": "string", "pattern": "^[0-9a-f]{7,40}$"}},
+    "commits": {"description": "Only the commits you created. A review creates none, so this list is empty: never list a commit of the range.", "type": "array", "items": {"type": "string", "pattern": "^[0-9a-f]{7,40}$"}},
     "files": {"type": "array", "items": {"type": "string"}},
     "concerns": {"type": "array", "items": {"type": "string"}},
     "findings": {"type": "array", "items": {"type": "object", "required": ["severity", "file", "line", "title", "evidence", "kind"], "properties": {"severity": {"enum": ["critical", "important", "minor"]}, "file": {"type": "string"}, "line": {"type": "integer"}, "title": {"type": "string", "minLength": 1}, "evidence": {"type": "string", "minLength": 1}, "kind": {"enum": ["code", "fixture", "test"]}}}},
-    "mutations": {"type": "array", "items": {"type": "object", "required": ["test", "file", "line", "red"], "properties": {"test": {"type": "string", "minLength": 1}, "file": {"type": "string", "minLength": 1}, "line": {"type": "integer"}, "red": {"type": "string", "minLength": 1}}}}
+    "mutations": {"description": "Required in the first review of a tip: one proof or more for each locked test file, with `test` as `<locked file>::<test name>`. A review scoped to a fix gives the proofs that it names.", "type": "array", "items": {"type": "object", "required": ["test", "file", "line", "red"], "properties": {"test": {"type": "string", "minLength": 1}, "file": {"type": "string", "minLength": 1}, "line": {"type": "integer"}, "red": {"type": "string", "minLength": 1}}}}
   }
 }
 ```

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)]}))
@@ -516,6 +544,32 @@ def test_the_correctness_prompt_keeps_the_agent_off_the_tree_the_reviewer_edits(
     assert "run no tests" in text
 
 
+def test_the_correctness_pass_reads_the_untracked_inputs_of_the_driver_from_the_working_tree(tmp_path):
+    """Issue 66: the ticket and the findings files are in the ignored .agent/, so git at the tip has none of them."""
+    rig = Inside(tmp_path, RISKY, {"correctness": [SOL, OPUS], "implementer": [OPUS]})
+    rig.run(plan(**{"02/correctness": [correct([finding("C-IMPORTANT")])], "02/fixer": [fix("02", 1)]}))
+    assert rig.code == 0, rig.ledger()
+    again = rig.prompt("correctness-1", "02")
+    inputs = (".agent/tickets/02-quote-fields.md", ".agent/implement/02/findings-0.json")
+    assert all(path in again for path in inputs), again
+    tracked = subprocess.run(["git", "-C", str(rig.repo), "ls-files", *inputs], capture_output=True, text=True).stdout
+    assert tracked == ""
+    assert "read the spec, the ticket and the findings file from the working tree" in again
+
+
+@pytest.mark.parametrize("role", ["reviewer", "correctness"])
+def test_the_schema_of_a_review_says_that_commits_holds_only_the_agents_own_commits(role):
+    """Issue 66: a reviewer that lists a commit of the range costs a rerun (`is not a new commit`)."""
+    description = driver_report.schema(role)["properties"]["commits"]["description"]
+    assert "only the commits you created" in description.lower() and "empty" in description
+
+
+def test_the_reviewer_schema_asks_for_one_proof_for_each_locked_test_file_in_the_first_review():
+    """Issue 66: a first review with no proof for a locked test file costs a rerun."""
+    description = driver_report.schema("reviewer")["properties"]["mutations"]["description"]
+    assert "each locked test file" in description and "`<locked file>::<test name>`" in description
+
+
 def test_git_identity_is_not_needed_to_open_the_merge_for_the_conflict_agent(tmp_path):
     import driver_merge
     rig = Inside(tmp_path)

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:11:47.113Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.10",
-      "hash": "sha256-a0c42688cad43aece79d51d9e09644cc879518858781bf5563e6f8388d009a0c",
+      "version": "0.1.12",
+      "hash": "sha256-d50cbfcb02b148c9f122d16333274b2d758efc8a1b35e0cf54eb831f34eba6de",
       "description": "Implement a specification in code."
     },
     {