@jesdi/skills 0.0.30 → 0.0.31

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

@@ -0,0 +1,162 @@
+"""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).
+"""
+import json
+import subprocess
+
+import pytest
+
+from driver_report import validate
+
+GIT = ["git", "-c", "user.name=t", "-c", "user.email=t@example.com", "-c", "commit.gpgsign=false"]
+RED = "FAILED tests/test_export.py::test_rows - AttributeError"
+MUTATION = "FAILED tests/test_export.py::test_rows after breaking demo/export.py:2"
+
+
+def git(root, *args):
+    return subprocess.run([*GIT, *args], cwd=root, check=True, capture_output=True, text=True).stdout.strip()
+
+
+def commit(root, path, text):
+    (root / path).parent.mkdir(parents=True, exist_ok=True)
+    (root / path).write_text(text)
+    git(root, "add", "-A")
+    git(root, "commit", "-q", "-m", f"edit {path}")
+    return git(root, "rev-parse", "HEAD")
+
+
+@pytest.fixture
+def world(tmp_path):
+    """main: base. ticket/01: base -> tests (test-writer) -> impl. other: base -> stray."""
+    root = tmp_path / "slot"
+    root.mkdir()
+    git(root, "init", "-q", "-b", "main")
+    base = commit(root, "demo/export.py", "def export_csv():\n    return ''\n")
+    git(root, "checkout", "-q", "-b", "other")
+    stray = commit(root, "stray.txt", "x\n")
+    git(root, "checkout", "-q", "-b", "ticket/01", "main")
+    tests = commit(root, "tests/test_export.py", "def test_rows():\n    assert False\n")
+    impl = commit(root, "demo/export.py", "def export_csv():\n    return 'rows'\n")
+    (tmp_path / "agent.log").write_text(f"collected 1 item\n{RED}\n{MUTATION}\n")
+    shas = dict(base=base, stray=stray, tests=tests, impl=impl)
+
+    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}
+        return validate(role, str(path), {**ctx, **context})
+    return shas, check, tmp_path
+
+
+def common(**changes):
+    return {"status": "DONE", "commits": [], "files": [], "concerns": [], **changes}
+
+
+def writer(shas, **changes):
+    return common(**{"commits": [shas["tests"]], "files": ["tests/test_export.py"], "locked": ["tests/test_export.py"],
+                     "red": [{"test": "tests/test_export.py::test_rows", "line": RED}], **changes})
+
+
+def implementer(shas, **changes):
+    return common(**{"commits": [shas["impl"]], "files": ["demo/export.py"], "green": ["1 passed"], **changes})
+
+
+def finding(**changes):
+    return {"severity": "minor", "file": "demo/export.py", "line": 2, "title": "t", "evidence": "e", "kind": "code",
+            **changes}
+
+
+def reviewer(**changes):
+    return common(**{"findings": [finding()], "mutations": [
+        {"test": "tests/test_export.py::test_rows", "file": "demo/export.py", "line": 2, "red": MUTATION}], **changes})
+
+
+def test_valid_reports_pass_and_unknown_status_is_named(world):
+    shas, check, _ = world
+    assert check("test-writer", writer(shas), start=shas["base"]) == []
+    assert check("implementer", implementer(shas), start=shas["tests"]) == []
+    assert check("reviewer", reviewer(), start=shas["impl"]) == []
+    errors = check("implementer", implementer(shas, status="FINISHED"), start=shas["tests"])
+    assert errors and any("status" in e and "FINISHED" in e for e in errors)
+
+
+@pytest.mark.parametrize("field", ["status", "commits", "files", "concerns"])
+def test_missing_common_field_is_named(world, field):
+    shas, check, _ = world
+    assert check("implementer", implementer(shas), start=shas["tests"]) == []
+    report = implementer(shas)
+    del report[field]
+    assert any(field in e for e in check("implementer", report, start=shas["tests"]))
+
+
+@pytest.mark.parametrize("role, field", [("test-writer", "locked"), ("test-writer", "red"), ("implementer", "green")])
+def test_missing_role_field_is_named(world, role, field):
+    shas, check, _ = world
+    report = writer(shas) if role == "test-writer" else implementer(shas)
+    start = shas["base"] if role == "test-writer" else shas["tests"]
+    assert check(role, report, start=start) == []
+    del report[field]
+    assert any(field in e for e in check(role, report, start=start))
+
+
+@pytest.mark.parametrize("path", ["missing", "empty", "not json"])
+def test_unusable_report_is_an_error_not_a_crash(world, path):
+    shas, check, tmp = world
+    assert check("implementer", implementer(shas), start=shas["tests"]) == []
+    if path == "missing":
+        assert validate("implementer", str(tmp / "nope.json"), {"repo": str(tmp / "slot"), "branch": "ticket/01",
+                                                                 "start": shas["tests"], "log": str(tmp / "agent.log")})
+        return
+    assert check("implementer", "" if path == "empty" else "{oops", start=shas["tests"])
+
+
+def test_commit_off_the_ticket_branch_or_unknown_is_a_violation(world):
+    shas, check, _ = world
+    assert check("implementer", implementer(shas), start=shas["tests"]) == []
+    for sha in (shas["stray"], "0123456789abcdef0123456789abcdef01234567"):
+        errors = check("implementer", implementer(shas, commits=[sha]), start=shas["tests"])
+        assert any(sha[:7] in e for e in errors), errors
+
+
+def test_commit_predating_the_role_start_is_a_violation(world):
+    shas, check, _ = world
+    assert check("implementer", implementer(shas), start=shas["tests"]) == []
+    errors = check("implementer", implementer(shas, commits=[shas["tests"], shas["impl"]]), start=shas["tests"])
+    assert any(shas["tests"][:7] in e for e in errors), errors
+
+
+def test_implementer_without_a_new_commit_is_a_violation(world):
+    shas, check, _ = world
+    assert check("implementer", implementer(shas), start=shas["tests"]) == []
+    assert any("commit" in e for e in check("implementer", implementer(shas, commits=[]), start=shas["tests"]))
+    assert check("implementer", implementer(shas), start=shas["impl"])  # its only commit is not new
+
+
+def test_locked_path_absent_from_the_commit_is_a_violation(world):
+    shas, check, _ = world
+    assert check("test-writer", writer(shas), start=shas["base"]) == []
+    errors = check("test-writer", writer(shas, locked=["tests/test_export.py", "tests/test_other.py"]),
+                   start=shas["base"])
+    assert any("tests/test_other.py" in e for e in errors), errors
+
+
+def test_red_line_absent_from_the_log_is_a_violation(world):
+    shas, check, _ = world
+    assert check("test-writer", writer(shas), start=shas["base"]) == []
+    report = writer(shas, red=[{"test": "t", "line": "FAILED tests/test_export.py::test_rows - KeyError"}])
+    assert "red line not found in log" in check("test-writer", report, start=shas["base"])
+
+
+def test_reviewer_fields_and_mutation_proofs(world):
+    shas, check, _ = world
+    assert check("reviewer", reviewer(), start=shas["impl"], round=1) == []
+    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))
+    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))

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

