@jesdi/skills 0.0.41 → 0.0.42

package/package.json

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

package/skills/implement-spec/ARCHITECTURE.md

@@ -112,6 +112,8 @@ and do not know about the run, except `driver_run.py`, which the three deciding
   provider of the implementer.
 - A red gate on the implementer's or a fixer's commit is a finding of the next round (`driver_fixloop._gate`), so
   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.
 
 ### Questions
 

package/skills/implement-spec/README.md

@@ -95,7 +95,7 @@ Everything is under `.agent/`, which is never committed.
 A ticket is ready when each ticket in its **Blocked by** line is merged and no running ticket touches the same place. The places are the backticked entries of the **Touches** lines: `file` or `file: function`. Two entries are the same place when they name the same file and the same function, or when one of them names the whole file. Each ready ticket takes the lowest free slot.
 
 1. **test-writer** (`prompts/test-writer.md`). It writes one black-box test for each criterion through the Seam and commits them red. Those files are locked. A ticket with Seam `none — refactor` has no test-writer.
-2. **implementer** (`prompts/implementer.md`). It starts from that commit and makes the locked tests green.
+2. **implementer** (`prompts/implementer.md`). It starts from that commit and makes the locked tests green. Its prompt gives the `--gate` command: it runs the gate on its final commit and makes it green before it reports DONE or DONE_WITH_CONCERNS.
 3. **Gate.** The driver runs `--gate` on the ticket tip.
 4. **Review.** The driver compares each locked file of the ticket with the test-writer commit. A file that differs is a critical finding `locked file changed: <path>`. Then the **reviewer** (`prompts/reviewer.md`) runs, and for a ticket with a **Risk** line the **correctness** pass (`prompts/correctness.md`) runs at the same time in the same slot.
 5. **Merge.** The driver merges the reviewed tip into the PR branch with git plumbing, then deletes the ticket branch. A conflict goes to the **conflict** agent (`prompts/conflict.md`) once. Its resolution may change no locked file of the ticket. A second conflict blocks the ticket.
@@ -117,7 +117,7 @@ Rules for each agent:
 | `critical` or `important` | One fix round. |
 | `minor` | It stays in the ledger and in the findings file. The final reviewer gets the list. |
 
-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 fix round is one **fixer** (`prompts/fixer.md`), which runs the gate on its final commit before it reports, as the implementer does, then the gate of the driver 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 the implementer or 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: a red gate on the commit of the implementer starts round 1. The 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 a test-writer correction: the correction is outside the fix rounds, and a fixer may not edit the locked files.
 

package/skills/implement-spec/driver.py

@@ -81,7 +81,7 @@ def _prompt_values(ticket: Ticket, slot: str, run: Run) -> dict[str, str]:
     folder = OUT / ticket.number
     return {"spec": os.path.relpath(run.args.spec, slot), "seam": ticket.seam, "pr_branch": run.pr,
             "branch": f"ticket/{ticket.number}", "ticket": os.path.relpath(Path(run.args.tickets) / ticket.file, slot),
-            "correctness": str(driver_review.CORRECTNESS),
+            "correctness": str(driver_review.CORRECTNESS), "gate": run.args.gate,
             "blocked_report": os.path.relpath(_blocked_report(ticket.number, run), slot),
             "writer_report": os.path.relpath(folder / "test-writer-0.json", slot)}
 

package/skills/implement-spec/driver_final.py

@@ -79,7 +79,8 @@ def finish_interrupted_move(state: State, pr: str) -> None:
 
 def _prompt_values(run: Run) -> dict[str, str]:
     """The pointers every prompt of the end of run gets. Its agents work in slot 1, the PR worktree."""
-    return {"spec": run.args.spec, "tickets": run.args.tickets, "pr_branch": run.pr, "branch": run.pr}
+    return {"spec": run.args.spec, "tickets": run.args.tickets, "pr_branch": run.pr, "branch": run.pr,
+            "gate": run.args.gate}
 
 
 def _title(finding: dict) -> str:

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

@@ -11,7 +11,8 @@ Findings to fix:
 Fix each finding in the list as one batch, in one commit or in several. Leave the minor findings of the findings file.
 Each commit belongs to one ticket: the ticket whose criterion or code the commit changes. A fix for two tickets is two commits.
 Never edit a locked file: each one stays as it is at {start_sha}, and a locked file that differs is a critical finding of the next review.
-Use targeted tests while you work. The driver runs the gate on your final commit, and a scoped review reads your commits.
+Use targeted tests while you work.
+Before you report DONE or DONE_WITH_CONCERNS, run the gate on your final commit, with IMPLEMENT_SPEC_BASE={pr_branch} in the environment: `{gate}`. Fix each failure, commit, and run it again until it is green. The driver runs the gate again on your final commit, and a scoped review reads your commits.
 Commit your work on the checked-out PR branch and change no commit that is on it now. Do not dispatch subagents.
 In `commits`, give every commit you made with the number of its ticket: the driver names each commit `fix(NN): <your subject>` from it, and a commit with no ticket is a violation. In `green`, give the summary lines of the passing test output.
 

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

