@jesdi/skills 0.0.40 → 0.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jesdi/skills",
-  "version": "0.0.40",
+  "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

@@ -110,8 +110,10 @@ 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.
+- 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,9 +117,9 @@ 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 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 test-writer correction.
+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.
 
 - 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.

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/driver_fixloop.py

@@ -164,12 +164,13 @@ def _act_on(job: Job, found: list[dict]) -> bool:
 
 
 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."""
+    """Gate the tip. A red gate on the implementer's commit or a fixer's commit before round 4 is a finding for the
+    next round; a red gate after round 4 or on a test-writer correction 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:
+        if job.round == ROUNDS or job.corrected:
             run.gate(number, job.slot, job.tip)
             return []
         record = run.red_gate(number, job.slot, job.tip)

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"):]
@@ -358,6 +359,9 @@ echo "$nn $PWD" >> "$0.calls"
 # Ticket 01 waits until ticket 02 has its branch, so both start from the same PR tip.
 TOGETHER = """[ "$nn" != 01 ] || until git rev-parse -q --verify refs/heads/ticket/02 > /dev/null; do sleep 0.02; done\n"""
 REFACTOR = {"seam": "none — refactor"}
+# A fixer that cannot make the red gate green: the ticket blocks at fix round 1.
+GIVE_UP = """[ $role != fixer ] || { printf '{"status": "BLOCKED", "commits": [], "files": [], "concerns": ["the gate stays red"], "green": [], "ticket": "01"}' > "$report"; exit 0; }\n"""
+GAVE_UP = "Ticket 01: BLOCKED at fix round 1: the fixer reported BLOCKED: the gate stays red."
 
 
 def walk(tmp_path, capsys, body, *args, gate="true"):
@@ -452,13 +456,13 @@ def test_a_conflict_cli_that_fails_stops_the_run_and_leaves_no_open_merge(repo,
         assert out_of("git", "-C", slot, "rev-parse", "-q", "--verify", "MERGE_HEAD") == ""
 
 
-def test_a_red_gate_blocks_the_ticket_and_the_ticket_it_blocks_never_starts(repo, tmp_path, capsys):
+def test_a_red_gate_is_a_finding_and_the_ticket_it_blocks_never_starts(repo, tmp_path, capsys):
     two(repo, second="01")
-    code, ledger, out = walk(tmp_path, capsys, WORK + REPORT, gate="echo CHECK-OUTPUT; exit 1")
+    code, ledger, out = walk(tmp_path, capsys, GIVE_UP + WORK + REPORT, gate="echo CHECK-OUTPUT; exit 1")
     tip = out_of("git", "rev-parse", "--short=7", "ticket/01")
-    assert code == 1 and len(ledger) == 2, out
-    assert ledger[1] == (f"Ticket 01: BLOCKED at the gate: the gate is red on {tip}, "
-                         f"record .agent/implement/01/gate-{tip}.log.")
+    assert code == 1 and ledger[-1] == GAVE_UP, out
+    assert ledger[1] == (f"Ticket 01: critical finding of kind code from the gate at "
+                         f".agent/implement/01/gate-{tip}.log:0: the gate is red on {tip}.")
     record = (tmp_path / f".agent/implement/01/gate-{tip}.log").read_text()
     assert "status: clean\n" in record and "CHECK-OUTPUT\n\nexit: 1\nafter: clean\nend: " in record
     assert "Ticket 02 is not merged: its phase is pending." in out and "| gates run | 1 |" in out
@@ -479,8 +483,8 @@ def test_a_red_merge_gate_blocks_the_ticket_and_the_pr_branch_does_not_move(repo
 
 def test_a_tree_that_is_not_clean_is_a_red_gate_and_the_slot_keeps_the_work(repo, tmp_path, capsys):
     repo(t01=ticket("01", **REFACTOR))
-    code, ledger, out = walk(tmp_path, capsys, WORK + REPORT + "echo left > junk.txt\n", gate="echo NEVER")
-    assert code == 1 and "BLOCKED at the gate" in ledger[-1], out
+    code, ledger, out = walk(tmp_path, capsys, GIVE_UP + WORK + REPORT + "echo left > junk.txt\n", gate="echo NEVER")
+    assert code == 1 and "from the gate at .agent/implement/01/gate-" in ledger[-3] and ledger[-1] == GAVE_UP, out
     record = next((tmp_path / ".agent/implement/01").glob("gate-*.log")).read_text()
     assert "status: not clean\n    ?? junk.txt\n" in record and "exit: not run" in record and "\nNEVER\n" not in record
     assert out_of("git", "symbolic-ref", "--short", "HEAD") == "ticket/01" and (tmp_path / "junk.txt").exists()
@@ -729,8 +733,8 @@ def test_a_merge_commit_the_slot_cannot_check_out_is_not_gated_and_does_not_land
 ])
 def test_a_gate_that_changes_the_tree_or_moves_head_is_red(repo, tmp_path, capsys, gate, after):
     repo(t01=ticket("01", **REFACTOR))