@@ -0,0 +1,338 @@
+"""Ticket 04 acceptance tests: review, correctness pass, fix loop, fixture corrections, conflict agent.
+
+All through `sh run.sh --runner <script>` on the fixture repository (the rig of test_walk). The fake runner also plays
+reviewer, correctness, fixer, conflict and a second test-writer call; a role it has no script for reports nothing wrong.
+
+Interface choices (ticket 04):
+- the runner replaces the CLI, so a model entry is observed in the ledger: the line of a call names its role and entry.
+- a fix round runs the role `fixer` (report `fixer-<round>.json`) on the implementer's model list: entry 0 in rounds
+  1-2, entry 1 in rounds 3-4. `state.json` `round` counts fix rounds only. The review that follows round K writes
+  `reviewer-K.json` (the first review `reviewer-0.json`); a correctness pass writes `correctness-K.json`.
+- `mutations[].test` is `<locked file>::test_x`; a re-review prompt names each mutation proof to repeat as
+  `<file>:<line>`, with the line number it has at the new tip.
+- an installed skill without a sibling `review-diff/correctness.md` makes the driver exit 3 before any agent, and the
+  message names `review-diff/correctness.md`.
+- a second conflict on one merge: the PR branch moved again while the conflict agent worked.
+"""
+import json
+import shutil
+import subprocess
+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
+
+# The fake runner of test_walk plus two hooks: `git` runs before the step's files, `git_after` right after them.
+HOOKED = RUNNER.replace(
+    'for path, text in step.get("files", {}).items():',
+    'for cmd in step.get("git", []):\n    git(*cmd)\nfor path, text in step.get("files", {}).items():', 1).replace(
+    'sys.stdout.write(step.get("stdout", ""))',
+    'for cmd in step.get("git_after", []):\n    git(*cmd)\nsys.stdout.write(step.get("stdout", ""))', 1)
+assert HOOKED.count("git_after") == 1 and HOOKED.count('step.get("git", [])') == 1
+
+ONE = {"01-export-rows.md": ticket("01", "Export rows")}
+RISKY = {"02-quote-fields.md": ticket("02", "Quote fields", risk="persistence")}
+OPUS, FABLE, SOL = "claude-opus-5@medium", "claude-fable-5-1@high", "openai/gpt-sol@medium"
+LONG = "".join(f"v{i} = {i}\n" for i in range(1, 41))
+
+
+class Review(Rig):
+    """The rig of test_walk with the hooked runner and per-test model lists."""
+
+    def __init__(self, tmp, files=ONE, models=None, **kw):
+        super().__init__(tmp, files, **kw)
+        (self.rig / "run-agent").write_text(HOOKED)
+        self.models = models_file(tmp, **(models or {}))
+
+    def led(self, *words):
+        return [l for l in self.ledger() if all(w in l for w in words)]
+
+    def tip(self):
+        return self.walked()  # the tip the walk made: the end of run tidies it away (ticket 08)
+
+    def folder(self, nn="01"):
+        return self.repo / ".agent/implement" / nn
+
+
+def finding(title, severity="important", kind="code", file="demo/export.py", line=99):
+    return dict(severity=severity, file=file, line=line, title=title, evidence=title, kind=kind)
+
+
+def red(nn, line):
+    return f"FAILED tests/test_{nn}.py::test_x - AssertionError at demo/export.py:{line}"
+
+
+def review(nn="01", findings=(), lines=(1,), **extra):
+    """A reviewer step: findings plus a mutation proof per production line, its red line printed to the log."""
+    proofs = [dict(test=f"tests/test_{nn}.py::test_x", file="demo/export.py", line=n, red=red(nn, n)) for n in lines]
+    report = dict(status="DONE", commits=[], files=[], concerns=[], findings=list(findings), mutations=proofs)
+    return {"stdout": "".join(p["red"] + "\n" for p in proofs), "report": report, **extra}
+
+
+def correct(findings=(), **extra):
+    report = dict(status="DONE", commits=[], files=[], concerns=[], findings=list(findings))
+    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)
+    for key, value in new.items():
+        lines[int(key[1:]) - 1] = value + "\n"
+    return "".join(lines)
+
+
+# ---------------------------------------------------------------- locked-file check
+
+def test_a_changed_locked_file_is_a_critical_finding_that_starts_a_fix_round(tmp_path):
+    rig = Review(tmp_path)
+    locked = tw("01")["files"]
+    cheat = impl("01", files={"demo/export.py": "def fn_01():\n    return '01'\n", "tests/test_01.py": "# edited\n"})
+    steps = plan(**{"01/implementer": [cheat], "01/fixer": [fix("01", 1, files={**locked, "demo/export.py": "x = 1\n"})]})
+    rig.run(steps)
+    assert rig.code == 0, rig.output()
+    (line,) = rig.led("locked file changed: tests/test_01.py")
+    assert "critical" in line.lower()
+    assert len(rig.calls("01", "fixer")) == 1 and rig.state()["tickets"]["01"]["round"] == 1
+    assert git(rig.repo, "show", "feat/csv:tests/test_01.py") == locked["tests/test_01.py"]
+
+
+# ---------------------------------------------------------------- correctness pass
+
+@pytest.fixture(scope="module")
+def pair(tmp_path_factory):
+    """Ticket 02 (Risk: persistence), codex on PATH: reviewer and correctness each wait for the other to start."""
+    rig = Review(tmp_path_factory.mktemp("pair"), RISKY, {"correctness": [SOL, OPUS], "implementer": [OPUS]})
+    steps = plan(**{
+        "02/reviewer": [review("02", [finding("R-MINOR", "minor")], touch=["r"], wait=["c"])],
+        "02/correctness": [correct([finding("C-IMPORTANT")], touch=["c"], wait=["r"])],
+        "02/fixer": [fix("02", 1)]})
+    return rig.run(steps)
+
+
+def test_reviewer_and_correctness_run_at_the_same_time_on_their_models(pair):
+    assert pair.code == 0, pair.output()
+    (r,), (c,) = pair.calls("02", "reviewer")[:1], pair.calls("02", "correctness")[:1]
+    assert r["t0"] < c["t1"] and c["t0"] < r["t1"], "each started before the other ended"
+    assert pair.led("reviewer", OPUS) and pair.led("correctness", "gpt-sol@medium")
+
+
+def test_findings_of_both_reports_are_merged_with_their_severities(pair):
+    assert len(pair.calls("02", "fixer")) == 1, "the important finding of the correctness pass starts a round"
+    assert pair.led("R-MINOR", "minor") and pair.led("C-IMPORTANT", "important")
+    assert pair.state()["tickets"]["02"]["phase"] == "merged"
+
+
+# Ticket 08: the pass is never folded into the reviewer. A correctness entry with no CLI on PATH stops the run at the
+# start: test_amendments.py test_a_correctness_entry_whose_cli_is_not_on_path_stops_the_run_before_any_agent.
+
+def test_an_installed_skill_without_review_diff_fails_clearly_before_any_agent(tmp_path):
+    rig = Review(tmp_path, RISKY)
+    copy = tmp_path / "installed/skills/implement-spec"
+    shutil.copytree(SKILL, copy, ignore=shutil.ignore_patterns("__pycache__", ".pytest_cache", "test_*"))
+    (rig.rig / "plan.json").write_text(json.dumps(plan()))
+    args = ["--tickets", ".agent/tickets", "--gate", str(rig.rig / "gate"), "--spec", "specs/csv/spec.md",
+            "--models", str(rig.models), "--runner", str(rig.rig / "run-agent")]
+    proc = subprocess.run(["sh", str(copy / "run.sh"), *args], cwd=rig.repo, env=rig.env, text=True,
+                          capture_output=True, timeout=120)
+    assert proc.returncode == 3, proc.stdout + proc.stderr
+    assert "review-diff/correctness.md" in proc.stdout + proc.stderr
+    assert not rig.calls() and not (rig.repo / ".agent/implement/summary.md").exists()
+
+
+@pytest.fixture(scope="module")
+def plain(tmp_path_factory):
+    """A ticket without a Risk line whose reviewer reports two minor findings."""
+    rig = Review(tmp_path_factory.mktemp("plain"), ONE, {"correctness": [SOL, OPUS]})
+    return rig.run(plan(**{"01/reviewer": [review("01", [finding("M-ONE", "minor"), finding("M-TWO", "minor")])]}))
+
+
+def test_a_ticket_without_a_risk_line_runs_no_correctness_pass(plain):
+    assert plain.code == 0, plain.output()
+    assert len(plain.calls("01", "reviewer")) == 1 and not plain.calls("01", "correctness")
+    assert not plain.led("folded")
+
+
+def test_a_review_with_only_minor_findings_passes_and_writes_them_to_the_ledger(plain):
+    assert not plain.calls("01", "fixer") and plain.state()["tickets"]["01"]["phase"] == "merged"
+    assert plain.state()["tickets"]["01"]["round"] == 0
+    assert plain.led("M-ONE", "minor") and plain.led("M-TWO", "minor")
+
+
+# ---------------------------------------------------------------- fix loop
+
+STUCK = finding("STUCK")
+
+
+@pytest.fixture(scope="module")
+def escalated(tmp_path_factory):
+    """One important finding survives the re-reviews after rounds 1 and 2; round 3 is clean."""
+    rig = Review(tmp_path_factory.mktemp("esc"), ONE, {"implementer": [OPUS, FABLE]})
+    bad = review("01", [STUCK])
+    return rig.run(plan(**{"01/reviewer": [bad, bad, bad, review("01")],
+                           "01/fixer": [fix("01", n) for n in (1, 2, 3)]}))
+
+
+def test_round_3_starts_a_fresh_implementer_on_the_next_model(escalated):
+    assert escalated.code == 0, escalated.output()
+    assert escalated.led("01 round 3: escalated to claude-fable-5-1@high")
+    assert not escalated.led("round 1: escalated") and not escalated.led("round 2: escalated")
+    assert len(escalated.led("fixer", OPUS)) == 2 and len(escalated.led("fixer", FABLE)) == 1
+    assert escalated.state()["tickets"]["01"]["round"] == 3
+
+
+def test_each_round_ends_with_one_gate_record_and_a_re_review_scoped_to_the_fix(escalated):
+    tips = [escalated.sha("01", "implementer")] + [c["sha"] for c in escalated.calls("01", "fixer")]
+    commits = [g["commit"] for g in escalated.gates()]
+    assert len(tips) == 4 and all(commits.count(t) == 1 for t in tips), commits
+    assert all((escalated.folder() / f"gate-{t[:7]}.log").exists() for t in tips)
+    reviews = escalated.calls("01", "reviewer")
+    assert len(reviews) == 4
+    for k in (1, 2, 3):
+        assert tips[k - 1][:7] in reviews[k]["prompt"] and tips[k][:7] in reviews[k]["prompt"], k
+
+
+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
+
+
+@pytest.fixture(scope="module")
+def capped(tmp_path_factory):
+    """The three-ticket default; 01's reviewer keeps the same finding through round 4."""
+    rig = Review(tmp_path_factory.mktemp("cap"), three(), {"implementer": [OPUS, FABLE]})
+    return rig.run(plan(**{"01/reviewer": [review("01", [STUCK])] * 5,
+                           "01/fixer": [fix("01", n) for n in (1, 2, 3, 4)]}))
+
+
+def test_a_finding_open_after_round_4_blocks_the_ticket_and_the_run_goes_on(capped):
+    assert capped.code == 1, capped.output()
+    assert capped.led("01", "BLOCKED", "STUCK")
+    assert len(capped.calls("01", "fixer")) == 4 and len(capped.calls("01", "reviewer")) == 5
+    assert not capped.calls("02"), "02 is blocked by 01"
+    assert capped.state()["tickets"]["01"]["phase"] == "blocked"
+    assert capped.state()["tickets"]["03"]["phase"] == "merged" and "feat: 03 rows" in capped.pr_subjects()
+
+
+# ---------------------------------------------------------------- fixture correction
+
+def test_a_fixture_finding_runs_one_test_writer_correction_outside_the_rounds(tmp_path):
+    rig = Review(tmp_path)
+    new = "def test_x():\n    assert '01' == 'x'\n"
+    correction = {**tw("01"), "files": {"tests/test_01.py": new}, "commit": "test: 01 fixture fix"}
+    stale = finding("STALEMARK stale path", file="tests/test_01.py", kind="fixture", line=1)
+    rig.run(plan(**{"01/test-writer": [tw("01"), correction], "01/reviewer": [review("01", [stale])]}))
+    assert rig.code == 0, rig.output()
+    assert len(rig.calls("01", "test-writer")) == 2 and not rig.calls("01", "fixer")
+    assert rig.led("tests/test_01.py", "STALEMARK")
+    assert rig.state()["tickets"]["01"]["round"] == 0 and rig.state()["tickets"]["01"]["phase"] == "merged"
+    assert git(rig.repo, "show", "feat/csv:tests/test_01.py") == new
+
+
+# ---------------------------------------------------------------- mutation proofs
+
+def scoped(tmp, lines, fixes, last_lines):
+    """01's implementer writes 40 lines; the reviewer proves `lines`; each fix replaces the file."""
+    rig = Review(tmp)
+    bad = review("01", [STUCK], lines=lines)
+    reviews = [bad] * len(fixes) + [review("01", lines=last_lines)]
+    rig.run(plan(**{"01/implementer": [impl("01", text=LONG)], "01/reviewer": reviews,
+                    "01/fixer": [fix("01", n, text=t) for n, t in enumerate(fixes, 1)]}))
+    return rig
+
+
+def test_a_re_review_asks_the_mutation_proof_only_for_the_lines_the_fix_changed(tmp_path):
+    first = edit(LONG, l12="v12 = 'a'", l30="v30 = 'a'")
+    rig = scoped(tmp_path, (12, 30), [first, edit(first, l30="v30 = 'b'")], (30,))
+    assert rig.code == 0, rig.output()
+    after1, after2 = (c["prompt"] for c in rig.calls("01", "reviewer")[1:])
+    assert "demo/export.py:12" in after1 and "demo/export.py:30" in after1
+    assert "demo/export.py:30" in after2 and "demo/export.py:12" not in after2
+
+
+def test_a_mutation_proof_follows_its_production_line_when_a_fix_moves_it(tmp_path):
+    lines = LONG.splitlines(keepends=True)
+    moved = "".join(lines[:19] + ["i1 = 1\n", "i2 = 2\n"] + lines[19:29] + ["v30 = 'changed'\n"] + lines[30:])
+    rig = scoped(tmp_path, (12, 30, 35), [moved], (32,))
+    assert rig.code == 0, rig.output()
+    prompt = rig.calls("01", "reviewer")[1]["prompt"]
+    assert "demo/export.py:32" in prompt, "line 30 is line 32 after two inserted lines"
+    for gone in (":30", ":12", ":35", ":37"):  # the old number, and the lines that did not change
+        assert f"demo/export.py{gone}" not in prompt, gone
+
+
+def test_a_first_review_without_a_mutation_for_a_locked_test_is_a_violation(tmp_path):
+    rig = Review(tmp_path)
+    rig.run(plan(**{"01/reviewer": [review("01", lines=()), review("01")]}))
+    assert rig.code == 0, rig.output()
+    first, second = rig.calls("01", "reviewer")
+    appended = second["prompt"].replace(first["prompt"].strip(), "")
+    assert first["prompt"].strip() in second["prompt"] and "tests/test_01.py" in appended
+    assert "mutation" in appended.lower()
+
+
+@pytest.mark.parametrize("second_matches", [True, False])
+def test_a_red_line_missing_from_the_reviewer_log_reruns_once_then_blocks(tmp_path, second_matches):
+    rig = Review(tmp_path)
+    bad = review("01")
+    bad["report"]["mutations"][0]["red"] = "NEVER PRINTED"
+    rig.run(plan(**{"01/reviewer": [bad, review("01") if second_matches else bad]}))
+    first, second = rig.calls("01", "reviewer")
+    assert "red line not found in log" in second["prompt"] and "red line not found" not in first["prompt"]
+    assert rig.code == (0 if second_matches else 1), rig.output()
+    assert len(rig.calls("01", "reviewer")) == 2
+    if not second_matches:
+        assert rig.led("01", "BLOCKED") and "feat: 01 rows" not in rig.pr_subjects()
+
+
+# ---------------------------------------------------------------- conflict agent
+
+def cli(text):
+    return f"def main():\n    return {text!r}\n"
+
+
+def conflicted(tmp, moves_again=False):
+    """01 and 03 both add demo/cli.py; 03 merges first, so 01's merge conflicts."""
+    rig = Review(tmp, {k: v for k, v in three().items() if not k.startswith("02")})
+    resolve = {"files": {"demo/cli.py": cli("resolved")}, "commit": "merge: resolve cli",
+               "report": {"status": "DONE", "commits": ["$SHA"], "files": ["demo/cli.py"], "concerns": []}}
+    if moves_again:  # while the agent works, another commit lands on the PR branch and changes the same file
+        third = str(tmp / "third")
+        resolve["git"] = [["worktree", "add", "--detach", third, "feat/csv"]]
+        resolve["files"][third + "/demo/cli.py"] = cli("third")
+        resolve["git_after"] = [["-C", third, "add", "-A"], ["-C", third, "commit", "-q", "-m", "feat: third"],
+                                ["-C", third, "branch", "-f", "feat/csv", "HEAD"],
+                                ["worktree", "remove", "--force", third]]
+    one = impl("01", files={"demo/export.py": "def fn_01():\n    return '01'\n", "demo/cli.py": cli("one")})
+    return rig.run(plan(**{
+        "01/test-writer": [{**tw("01"), "touch": ["s1"]}],
+        "03/implementer": [{**impl("03", "demo/cli.py", cli("three")), "wait": ["s1"]}],
+        "01/implementer": [{**one, "wait_pr_moves": True}],
+        "01/conflict": [resolve]}))
+
+
+def test_a_conflicting_merge_runs_the_conflict_agent_once_then_the_gate_on_the_merge_commit(tmp_path):
+    rig = conflicted(tmp_path)
+    assert rig.code == 0, rig.output()
+    (call,) = rig.calls("01", "conflict")
+    assert call["cwd"] == rig.calls("01", "implementer")[0]["cwd"], "in the ticket's slot"
+    assert rig.tip() in [g["commit"] for g in rig.gates()], "the merge commit is gated"
+    assert git(rig.repo, "show", "feat/csv:demo/cli.py") == cli("resolved")
+    assert rig.led("demo/cli.py", "onflict")
+
+
+def test_a_second_conflict_on_the_same_merge_blocks_the_ticket(tmp_path):
+    rig = conflicted(tmp_path, moves_again=True)
+    assert rig.code == 1, rig.output()
+    assert len(rig.calls("01", "conflict")) == 1
+    assert rig.led("01", "BLOCKED") and rig.state()["tickets"]["01"]["phase"] == "blocked"
+    assert rig.state()["tickets"]["03"]["phase"] == "merged"

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