@@ -10,7 +10,8 @@ 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` and each finding of kind `test` on a locked file: 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}.
 If a locked test contradicts the spec or the ticket, so that no fix can make it green, stop and report BLOCKED with a concern that starts with `locked test contradicts spec:`, then the test and the evidence.
-Use targeted tests while you work. The driver runs the gate on your final commit, and a re-review reads the lines you changed.
+Use targeted tests while you work.
+Before you report DONE or DONE_WITH_CONCERNS, run the gate on your final commit, with IMPLEMENT_SPEC_BASE={pr_branch} in the environment: `{gate}`. Fix each failure, commit, and run it again until it is green. The driver runs the gate again 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/implementer.md

@@ -9,7 +9,8 @@ Locked files: {locked}
 Make the locked tests green and meet each criterion of the ticket. For internal code, work in vertical test-first slices: one failing test, the smallest code that passes it, then the next slice.
 Never edit a locked file. If a locked test contradicts the spec or the ticket, stop and report BLOCKED with a concern that starts with `locked test contradicts spec:`, then the test and the evidence.
 Commit your work on the checked-out ticket branch. Do not dispatch subagents.
-Run targeted tests while you work. The driver runs the gate on your final commit.
+Run targeted tests while you work.
+Before you report DONE or DONE_WITH_CONCERNS, run the gate on your final commit, with IMPLEMENT_SPEC_BASE={pr_branch} in the environment: `{gate}`. Fix each failure, commit, and run it again until it is green. The driver runs the gate again on your final commit.
 In `green`, give the summary lines of the passing test output.
 
 Write one JSON report at {report} that matches this schema:

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

@@ -247,7 +247,7 @@ def test_implementer_prompt_carries_pointers_and_only_template_sentences(env):
     for prefix in (str(w.repo.resolve()) + "/", str(w.repo) + "/"):
         prompt = prompt.replace(prefix, "")
     for value in (report, "specs/csv/spec.md", ".agent/tickets/01-export-rows.md", "`export_csv()`", sha,
-                  "tests/test_export.py"):
+                  "tests/test_export.py", "feat/csv", "true"):
         prompt = prompt.replace(value, "")
     lines = lambda text: {" ".join(l.split()) for l in text.splitlines() if l.strip()}
     assert lines(prompt) <= lines(re.sub(r"\{[a-z_]+\}", "", template))

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

@@ -229,6 +229,7 @@ def test_a_rerun_prompt_holds_only_template_lines_and_keeps_its_ending(repo, tmp
     prompt = prompt_of(tmp_path)
     first = driver_agents.render("implementer", {
         "spec": "spec.md", "ticket": ".agent/tickets/01-t.md", "seam": "none — refactor", "locked": "",
+        "gate": "true", "pr_branch": "feat/x",
         "start_sha": subprocess.run(["git", "rev-parse", "HEAD"], capture_output=True, text=True).stdout.strip(),
         "report": ".agent/implement/01/implementer-0.json"})
     ending = first[first.index("\nWrite one JSON report"):]

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

@@ -31,7 +31,7 @@ from types import SimpleNamespace
 import pytest
 
 from test_cli import git, ticket
-from test_review import FABLE, HOOKED, ONE, OPUS, Review, finding, review
+from test_review import FABLE, HOOKED, ONE, OPUS, Review, finding, gate_rule, review
 from test_stops import UNATTENDED, decisions, stage
 from test_walk import impl, plan, tw
 
@@ -296,6 +296,11 @@ def test_two_findings_make_one_fixer_batch_of_fix_commits_on_top_of_the_unchange
     assert ref(fixed.repo, "feat/csv~2") == reviewed
 
 
+def test_the_fixer_of_the_final_review_gets_the_gate_command_and_runs_it_before_it_reports(fixed):
+    (batch,) = fixed.final_calls("fixer")
+    gate_rule(batch["prompt"], str(fixed.rig / "gate"))
+
+
 def test_a_scoped_review_covers_the_range_after_the_reviewed_tip_and_one_gate_runs_on_the_new_tip(fixed):
     reviewed, tip = fixed.final_calls("final-reviewer")[0]["head"], fixed.branch()
     first, scoped = fixed.final_calls("final-reviewer")

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

@@ -194,6 +194,21 @@ def test_each_round_ends_with_one_gate_record_and_a_re_review_scoped_to_the_fix(
         assert tips[k - 1][:7] in reviews[k]["prompt"] and tips[k][:7] in reviews[k]["prompt"], k
 
 
+def gate_rule(prompt, gate):
+    """The line of `prompt` that gives the gate command; it must say to run it before the report."""
+    (line,) = [l for l in prompt.splitlines() if f"`{gate}`" in l]
+    assert "IMPLEMENT_SPEC_BASE=feat/csv" in line and "Before you report DONE" in line, line
+    return line
+
+
+def test_the_implementer_and_each_fixer_get_the_gate_command_and_run_it_before_they_report(escalated):
+    gate = str(escalated.rig / "gate")
+    agents = escalated.calls("01", "implementer") + escalated.calls("01", "fixer")
+    assert len(agents) == 4, "the implementer and the fixers of rounds 1, 2 and 3 (the next model)"
+    for call in agents:
+        gate_rule(call["prompt"], gate)
+
+
 def test_reports_are_named_by_role_and_round(escalated):
     for name in ("reviewer-0", "reviewer-1", "reviewer-2", "reviewer-3", "fixer-1", "fixer-2", "fixer-3"):
         assert (escalated.folder() / f"{name}.json").exists(), name

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-16T09:21:05.102Z",
+  "generatedAt": "2026-10-16T10:22:13.328Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.17",
-      "hash": "sha256-3e93a264e28048f143a4d39786bb30974e42b4da6a6f5da36a1ea3418b840632",
+      "version": "0.1.18",
+      "hash": "sha256-b10cd79532e2c8a33ddb8c55934ee26ee7f98d104ff7805bc3e2b819d0bb9241",
       "description": "Implement a specification in code."
     },
     {