@jesdi/skills 0.0.30 → 0.0.31

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

@@ -0,0 +1,358 @@
+"""Agent launch acceptance tests, through `sh run.sh` with a fake runner script or fake claude/codex on PATH.
+
+Interface choices (ticket 02): `--runner <script>` is called as `<script> <role> <prompt> <report>` in the slot
+directory. A plain run (no --dry-run) branches ticket/NN from the PR tip in slot 1, runs the test-writer (unless the
+Seam is `none — refactor`) then the implementer; from ticket 03 on an accepted ticket goes on to the driver's gate (`true` here) and a
+merge into the PR branch, which deletes `ticket/NN`. Exit 0 when the ticket merges, 1 on BLOCKED.
+`--only <role>` runs that one role on the first ticket and stops. `--spec <path>` names the spec for the prompts.
+`--timeout <role>=<minutes>` (repeatable, fractions allowed) overrides a role timeout.
+Ticket 08: the fixture has no `origin`, and a run that merges its ticket ends with the tidy and the final review, so
+`ticket_commits()` reads the ticket's commits from `refs/implement/recovery`, the PR tip from before the tidy.
+"""
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from test_cli import GIT, ROLES, RUN, SKILL, TOOLS, drive, git, make_repo, models_file, ticket
+
+RED = "FAILED tests/test_export.py::test_rows - AttributeError"
+RUNNER = f"""#!{sys.executable}
+import json, os, subprocess, sys, time
+from pathlib import Path
+here = Path(__file__).resolve().parent
+role, prompt, report = sys.argv[1:4]
+def git(*a):
+    cmd = ["git", "-c", "user.name=t", "-c", "user.email=t@example.com", "-c", "commit.gpgsign=false", *a]
+    return subprocess.run(cmd, capture_output=True, text=True).stdout.strip()
+calls = here / "calls.jsonl"
+past = [json.loads(l) for l in calls.read_text().splitlines()] if calls.exists() else []
+n = sum(1 for c in past if c["role"] == role)
+rec = dict(role=role, argv=sys.argv[1:], cwd=os.path.realpath(os.getcwd()), prompt=Path(prompt).read_text(),
+           branch=git("rev-parse", "--abbrev-ref", "HEAD"), head=git("rev-parse", "HEAD"),
+           status=git("status", "--porcelain"))
+with calls.open("a") as f:
+    f.write(json.dumps(rec) + "\\n")
+plan = json.loads((here / "plan.json").read_text()).get(role, [])
+step = plan[n] if n < len(plan) else {{}}
+if role in ("reviewer", "correctness", "final-reviewer") and "report" not in step:  # a role the test does not script reports no findings
+    reds = [f"FAILED {{p}}::test_x - AttributeError" for p in git("diff", "--name-only", "feat/csv...HEAD", "--", "tests").split()]
+    proofs = [dict(test=r.split()[1], file="demo/export.py", line=1, red=r) for r in reds]
+    step = dict(step, stdout="".join(r + "\\n" for r in reds), report=dict(
+        status="DONE", commits=[], files=[], concerns=[], findings=[], mutations=proofs))
+for cmd in step.get("git", []):
+    git(*cmd)
+for path, text in step.get("files", {{}}).items():
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    Path(path).write_text(text)
+sys.stdout.write(step.get("stdout", ""))
+sys.stderr.write(step.get("stderr", ""))
+sys.stdout.flush()
+sys.stderr.flush()
+time.sleep(step.get("sleep", 0))
+sha = ""
+if "commit" in step:
+    git("add", "-A")
+    git("commit", "-q", "-m", step["commit"])
+    sha = git("rev-parse", "HEAD")
+if step.get("report") is not None:
+    Path(report).parent.mkdir(parents=True, exist_ok=True)
+    Path(report).write_text(json.dumps(step["report"]).replace("$SHA", sha))
+sys.exit(step.get("exit", 0))
+"""
+
+
+@pytest.fixture
+def env(tmp_path):
+    """A restricted PATH whose fake claude and codex append their argv (NUL-separated) and exit 1."""
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    for name in TOOLS:
+        if shutil.which(name):
+            (bin_dir / name).symlink_to(shutil.which(name))
+    for cli in ("claude", "codex"):
+        log = f'"{tmp_path}/argv-{cli}"'
+        (bin_dir / cli).write_text(f"#!/bin/sh\nprintf '%s\\0' \"$@\" >> {log}\nprintf '\\036' >> {log}\nexit 1\n")
+        (bin_dir / cli).chmod(0o755)
+    return dict(os.environ, PATH=str(bin_dir)), tmp_path
+
+
+def launches(tmp_path, cli):
+    path = tmp_path / f"argv-{cli}"
+    records = path.read_bytes().decode().split("\x1e")[:-1] if path.exists() else []
+    return [record.split("\0")[:-1] for record in records]
+
+
+def value_after(argv, *flags):
+    return next((argv[i + 1] for i, arg in enumerate(argv[:-1]) if arg in flags), None)
+
+
+class World:
+    def __init__(self, env, *, refactor=False, **models):
+        self.env, self.tmp = env, env[1]
+        seam = {"seam": "none — refactor", "criteria": ()} if refactor else {}
+        self.repo = make_repo(self.tmp / "demo", {"01-export-rows.md": ticket("01", "Export rows", **seam)})
+        (self.repo / "specs/csv").mkdir(parents=True)
+        (self.repo / "specs/csv/spec.md").write_text("# csv spec\n")
+        git(self.repo, "add", "specs")
+        git(self.repo, "commit", "-q", "-m", "spec")
+        self.base = git(self.repo, "rev-parse", "HEAD").strip()
+        self.models = models_file(self.tmp, **models)
+        self.runner = self.tmp / "runner/run-agent"
+        self.runner.parent.mkdir()
+        self.runner.write_text(RUNNER)
+        self.runner.chmod(0o755)
+
+    def run(self, plan=None, *extra, runner=True):
+        (self.runner.parent / "plan.json").write_text(json.dumps(plan or {}))
+        args = ["--tickets", ".agent/tickets", "--gate", "true", "--spec", "specs/csv/spec.md",
+                "--models", str(self.models), *(["--runner", str(self.runner)] if runner else []), *extra]
+        return drive(self.env, self.repo, *args)
+
+    def calls(self, role):
+        path = self.runner.parent / "calls.jsonl"
+        rows = [json.loads(line) for line in path.read_text().splitlines()] if path.exists() else []
+        return [row for row in rows if row["role"] == role]
+
+    def ledger(self):
+        path = self.repo / ".agent/implement/ledger.md"
+        return path.read_text() if path.exists() else ""
+
+    def ticket_commits(self):
+        made = subprocess.run(["git", "rev-parse", "--verify", "-q", "refs/implement/recovery"], cwd=self.repo,
+                              capture_output=True, text=True).stdout.strip() or "feat/csv"
+        return git(self.repo, "rev-list", "--reverse", "--no-merges", f"{self.base}..{made}").split()
+
+
+def ok(proc):
+    assert proc.returncode == 0, proc.stdout + proc.stderr
+
+
+def blocked(proc):
+    assert proc.returncode == 1, proc.stdout + proc.stderr
+
+
+def tw(n=0, stdout=RED + "\n", **changes):
+    step = {"files": {"tests/test_export.py": f"def test_rows():\n    assert {n} == 'rows'\n"},
+            "stdout": stdout, "commit": "test: red",
+            "report": {"status": "DONE", "commits": ["$SHA"], "files": ["tests/test_export.py"], "concerns": [],
+                       "locked": ["tests/test_export.py"],
+                       "red": [{"test": "tests/test_export.py::test_rows", "line": RED}]}}
+    return {**step, **changes}
+
+
+def impl(n=0, **changes):
+    step = {"files": {"demo/export.py": f"def export_csv():\n    return 'rows{n}'\n"}, "commit": "feat: rows",
+            "report": {"status": "DONE", "commits": ["$SHA"], "files": ["demo/export.py"], "concerns": [],
+                       "green": ["1 passed"]}}
+    return {**step, **changes}
+
+
+def with_report(step, **changes):
+    return {**step, "report": {**step["report"], **changes}}
+
+
+def test_runner_is_called_with_role_prompt_report_in_the_slot_directory(env):
+    w = World(env, refactor=True)
+    ok(w.run({"implementer": [impl()]}))
+    (call,) = w.calls("implementer")
+    role, prompt, report = call["argv"]
+    assert role == "implementer" and call["prompt"].strip()
+    assert Path(call["cwd"], report).resolve().as_posix().endswith(".agent/implement/01/implementer-0.json")
+    assert Path(call["cwd"], report).exists()
+    assert call["cwd"] == str(w.repo.resolve()) and call["branch"] == "ticket/01"
+
+
+def test_default_models_file_names_every_role():
+    models = json.loads((SKILL / "models.json").read_text())
+    assert set(models) == set(ROLES) and all(models[role] for role in ROLES)
+
+
+def test_help_lists_the_timeout_flag_and_default_minutes():
+    proc = subprocess.run(["sh", str(RUN), "--help"], capture_output=True, text=True)
+    assert "--timeout" in proc.stdout and re.search(r"implementer\W+90", proc.stdout), proc.stdout
+
+
+@pytest.mark.parametrize("entry", ["openai/gpt-sol@medium"])
+def test_openai_implementer_launches_codex_exec_in_workspace_write(env, entry):
+    # ticket 08: the correctness list needs an entry on another provider than the implementer's
+    w = World(env, refactor=True, implementer=[entry], correctness=["claude-opus-5@medium"])
+    w.run(runner=False)
+    argv = launches(w.tmp, "codex")[0]
+    assert argv[0] == "exec" and "--ephemeral" not in argv
+    assert value_after(argv, "--model", "-m") == "gpt-sol"
+    assert any("model_reasoning_effort" in a and "medium" in a for a in argv)
+    assert value_after(argv, "--sandbox", "-s") == "workspace-write"
+    assert not launches(w.tmp, "claude")
+
+
+@pytest.mark.parametrize("role", ["reviewer", "correctness"])
+def test_reviewing_roles_launch_codex_exec_read_only(env, role):
+    w = World(env, refactor=True, **{role: ["openai/gpt-sol@medium"]})
+    w.run(None, "--only", role, runner=False)
+    argv = launches(w.tmp, "codex")[0]
+    assert argv[0] == "exec" and "--ephemeral" not in argv
+    assert value_after(argv, "--sandbox", "-s") == "read-only"
+    assert value_after(argv, "--model", "-m") == "gpt-sol"
+
+
+@pytest.mark.parametrize("entry", ["claude-opus-5@medium", "anthropic/claude-opus-5@medium"])
+def test_claude_entry_launches_claude_p_and_bare_means_anthropic(env, entry):
+    w = World(env, refactor=True, implementer=[entry])
+    w.run(runner=False)
+    argv = launches(w.tmp, "claude")[0]
+    assert ("-p" in argv or "--print" in argv)
+    assert value_after(argv, "--model") == "claude-opus-5"
+    assert value_after(argv, "--effort") == "medium"
+    assert not launches(w.tmp, "codex")
+
+
+@pytest.mark.parametrize("entry", ["mystery/model@medium", "anthropic/claude-opus-5@turbo", "openai/gpt-sol@turbo"])
+def test_unknown_provider_or_effort_exits_3_naming_role_and_entry_before_any_agent(env, entry):
+    w = World(env, reviewer=[entry])
+    proc = drive(w.env, w.repo, "--tickets", ".agent/tickets", "--gate", "true", "--models", str(w.models), "--dry-run")
+    assert proc.returncode == 3, proc.stdout + proc.stderr
+    assert any("reviewer" in l and entry in l for l in proc.stdout.splitlines()), proc.stdout
+    proc = w.run({"test-writer": [tw()]})
+    assert proc.returncode == 3 and not w.calls("test-writer")
+    assert not launches(w.tmp, "claude") and not launches(w.tmp, "codex")
+    assert "ticket/01" not in git(w.repo, "branch", "--list")
+
+
+def test_implementer_prompt_carries_pointers_and_only_template_sentences(env):
+    w = World(env)
+    ok(w.run({"test-writer": [tw()], "implementer": [impl()]}))
+    (call,) = w.calls("implementer")
+    prompt, report = call["prompt"], call["argv"][2]
+    sha = w.ticket_commits()[0]
+    for pointer in ("specs/csv/spec.md", ".agent/tickets/01-export-rows.md", "`export_csv()`", sha,
+                    "tests/test_export.py", report):
+        assert pointer in prompt, pointer
+    template = (SKILL / "prompts/implementer.md").read_text()
+    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"):
+        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))
+
+
+@pytest.mark.parametrize("role, extra, refactor", [
+    ("test-writer", (), False), ("implementer", (), True),
+    ("reviewer", ("--only", "reviewer"), True), ("correctness", ("--only", "correctness"), True)])
+def test_every_prompt_ends_with_report_path_schema_and_the_never_rule(env, role, extra, refactor):
+    w = World(env, refactor=refactor)
+    w.run(None, *extra)
+    call = w.calls(role)[0]
+    prompt, report = call["prompt"].rstrip(), call["argv"][2]
+    last = prompt.splitlines()[-1].lower()
+    assert "never" in last and "stash" in last and "reset" in last and "check out" in last, last
+    assert prompt.rfind(report) < prompt.rfind("DONE_WITH_CONCERNS") < prompt.rfind(prompt.splitlines()[-1])
+    assert report in prompt
+
+
+def test_no_report_is_a_violation_with_one_rerun_then_blocked(env):
+    w = World(env, refactor=True)
+    blocked(w.run({"implementer": [{}, {}, impl()]}))
+    first, second = w.calls("implementer")
+    assert first["prompt"].strip() in second["prompt"] and len(second["prompt"]) > len(first["prompt"])
+    assert "report" in second["prompt"][len(first["prompt"].rstrip()):].lower()
+    assert len(w.calls("implementer")) == 2
+    assert any("01" in l and "BLOCKED" in l for l in w.ledger().splitlines()), w.ledger()
+
+
+def test_finished_status_reruns_the_implementer_once_with_the_error_appended(env):
+    w = World(env)
+    ok(w.run({"test-writer": [tw()], "implementer": [with_report(impl(0), status="FINISHED"), impl(1)]}))
+    first, second = w.calls("implementer")
+    assert first["prompt"].strip() in second["prompt"] and "FINISHED" in second["prompt"]
+    assert "FINISHED" not in first["prompt"]
+
+
+def test_second_schema_violation_blocks_the_ticket_with_the_error_in_the_ledger(env):
+    w = World(env)
+    bad = lambda n: with_report(impl(n), status="FINISHED")
+    blocked(w.run({"test-writer": [tw()], "implementer": [bad(0), bad(1), impl(2)]}))
+    assert len(w.calls("implementer")) == 2
+    assert any("01" in l and "BLOCKED" in l and "FINISHED" in l for l in w.ledger().splitlines()), w.ledger()
+
+
+@pytest.mark.parametrize("second_matches", [True, False])
+def test_red_line_missing_from_the_log_reruns_once_then_blocks(env, second_matches):
+    w = World(env)
+    plan = {"test-writer": [tw(0, "no such line\n"), tw(1, RED + "\n" if second_matches else "still none\n")],
+            "implementer": [impl()]}
+    proc = w.run(plan)
+    second = w.calls("test-writer")[1]["prompt"]
+    assert "red line not found in log" in second and "red line not found" not in w.calls("test-writer")[0]["prompt"]
+    if second_matches:
+        ok(proc)
+        assert len(w.calls("implementer")) == 1
+    else:
+        blocked(proc)
+        assert len(w.calls("test-writer")) == 2 and not w.calls("implementer")
+        assert any("01" in l and "BLOCKED" in l for l in w.ledger().splitlines()), w.ledger()
+
+
+def test_implementer_report_with_no_new_commit_is_a_violation(env):
+    w = World(env)
+    nothing = with_report(impl(), commits=[])
+    nothing.pop("commit"), nothing.pop("files")
+    blocked(w.run({"test-writer": [tw()], "implementer": [nothing, nothing]}))
+    assert len(w.calls("implementer")) == 2
+    assert any("01" in l and "BLOCKED" in l and "commit" in l for l in w.ledger().splitlines()), w.ledger()
+
+
+def test_timeout_keeps_the_tree_and_reruns_once_with_double_the_limit(env):
+    w = World(env, refactor=True)
+    hang = {"files": {"wip.txt": "half done\n"}, "sleep": 60}
+    # 0.04 min = 2.4 s: the rerun sleeps 3.6 s, which passes only under the doubled 4.8 s limit.
+    ok(w.run({"implementer": [hang, impl(sleep=3.6)]}, "--timeout", "implementer=0.04"))
+    first, second = w.calls("implementer")
+    assert "wip.txt" in second["status"]
+    prompt = second["prompt"].lower()
+    assert "timed out" in prompt and "in the tree" in prompt and "timed out" not in first["prompt"].lower()
+    assert git(w.repo, "show", "feat/csv:wip.txt") == "half done\n"
+
+
+def test_second_timeout_blocks_the_ticket(env):
+    w = World(env, refactor=True)
+    hang = {"files": {"wip.txt": "half done\n"}, "sleep": 60}
+    blocked(w.run({"implementer": [hang, hang, impl()]}, "--timeout", "implementer=0.04"))
+    assert len(w.calls("implementer")) == 2
+    assert any("BLOCKED" in l and "timed out" in l for l in w.ledger().splitlines()), w.ledger()
+    assert (w.repo / "wip.txt").exists()
+
+
+def test_head_moved_to_the_pr_branch_resets_the_slot_and_reruns_once(env):
+    w = World(env)
+    ok(w.run({"test-writer": [tw()], "implementer": [{"git": [["checkout", "feat/csv"]]}, impl()]}))
+    first, second = w.calls("implementer")
+    tests_sha = w.ticket_commits()[0]
+    assert (second["branch"], second["head"]) == ("ticket/01", tests_sha)
+    assert any("implementer" in l and "feat/csv" in l for l in w.ledger().splitlines()), w.ledger()
+
+
+def test_a_missing_ticket_branch_is_a_violation_named_in_the_ledger(env):
+    w = World(env)
+    gone = {"git": [["checkout", "--detach"], ["branch", "-D", "ticket/01"]]}
+    proc = w.run({"test-writer": [tw()], "implementer": [gone, impl()]})
+    assert "Traceback" not in proc.stderr
+    assert any("ticket/01" in l and "branch" in l for l in w.ledger().splitlines()), w.ledger()
+
+
+def test_log_next_to_report_and_ledger_records_role_entry_duration_and_cost(env):
+    w = World(env, refactor=True, implementer=["claude-opus-5@medium"])
+    step = impl(stdout='OUT-MARK\n{"total_cost_usd": 0.4242}\n', stderr="ERR-MARK\n")
+    ok(w.run({"implementer": [step]}))
+    folder = w.repo / ".agent/implement/01"
+    log = (folder / "implementer-0.log").read_text()
+    assert "OUT-MARK" in log and "ERR-MARK" in log and (folder / "implementer-0.json").exists()
+    (line,) = [l for l in w.ledger().splitlines() if "implementer" in l and "claude-opus-5@medium" in l]
+    assert re.search(r"\d+(\.\d+)?s\b", line) and "0.4242" in line, line

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