@@ -0,0 +1,67 @@
+"""Ticket 05 acceptance tests for `driver_review_page.render(decisions) -> html`.
+
+Interface choice: `decisions` is the dict of decisions.json (`revision`, `questions[]` with `id`, `title`, `why`,
+`evidence` (list of strings), `options` (list of `{id, description}`), `recommended` (an option id)); the result is the
+whole page as a string. The checks are only those that skills/review-page/SKILL.md and schema.md state.
+"""
+import re
+from pathlib import Path
+
+import driver_review_page
+
+REVIEW_PAGE = Path(__file__).resolve().parents[2] / "review-page"
+TEMPLATE = (REVIEW_PAGE / "template.html").read_text()
+ID = re.compile(r"[a-z0-9_-]{1,64}")
+WHAT = "<b>&\"quoted\"</b>"
+
+
+def question(qid, options, recommended, title=None):
+    return {"id": qid, "title": title or f"Title of {qid}", "why": f"Why {qid} matters",
+            "evidence": [".agent/implement/01/implementer.json", ".agent/implement/ledger.md:3"],
+            "options": [{"id": o, "description": f"Trade-off of {o}"} for o in options], "recommended": recommended}
+
+
+DECISIONS = {"revision": "ab" * 32, "questions": [
+    question("01-locked-test-1", ["overrule-test", "overrule-implementer"], "overrule-implementer"),
+    question("02-finding-1", ["accept", "split", "redesign", "other"], "split", title=WHAT)]}
+
+
+def blocks(html):
+    """(data-q value, block html) per question block, in page order."""
+    return re.findall(r'<div class="q" data-q="([^"]*)">(.*?)</textarea>', html, re.S)
+
+
+def check_page(html, decisions):
+    """Every check the review-page skill states, for a page in questionnaire mode."""
+    questions = decisions["questions"]
+    assert 'name="agent-ops-review"' in html and 'content="1"' in html, "the dispatcher looks for the marker"
+    assert '<body data-mode="questionnaire"' in html
+    assert html.count('data-q="') == len(questions) == len(blocks(html)), "one data-q block per question"
+    for style_or_script in re.findall(r"<(?:style|script)>.*?</(?:style|script)>", TEMPLATE, re.S):
+        assert style_or_script in html, "script and CSS are never edited"
+    for slot in ("tickets", "questions", "corrections", "track"):
+        assert f'<section data-slot="{slot}">' in html, "the wrappers stay"
+    for forbidden in ("<link", "src=", "http:", "https:", "<button", 'data-q="track"', 'data-q="format"'):
+        assert forbidden not in html, forbidden
+    for (qid, block), want in zip(blocks(html), questions):
+        assert qid == want["id"] and ID.fullmatch(qid), qid
+        assert f'id="note-{qid}"' in block and 'id="state"' not in block, "the script owns id state"
+        radios = re.findall(r'<input type="radio" name="([^"]*)" value="([^"]*)"', block)
+        assert radios == [(qid, o["id"]) for o in want["options"]], "name is the question id, value is the option id"
+        labels = block.split('<label class="opt">')[1:]
+        recommended = [i for i, label in enumerate(labels) if "chip rec" in label]
+        assert block.count("chip rec") == 1 and len(recommended) == 1, "exactly one recommended option"
+        assert f'value="{want["recommended"]}"' in labels[recommended[0]]
+
+
+def test_the_page_carries_the_marker_questionnaire_mode_and_one_block_per_question():
+    check_page(driver_review_page.render(DECISIONS), DECISIONS)
+
+
+def test_titles_whys_and_descriptions_show_up_and_markup_in_them_is_escaped():
+    html = driver_review_page.render(DECISIONS)
+    for want in DECISIONS["questions"]:
+        assert f"Why {want['id']} matters" in html
+        assert all(f"Trade-off of {o['id']}" in html for o in want["options"])
+    assert "Title of 01-locked-test-1" in html
+    assert WHAT not in html and "&lt;b&gt;" in html, "a title is text, never markup"

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

