@jesdi/skills 0.0.46 → 0.0.48

package/package.json

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

package/skills/implement-spec/README.md

@@ -97,13 +97,13 @@ 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.
+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. Its prompt names the locked tests of merged tickets: each fixture must set up the precondition of its scenario under the spec rules and those tests. 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. It makes the gate (`--gate`) green on its final commit 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>`. A locked file of a merged ticket that the ticket changed since its merge base with the PR branch is a critical `fixture` finding `the ticket changed the locked file of a merged ticket: <path>`, so it goes to a correction (see **Before a correction**). 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. A read-only role (reviewer, correctness, final-reviewer, pr-writer) leaves its slot and the git config as it found them: all worktrees share one config, and one key written there, such as a `core.worktree` on a temp directory, breaks git in each of them. To run a check off the slot, a reviewer reads the driver's gate record or makes its own `git worktree add --detach` copy and removes it. After read-only roles, the driver checks the slot and the shared config (`git rev-parse --git-common-dir`, then `config`) against what they were before. When one of them changed, the driver restores it, writes `a read-only role broke its rule: ...` to the ledger, and runs the review one more time; a second change blocks the ticket.
 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.
    **The landing check.** Merges are serial. Before the PR branch moves, the driver compares the tree that is about to land (the ticket tip of a fast-forward, or the merge commit) with the PR tip: each locked file of each merged ticket must be the same tree entry in both: the same blob with the same mode, so a file that became a symlink is a difference. A file that only one of them has is a difference. A file that the landing ticket lists in its own `locked` is not checked: the test-writer of a later ticket can add a test to a file that an earlier ticket locked, and must list that file. A test-writer report that changes such a file and does not list it is rejected, with the usual one rerun. The review finds such a change first; the landing check catches a change that no review saw, for example of a ticket that merged after the last review. A difference refuses the landing: the ticket is BLOCKED with `locked file changed: <path>` in the ledger, the PR branch does not move, and no fix round runs. The PR branch moves only from the tip that the check read; when another hand moved the branch in between, the driver makes the merge, the check and the gate again, one time. Only that case starts the landing again: a refused landing and a red merge gate block the ticket. The second try runs no conflict agent, so a conflict there blocks the ticket, and so does a branch that moved again.
-   **Before a correction.** A test-writer that corrects locked tests (after `overrule-test`, or for a `fixture` finding or a `test` finding on a locked file) starts from the locked versions: the driver puts back each locked file of the ticket and each locked file of a merged ticket that the ticket changed, commits them in one commit of its own, and the ledger names each file. A file of a merged ticket goes back to the version of the PR branch. The commit keeps the tree of the next fixer and of the gate clean, whatever files the correction commits. The correction's prompt names the restored files: when a test in one of them fails only because the ticket changed an interface that the test uses, the correction updates the file to the new interface, keeps what each test asserts, and lists the file in `locked`.
+   **Before a correction.** A test-writer that corrects locked tests (after `overrule-test`, or for a `fixture` finding or a `test` finding on a locked file) starts from the locked versions: the driver puts back each locked file of the ticket and each locked file of a merged ticket that the ticket changed, commits them in one commit of its own, and the ledger names each file. A file of a merged ticket goes back to the version of the PR branch. The commit keeps the tree of the next fixer and of the gate clean, whatever files the correction commits. The correction's prompt names the restored files: when a test in one of them fails only because the ticket changed an interface that the test uses, the correction updates the file to the new interface, keeps what each test asserts, and lists the file in `locked`. Each correction also gets `prompts/corrected.md`: when it adds a requirement, it updates each shared fake or fixture that other locked tests use, runs each whole locked file and each locked test of merged tickets, and names each red test in `concerns`.
    **The gate of the restore.** In the fix loop, the tip before the restore has a green gate, so the driver gates the restore commit and does not leave the question to the correction. A red gate means that a restored file fails with the ticket's code: the correction gets the gate record (`prompts/restored-red.md`), and a DONE correction must list a restored file in `locked`; else it reports BLOCKED with `locked test contradicts spec:`. A green gate with only driver findings to correct closes them with the restore: no test-writer runs. After `overrule-test` the driver does not gate the restore, because the tip before it has no green gate; a change that the next implementer makes to a merged ticket's file is a finding of the next review.
 
 Rules for each agent:
@@ -178,7 +178,7 @@ Every report has `status` (`DONE`, `DONE_WITH_CONCERNS`, `NEEDS_CONTEXT`, `BLOCK
 |---|---|---|---|
 | 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`. |
 | 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 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. |
+| 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. |
 | fixer | `prompts/fixer.md` | `green`, `ticket` | With DONE: one commit or more. |
 | final-reviewer | `prompts/final-reviewer.md` | `findings` | None. |
@@ -207,7 +207,7 @@ Answer with `--answer <question id>=<option id>` on the next run, or through the
 | Check | Where it lives |
 |---|---|
 | Locked tests with a demonstrated red | `driver_report.py` `_proof_errors`: each red line of the test-writer report must be in its log. `driver_review.py` `locked_findings`: a locked file of the ticket that differs from the test-writer commit is a critical finding, before each review. `driver_review.py` `merged_changes`: a locked file of a merged ticket that the ticket changed is a critical `fixture` finding, before each review. `driver_merge.py` `refused`, called from `driver.py` `_checked_landing` under the merge lock: a locked file of a merged ticket that differs between the PR tip and the tree that is about to land refuses the landing, so a later ticket cannot change the locked test of an earlier one. `driver_report.py` `_merged_errors` rejects a test-writer report that changes such a file and does not list it. |
-| One mutation proof for each locked test | `prompts/reviewer.md` asks for one proof for each locked test. `driver_report.py` `_locked_errors` and `_proof_errors` reject a first review with no proof for a locked test file, or with a red line that is not in the log. `driver_review.py` `follow` finds the proofs that a fix makes due again. |
+| One mutation proof for each locked test | `prompts/full-review.md`, the note of each full review, names the locked test files that need a proof. `driver_report.py` `_locked_errors` and `_proof_errors` reject a full review with no proof for a locked test file, or with a red line that is not in the log. `driver_review.py` `follow` finds the proofs that a fix makes due again. |
 | One independent correctness pass for each risky ticket | `driver_fixloop.py` `_review` adds the pass for a ticket with a **Risk** line. `driver_agents.py` `correctness_entry` picks the entry of another provider, and `load_models` stops the run when there is none or its CLI is not on PATH. |
 | One full gate for each candidate | `driver_gate.py` `run`, called from `driver_run.py` `Run.gate`: one record for each commit the driver is about to trust. Green is exit 0 on a tree that is clean before and after, with HEAD not moved. |
 | Post-merge check on the PR branch | `driver.py` `_checked_landing`: a merge commit is gated before the PR branch moves to it. A fast-forward of a gated tip uses the record of that tip. `driver_final.py` `_review_until_reviewed` gates the tip again after the tidy and after the fix batch. |
@@ -217,7 +217,7 @@ The driver enforces the mutation proof for each locked test file, not for each l
 ## Known limits
 
 - **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.
+- **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 each full 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. 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

@@ -66,12 +66,12 @@ def _run_reviewers(job: Job, cast: list[tuple[str, str]], locked: list[str]) ->
     errors: dict[str, str] = {}
 
     def call(role: str, entry: str) -> dict:
-        # The first review of a tip must give a mutation proof for each locked test.
-        first_review = not job.previous and role == "reviewer"
+        # A full review (no fix range) must give a mutation proof for each locked test file; the prompt names them.
+        full = not job.previous and role == "reviewer"
+        notes = ["rereview"] if job.previous else ["full-review"] if full else []
         try:
             return job.run.agent(role, job.ticket.number, job.slot, values, entry=entry, fix_round=job.round,
-                                 notes=["rereview"] if job.previous else [],
-                                 check={"round": 1, "locked": locked} if first_review else {},
+                                 notes=notes, check={"full": True, "locked": locked} if full else {},
                                  alone=lambda: len(running) == 1)
         except Blocked as blocked:
             errors[role] = f"the {role}: {blocked}"

package/skills/implement-spec/driver_report.py

@@ -1,6 +1,6 @@
 """Report validation: validate(role, path, context) -> list of errors, empty when the report is accepted.
 
-context: repo (slot path), branch, start (HEAD when the role started), log, round (1 = first review), locked,
+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),
   owners (ticket numbers, for the final fix batch), merged (locked files of merged tickets, not its own), pr (tip)."""
@@ -93,14 +93,14 @@ def _proof_errors(report: dict, context: dict) -> list[str]:
     errors = []
     if lines and not all(_seen(line, Path(context["log"]).read_text(errors="replace")) for line in lines):
         errors.append(RED)
-    if context.get("round") == 1 and "findings" in report and "mutations" not in report:
-        errors.append("mutations: required in round 1")
+    if context.get("full") and "findings" in report and "mutations" not in report:
+        errors.append("mutations: required in a full review")
     return errors
 
 
 def _locked_errors(report: dict, context: dict) -> list[str]:
-    """In the first review, each locked test file has a mutation proof (`mutations[].test` is `<file>::<test>`)."""
-    if context.get("round") != 1 or "findings" not in report:
+    """In a full review, each locked test file has a mutation proof (`mutations[].test` is `<file>::<test>`)."""
+    if not context.get("full") or "findings" not in report:
         return []
     tests = [proof["test"] for proof in report.get("mutations", [])]
     return [f"mutations: no mutation proof for the locked test file {path}" for path in context.get("locked", [])

package/skills/implement-spec/driver_run.py

@@ -105,6 +105,9 @@ class Run:
             # Its report may change a locked file of a merged ticket only when it lists the file.
             merged = driver_merge.protected(self.state.read()["tickets"], number)
             options["check"] = {**(options.get("check") or {}), "merged": merged, "pr": self.tip()}
+            values = {**values, "protected": " ".join(merged) or "none"}
+            if options["check"].get("correction"):
+                options["notes"] = [*options.get("notes", ()), "corrected"]
         report = _attempts(self, role, number, slot, values, **options)
         if role == "test-writer":
             report["locked"] = driver_report.locked_files(report["locked"])  # as validate read it
@@ -280,7 +283,7 @@ def _attempts(run: Run, role: str, number: str, slot: str, values: dict[str, str
     folder.mkdir(parents=True, exist_ok=True)
     report, log, prompt = (folder / f"{role}-{fix_round}{suffix}" for suffix in (".json", ".log", ".prompt.md"))
     report_in_slot = os.path.relpath(report, slot)  # the agent works in its slot
-    context = {"repo": slot, "branch": values["branch"], "start": values["start_sha"], "log": str(log), "round": 0,
+    context = {"repo": slot, "branch": values["branch"], "start": values["start_sha"], "log": str(log),
                "template": template or role, **(check or {})}
     argv = _command(run, role, entry, os.path.relpath(prompt, slot), report_in_slot)
     text = _first_prompt(context["template"], values, notes, report_in_slot)

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

@@ -0,0 +1,3 @@
+
+When this correction adds a requirement, update each shared fake or fixture that other locked tests use, so that those tests satisfy the requirement too.
+Then run each whole file of `locked` and each locked test of merged tickets. In `concerns`, name each red test and why it is expected to be red, or write that all are green.

package/skills/implement-spec/prompts/full-review.md

@@ -0,0 +1,2 @@
+
+This is a full review of {start_sha}: give one mutation proof or more for each of these locked test files: {locked}

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

@@ -8,7 +8,7 @@ Locked files: {locked}
 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`.