-    code, ledger, out = walk(tmp_path, capsys, WORK + REPORT, gate=gate)
-    assert code == 1 and "BLOCKED at the gate: the gate is red on " in ledger[-1], out
+    code, ledger, out = walk(tmp_path, capsys, GIVE_UP + WORK + REPORT, gate=gate)
+    assert code == 1 and "from the gate at .agent/implement/01/gate-" in ledger[-3] and ledger[-1] == GAVE_UP, out
     record = next((tmp_path / ".agent/implement/01").glob("gate-*.log")).read_text()
     assert "\nexit: 0\n" in record and after in record
     assert state_of(tmp_path)["tickets"]["01"]["green_gates"] == []

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_fixloop.py

@@ -399,6 +399,21 @@ def test_a_red_gate_on_a_fixer_commit_starts_the_next_round_with_the_record_as_e
     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_implementer_commit_starts_fix_round_1_with_the_record_as_evidence(tmp_path):
+    """Issue 80: the gate of the implementer commit is red. That is a finding for round 1, not a BLOCKED ticket."""
+    rig = Inside(tmp_path, gate={"subjects": ["feat: 01 rows"]})
+    rig.run(plan(**{"01/reviewer": [review("01")], "01/fixer": [fix("01", 1)]}))
+    assert rig.code == 0, rig.ledger()
+    assert [call["role"] for call in rig.calls("01")] == ["test-writer", "implementer", "fixer", "reviewer"]
+    tip = rig.sha("01", "implementer")
+    record = f".agent/implement/01/gate-{tip[:7]}.log"
+    (gate,) = json.loads((rig.folder() / "findings-0.json").read_text())
+    assert (gate["source"], gate["severity"], gate["kind"]) == ("gate", "critical", "code")
+    assert gate["title"] == f"the gate is red on {tip[:7]}" and record in gate["evidence"]
+    assert "findings-0.json" in rig.prompt("fixer-1") and rig.state()["tickets"]["01"]["phase"] == "merged"
+    assert "The fix is" not in rig.prompt("reviewer-1")  # no review saw the implementer commit: a full review
+
+
 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)]}))

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

@@ -22,7 +22,7 @@ from pathlib import Path
 import pytest
 
 from test_cli import SKILL, ticket, three, git, models_file