@@ -0,0 +1,32 @@
+"""Slots 2..N: created once, prepared once, reused only when clean."""
+import subprocess
+
+import driver_slots
+
+
+def test_a_slot_is_created_and_prepared_once_then_reused_off_any_branch(repo, tmp_path):
+    repo()
+    log = tmp_path.parent / f"{tmp_path.name}-prepare.log"
+    assert driver_slots.setup(3, f"pwd >> {log}") == []
+    assert len(log.read_text().splitlines()) == 2 and driver_slots.path(1) == "."
+    slot = driver_slots.path(3)
+    subprocess.run(["git", "-C", slot, "checkout", "-q", "-b", "ticket/07"], check=True)
+    assert driver_slots.setup(3, f"pwd >> {log}") == [] and len(log.read_text().splitlines()) == 2
+    assert driver_slots.git(slot, "symbolic-ref", "-q", "HEAD").returncode != 0  # detached: the branch is free
+
+
+def test_a_slot_with_uncommitted_work_stops_the_run_and_keeps_the_work(repo, tmp_path):
+    repo()
+    assert driver_slots.setup(2, None) == []
+    (tmp_path / ".agent/worktrees/slot-2/wip.txt").write_text("half done\n")
+    assert driver_slots.setup(3, None) == [
+        "slot 2: .agent/worktrees/slot-2 has uncommitted changes: commit or discard them"]
+    assert (tmp_path / ".agent/worktrees/slot-2/wip.txt").exists() and not (tmp_path / ".agent/worktrees/slot-3").exists()
+
+
+def test_a_slot_that_cannot_be_created_is_an_error(repo, tmp_path):
+    repo()
+    (tmp_path / ".agent/worktrees").mkdir(parents=True)
+    (tmp_path / ".agent/worktrees/slot-2").write_text("a file is in the way\n")
+    (error,) = driver_slots.setup(2, None)
+    assert error.startswith("slot 2: cannot create .agent/worktrees/slot-2: ")