+To make a mutation proof for a locked test, break the production line the test protects, run the test, print its failing output, then revert the edit. The end of this prompt names the proofs that this review needs. 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 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: `fixture` when a locked test encodes a stale path, format or setup detail; `test` when a test is weak or missing, as a locked test that stays green when you break the line it protects; `code` for anything else. The test-writer corrects each `fixture` finding and each critical or important `test` finding on a locked file, and the fixer gets the rest.
@@ -26,7 +26,7 @@ Write one JSON report at {report}. When your sandbox is read-only, give the JSON
     "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": {"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}}}}
+    "mutations": {"description": "Required in a full review: 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/prompts/test-writer.md

@@ -7,6 +7,7 @@ Branch: {branch}, at commit {start_sha}
 
 Read the spec, the ticket, CONTEXT.md and the ADRs when they exist, and the public interface of the Seam. Do not read an implementation plan or implementation code.
 Write one black-box acceptance test for each criterion of the ticket, through the Seam only. Define the interface when it does not exist.
+Each fixture sets up exactly the precondition of its scenario. Check it against the rules of the spec and against the locked tests of merged tickets: {protected}.
 Run each test and confirm that it fails because the behavior is missing, not because of an import error or a syntax error. Print that failing output.
 A test that is green before any implementation is not a proof. Rewrite it until it fails, or name in `concerns` the production-code mutation that turns it red.
 Commit the tests red on the checked-out branch. Do not write implementation code and do not dispatch subagents.

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

@@ -341,6 +341,22 @@ def test_a_fixture_correction_starts_from_the_locked_file_of_the_merged_ticket(t
     assert rig.led("Ticket 02:", "restored") == [RESTORED_01] and rig.code == 0
 
 
+def test_the_test_writer_checks_fixture_preconditions_and_a_correction_keeps_shared_fixtures_and_runs_the_locked_files(tmp_path):
+    """Issue #97: a fixture misses the precondition of its scenario or a rule that a merged ticket locks, and a
+    correction adds a requirement that the shared fakes of other locked tests do not satisfy."""
+    stale = finding("STALE", kind="fixture", file="tests/test_02.py")
+    correction = {**tw("02"), "files": {"tests/test_02.py": "# corrected\n"}, "commit": "test: 02 fixture fix"}
+    rig = Inside(tmp_path, three()).run(plan(**{"02/test-writer": [tw("02"), correction],
+                                                "02/reviewer": [review("02", [stale]), review("02")]}), parallel="1")
+    assert rig.code == 0, rig.ledger()
+    first, corrected = rig.prompt("test-writer-0", "02"), rig.prompt("test-writer-1", "02")
+    assert "Each fixture sets up exactly the precondition of its scenario" in first
+    assert "the locked tests of merged tickets: tests/test_01.py." in first
+    assert "update each shared fake or fixture" not in first
+    assert "update each shared fake or fixture that other locked tests use" in corrected
+    assert "run each whole file of `locked` and each locked test of merged tickets" in corrected
+
+
 def test_the_restore_before_a_correction_is_committed_so_the_next_fixer_and_its_gate_find_a_clean_tree(tmp_path):
     """Issue #86: the correction and the fixer each commit only their own files. The restore of the merged ticket's
     file must not stay in the tree, where the gate of the fixer's commit is `not clean` and burns a round."""
@@ -506,16 +522,38 @@ def test_a_first_review_proves_each_locked_file_and_a_second_bad_report_blocks(t
     assert "feat: 01 rows" not in rig.pr_subjects()
 
 
+def test_a_full_review_after_a_correction_names_each_locked_file_that_needs_a_proof(tmp_path):
+    """Issue #92: the full review after a correction in a later round must prove each locked file, not only round 1."""
+    two = ("tests/test_01.py", "tests/test_01b.py")
+    first = {**tw("01"), "files": {path: "def test_x():\n    assert 0\n" for path in two}}
+    first["report"] = {**first["report"], "files": list(two), "locked": list(two)}
+    proofs = [dict(test=f"{path}::test_x", file="demo/export.py", line=1, red=f"FAILED {path}::test_x") for path in two]
+    both = lambda found=(): {"stdout": "".join(p["red"] + "\n" for p in proofs),
+                             "report": {**review("01", found)["report"], "mutations": proofs}}
+    vacuous = finding("VACUOUS", "critical", kind="test", file="tests/test_01.py")
+    correction = {**first, "files": {"tests/test_01.py": "# stronger\n"}, "commit": "test: 01 stronger test"}
+    correction["report"] = {**first["report"], "files": ["tests/test_01.py"], "locked": ["tests/test_01.py"]}
+    rig = Inside(tmp_path).run(plan(**{"01/test-writer": [first, correction], "01/fixer": [fix("01", 1)],
+                                       "01/reviewer": [both([STUCK]), review("01", [vacuous], lines=()), both()]}))
+    assert rig.code == 0, rig.ledger()
+    order = [call["role"] for call in rig.calls("01")]
+    assert order == ["test-writer", "implementer", "reviewer", "fixer", "reviewer", "test-writer", "reviewer"]
+    due = "give one mutation proof or more for each of these locked test files: tests/test_01.py tests/test_01b.py\n"
+    initial, again, full = (call["prompt"] for call in rig.calls("01", "reviewer"))
+    assert due in initial and due in full, full
+    assert "In round 1" not in full and due not in again
+
+
 def test_the_locked_file_rule_is_for_the_first_review_only(tmp_path):
     report = dict(status="DONE", commits=[], files=[], concerns=[], findings=[], mutations=[])
     path = tmp_path / "reviewer-0.json"
     path.write_text(json.dumps(report))
     context = {"repo": ".", "branch": "main", "start": "HEAD", "log": str(path), "locked": ["tests/a.py", "tests/b.py"]}
-    assert driver_report.validate("reviewer", str(path), {**context, "round": 0}) == []
-    assert driver_report.validate("reviewer", str(path), {**context, "round": 1}) == [
+    assert driver_report.validate("reviewer", str(path), context) == []
+    assert driver_report.validate("reviewer", str(path), {**context, "full": True}) == [
         "mutations: no mutation proof for the locked test file tests/a.py",
         "mutations: no mutation proof for the locked test file tests/b.py"]
-    assert driver_report.validate("correctness", str(path), {**context, "round": 0}) == []
+    assert driver_report.validate("correctness", str(path), context) == []
 
 
 def test_a_timed_out_read_only_role_is_restored_only_when_no_other_agent_is_in_the_slot(tmp_path):

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

@@ -1,7 +1,7 @@
 """Report validation acceptance tests, through driver_report.validate only.
 
 context is a dict: repo (slot path), branch, start (HEAD sha when the role started),
-log (the agent's log file), round (fix-loop round, default 0).
+log (the agent's log file), full (a full review of the reviewer).
 """
 import json
 import subprocess
@@ -45,7 +45,7 @@ def world(tmp_path):
     def check(role, report, **context):
         path = tmp_path / f"{role}-0.json"
         path.write_text(report if isinstance(report, str) else json.dumps(report))
-        ctx = {"repo": str(root), "branch": "ticket/01", "log": str(tmp_path / "agent.log"), "round": 0}
+        ctx = {"repo": str(root), "branch": "ticket/01", "log": str(tmp_path / "agent.log")}
         return validate(role, str(path), {**ctx, **context})
     return shas, check, tmp_path
 
@@ -151,12 +151,12 @@ def test_red_line_absent_from_the_log_is_a_violation(world):
 
 def test_reviewer_fields_and_mutation_proofs(world):
     shas, check, _ = world
-    assert check("reviewer", reviewer(), start=shas["impl"], round=1) == []
+    assert check("reviewer", reviewer(), start=shas["impl"], full=True) == []
     assert any("severity" in e for e in check("reviewer", reviewer(findings=[finding(severity="huge")]),
                                               start=shas["impl"]))
     assert any("kind" in e for e in check("reviewer", reviewer(findings=[finding(kind="style")]), start=shas["impl"]))
     no_proof = reviewer()
     del no_proof["mutations"]
-    assert any("mutations" in e for e in check("reviewer", no_proof, start=shas["impl"], round=1))
+    assert any("mutations" in e for e in check("reviewer", no_proof, start=shas["impl"], full=True))
     fake = reviewer(mutations=[{"test": "t", "file": "demo/export.py", "line": 2, "red": "never ran"}])
-    assert any("not found in log" in e for e in check("reviewer", fake, start=shas["impl"], round=1))
+    assert any("not found in log" in e for e in check("reviewer", fake, start=shas["impl"], full=True))

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-17T15:47:59.977Z",
+  "generatedAt": "2026-10-17T23:11:17.693Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.22",
-      "hash": "sha256-66e2dec93c2b4ca09e8ca6693307e5e92f46fe1bd9b0a44379e7d4a4bd82d3f9",
+      "version": "0.1.24",
+      "hash": "sha256-8df47be43b54ab8ced155594ab3dfa0c23a27960597774d7868ca4e444ab817a",
       "description": "Implement a specification in code."
     },
     {