-from test_walk import RUNNER, Rig, impl, plan, tw
+from test_walk import RUNNER, Rig, fix, impl, plan, tw
 
 # The fake runner of test_walk plus two hooks: `git` runs before the step's files, `git_after` right after them.
 HOOKED = RUNNER.replace(
@@ -76,13 +76,6 @@ def correct(findings=(), **extra):
     return {"report": report, **extra}
 
 
-def fix(nn, n, text=None, **changes):
-    """A fixer step: one commit on the ticket branch."""
-    step = impl(nn, text=text or f"def fn_{nn}():\n    return 'fix{n}'\n", commit=f"fix: {nn} round {n}", **changes)
-    step["report"]["ticket"] = nn
-    return step
-
-
 def edit(text, **new):
     """`text` with line N replaced (keyword `l<N>`)."""
     lines = text.splitlines(keepends=True)
@@ -201,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/implement-spec/tests/test_walk.py

@@ -130,6 +130,13 @@ def impl(nn, path="demo/export.py", text=None, **changes):
     return {**step, **changes}
 
 
+def fix(nn, n, text=None, **changes):
+    """A fixer step: one commit on the ticket branch."""
+    step = impl(nn, text=text or f"def fn_{nn}():\n    return 'fix{n}'\n", commit=f"fix: {nn} round {n}", **changes)
+    step["report"]["ticket"] = nn
+    return step
+
+
 PATHS = {"01": "demo/export.py", "02": "demo/export.py", "03": "demo/cli.py"}
 
 
@@ -264,8 +271,9 @@ def std(tmp_path_factory):
 
 @pytest.fixture(scope="module")
 def blocked(tmp_path_factory):
-    """The default scenario with a red gate on ticket/01."""
-    return Rig(tmp_path_factory.mktemp("blocked"), gate={"red": ["ticket/01"]}).run(plan())
+    """The default scenario with a red gate on ticket/01 that four fix rounds do not make green."""
+    fixes = [fix("01", n) for n in (1, 2, 3, 4)]
+    return Rig(tmp_path_factory.mktemp("blocked"), gate={"red": ["ticket/01"]}).run(plan(**{"01/fixer": fixes}))
 
 
 def test_01_starts_in_slot_1_03_in_slot_2_and_02_after_the_merge_of_01(std):
@@ -331,12 +339,15 @@ def test_gate_environment_names_the_pr_branch_and_a_pycache_prefix_under_agent_i
     assert os.path.realpath(gate["pycache"]).startswith(str((rig.repo / ".agent/implement").resolve()) + os.sep)
 
 
-def test_red_gate_blocks_the_ticket_names_the_record_and_launches_no_later_role(blocked):
+def test_red_gate_blocks_the_ticket_after_round_4_names_the_record_and_launches_no_review(blocked):
     assert blocked.code == 1, blocked.output()
     a1 = blocked.sha("01", "implementer")
-    assert [l for l in blocked.ledger() if "01" in l and "BLOCKED" in l and f"gate-{a1[:7]}.log" in l], blocked.ledger()
+    finding = f"Ticket 01: critical finding of kind code from the gate at .agent/implement/01/gate-{a1[:7]}.log:0: "
+    assert [l for l in blocked.ledger() if l.startswith(finding)], blocked.ledger()
     assert re.search(r"exit\D*1", (blocked.repo / f".agent/implement/01/gate-{a1[:7]}.log").read_text())
-    assert {c["role"] for c in blocked.calls("01")} == {"test-writer", "implementer"}
+    last = blocked.calls("01", "fixer")[-1]["sha"]
+    assert [l for l in blocked.ledger() if "01" in l and "BLOCKED" in l and f"gate-{last[:7]}.log" in l], blocked.ledger()
+    assert [c["role"] for c in blocked.calls("01")] == ["test-writer", "implementer"] + ["fixer"] * 4
     assert blocked.state()["tickets"]["01"]["phase"] == "blocked"
     assert "ticket/01" in blocked.branches() and "feat: 01 rows" not in blocked.pr_subjects()
 

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-15T23:44:37.469Z",
+  "generatedAt": "2026-10-16T10:22:13.328Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.16",
-      "hash": "sha256-8f7e4b06072b26e3a6699974dced9afe2745917c01784f9f6166d972c3ba60f1",
+      "version": "0.1.18",
+      "hash": "sha256-b10cd79532e2c8a33ddb8c55934ee26ee7f98d104ff7805bc3e2b819d0bb9241",
       "description": "Implement a specification in code."
     },
     {