@@ -0,0 +1,117 @@
+"""Ticket 08 acceptance tests: a run with no `origin` gets its final review; the correctness CLI is mandatory.
+
+All through `sh run.sh --runner <script> [--push] [--unattended]` on the fixture repository: the rig of test_final
+with and without its bare `origin`, and the rig of test_review with and without the fake `codex` on PATH.
+
+Interface choices (ticket 08):
+- with no `origin`, the tidied commits sit on the commit the PR branch had when the run started (nothing to rebase
+  onto), and `refs/implement/recovery` holds the PR tip from before the tidy, as with an `origin`.
+- the one ledger sentence about the missing remote names `origin` and says that the rebase and the push were skipped.
+- a refused start (exit 3) prints its reason on stdout or stderr: `origin` for a push that has no remote; for the
+  correctness role one line that names `correctness` and `codex`, or `correctness` and each entry of its list.
+"""
+import pytest
+
+from test_cli import git, ticket
+from test_final import Final, ref, stop_lines
+from test_review import FABLE, ONE, OPUS, RISKY, SOL, Review, correct, review
+from test_stops import UNATTENDED
+from test_walk import plan
+
+TWO = {"01-export-rows.md": ticket("01", "Export rows"), "02-quote-fields.md": ticket("02", "Quote fields", "01")}
+
+
+# ---------------------------------------------------------------- no origin
+
+@pytest.fixture(scope="module")
+def bare(tmp_path_factory):
+    """Two tickets in a chain, no `origin`, no `--push`: both merge as fast-forwards, four commits in all."""
+    rig = Final(tmp_path_factory.mktemp("bare"), TWO, remote=False)
+    rig.start = rig.branch()
+    return rig.run(plan())
+
+
+def test_with_no_origin_the_branch_is_tidied_gated_and_reviewed_with_no_rebase_and_no_push(bare):
+    rig = bare
+    assert rig.code == 0, rig.output()
+    tip, recovery = rig.branch(), rig.recovery()
+    assert recovery and len(rig.commits(rig.start, recovery)) == 4, "the commits of the walk are at the recovery point"
+    rows = rig.commits(rig.start)
+    assert [r["subject"] for r in rows] == ["feat(01): Export rows", "feat(02): Quote fields"]
+    assert ref(rig.repo, f"{rows[0]['sha']}~1") == rig.start, "no rebase: the ticket commits sit on the branch's start"
+    assert ref(rig.repo, "feat/csv^{tree}") == ref(rig.repo, "refs/implement/recovery^{tree}")
+    records = sorted(p.name for p in (rig.repo / ".agent/implement/final").glob("gate-*.log"))
+    assert records == [f"gate-{tip[:7]}.log"], records
+    (gate,) = [g for g in rig.gates() if g["commit"] == tip]
+    (call,) = rig.final_calls("final-reviewer")
+    assert call["head"] == tip and gate["t0"] < call["t0"], "the final review reads the gated, tidied tip"
+    assert not rig.final_calls("conflict") and not rig.prs() and git(rig.repo, "remote") == "", "nothing is pushed"
+    branch_tip, reviewed, _ = stop_lines(rig.out)
+    assert branch_tip and reviewed, rig.out
+    assert tip.startswith(branch_tip.group(1)) and tip.startswith(reviewed.group(1))
+
+
+def test_with_no_origin_one_ledger_sentence_says_why_and_the_summary_does_not_deny_the_final_review(bare):
+    (line,) = bare.led("origin")
+    low = line.lower()
+    assert "rebase" in low and "push" in low and "skipped" in low and "no origin" in low, line
+    assert "did not run" not in (bare.repo / ".agent/implement/summary.md").read_text()
+
+
+@pytest.mark.parametrize("flags", [UNATTENDED, ("--push",)], ids=["unattended", "push"])
+def test_a_push_with_no_origin_is_refused_at_the_start_before_any_agent(tmp_path, flags):
+    rig = Final(tmp_path, ONE, remote=False).run(plan(), *flags)
+    assert rig.code == 3, rig.output()
+    assert "origin" in rig.out + rig.err
+    assert not rig.calls() and not rig.gates() and not rig.branches()
+
+
+def test_with_an_origin_the_end_of_run_still_rebases_onto_the_fetched_base_and_pushes(tmp_path):
+    rig = Final(tmp_path, ONE)
+    rig.move_base({"docs.md": "base docs\n"})
+    rig.run(plan(), "--push")
+    assert rig.code == 0, rig.output()
+    git(rig.repo, "merge-base", "--is-ancestor", ref(rig.origin, "refs/heads/main"), "feat/csv")
+    assert rig.pushes() == [f"refs/heads/feat/csv {rig.branch()}"] and len(rig.prs()) == 1
+    assert len(rig.final_calls("final-reviewer")) == 1 and not [l for l in rig.ledger() if "skipped" in l.lower()]
+
+
+# ---------------------------------------------------------------- the correctness CLI
+
+@pytest.mark.parametrize("files", [RISKY, ONE], ids=["risk-line", "no-risk-line"])
+def test_a_correctness_entry_whose_cli_is_not_on_path_stops_the_run_before_any_agent(tmp_path, files):
+    rig = Review(tmp_path, files, {"correctness": [SOL, OPUS], "implementer": [OPUS]})
+    (tmp_path / "bin/codex").unlink()
+    rig.run(plan())
+    assert rig.code == 3, rig.output()
+    assert [l for l in (rig.out + rig.err).splitlines() if "correctness" in l and "codex" in l], rig.output()
+    assert not rig.calls() and not rig.gates()
+
+
+def test_a_correctness_list_all_on_the_implementers_provider_stops_the_run_before_any_agent(tmp_path):
+    rig = Review(tmp_path, RISKY, {"correctness": [OPUS, FABLE], "implementer": [OPUS]})
+    rig.run(plan())
+    assert rig.code == 3, rig.output()
+    assert [l for l in (rig.out + rig.err).splitlines() if "correctness" in l and OPUS in l and FABLE in l], rig.output()
+    assert not rig.calls() and not rig.gates()
+
+
+@pytest.mark.parametrize("entries, codex", [([SOL, OPUS], False), ([OPUS], True)], ids=["no-codex", "one-provider"])
+def test_no_run_folds_the_correctness_pass_into_the_reviewer(tmp_path, entries, codex):
+    rig = Review(tmp_path, RISKY, {"correctness": entries, "implementer": [OPUS]})
+    if not codex:
+        (tmp_path / "bin/codex").unlink()
+    rig.run(plan())
+    assert not [c for c in rig.calls(role="reviewer") if "correctness.md" in c["prompt"]], "a reviewer got the pass"
+    assert not rig.led("folded"), rig.ledger()
+
+
+def test_a_risky_ticket_still_gets_reviewer_and_correctness_together_on_the_entry_of_another_provider(tmp_path):
+    rig = Review(tmp_path, RISKY, {"correctness": [OPUS, SOL], "implementer": [OPUS]})
+    rig.run(plan(**{"02/reviewer": [review("02", touch=["r"], wait=["c"])],
+                    "02/correctness": [correct(touch=["c"], wait=["r"])]}))
+    assert rig.code == 0, rig.output()
+    (r,), (c,) = rig.calls("02", "reviewer"), rig.calls("02", "correctness")
+    assert r["t0"] < c["t1"] and c["t0"] < r["t1"], "each started before the other ended"
+    assert rig.led("correctness", "gpt-sol@medium") and not rig.led("correctness", OPUS)
+    assert "correctness.md" not in r["prompt"] and not rig.led("folded")