@jesdi/skills 0.0.32 → 0.0.34

package/README.md

@@ -144,11 +144,12 @@ them afterwards). `external-skills.json` lists them under `forks`.
 
 ### The box set
 
-`external-skills.json` → `sets.box` names the skills the agent-ops box
-receives: `own` from this package, `external` from the pinned upstream.
-`pr` is in the external set and is installed directly from mattpocock/skills.
-agent-ops vendors that set into its claude-home seed with its own refresh
-command; this repo's job is to publish the set and keep the pins resolvable.
+`external-skills.json` → `sets.box.external` names the third-party skills the
+agent-ops box receives from the pinned upstream. `pr` is in this set and is
+installed directly from mattpocock/skills. agent-ops-infra lists the own skills
+of the box (`provision/my-skills.json`) and pins the commit of this file it
+reads (`provision/external-skills.pin`); this repo's job is to publish the set
+and keep the pins resolvable.
 
 ## Authoring skills
 

package/package.json

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

package/skills/implement-spec/ARCHITECTURE.md

@@ -33,6 +33,10 @@ and do not know about the run, except `driver_run.py`, which the three deciding
 - **A step that cannot go on raises `Blocked`.** The message says why. `with during("the merge"):` puts the step
   in front. Only two places catch it for good: `driver._run_ticket` (the ticket becomes BLOCKED) and
   `driver_final.run` (the end of run becomes BLOCKED). Another `except Blocked` only cleans up and raises again.
+- **A CLI that fails with no report raises `Halted`**, not `Blocked`: the setup of the run is wrong, not the
+  ticket. `driver._run_ticket` and `driver._work` catch it: the run starts no other agent and ends with exit 4,
+  and the ticket keeps its phase for the next run. A cleanup of an `except Blocked` that leaves git as it was (an
+  open merge, an open rebase, a rejected fix batch) also runs for `Halted`.
 - **A check before the first agent returns a list of errors**, so the operator sees all of them at one time
   (exit 3). Examples: `precondition_errors`, `driver_tickets.parse`, `driver_report.validate`.
 - **The modules that do not know about the run return a result, not `Blocked`.** Some return `""` or the reason

package/skills/implement-spec/README.md

@@ -19,6 +19,7 @@ Before any agent starts, the driver checks these. Each failed check prints one l
 - Each model entry is valid, and the CLI of the first entry of each role is on PATH. For the correctness role, the entry is the first of its list on another provider than the first implementer entry: that list must have such an entry, and its CLI must be on PATH. This applies to every run, also when no ticket has a **Risk** line.
 - The `review-diff` skill is installed next to this one: the final review of every run reads it, and so does the correctness pass.
 - With `--push` or `--unattended`, the repository has an `origin` remote.
+- Each model that the run can use answers one short test prompt (the preflight). A model that fails gives one line with its error. `--dry-run` skips the preflight.
 
 A run that stopped is continued with the same command. `state.json` is the only input of a resume.
 
@@ -56,6 +57,7 @@ Default timeouts in minutes: explorer 30, test-writer 30, implementer 90, review
 | 1 | A ticket is BLOCKED, or the end of run is BLOCKED. The other tickets ran as far as they could. |
 | 2 | Parked: a question of kind `locked-test` or `final-finding` is open. Exit 2 wins over exit 1. |
 | 3 | Invalid input or a failed precondition: a usage error, a ticket error, a model error, an uncommitted change, a slot that cannot be made, another driver that runs in the same repository. No agent starts. The one exception: a review page that cannot be written gives exit 3 at the end of a run, after agents ran. |
+| 4 | Stopped: the CLI of an agent failed two times and wrote no report (for example, the account cannot use the model). The driver starts no other agent and lets the running agents end. No ticket is BLOCKED by it: fix the CLI or the model entry, then run the same command again to resume. |
 | 130 | The operator interrupted the run. The driver stops each agent. The work stays in the slots for the next run. |
 
 With `--unattended`, the `--stage-json` file holds `{"stage": "implement", "status": …}`:
@@ -158,7 +160,7 @@ A repository with no `origin` remote skips only step 2 and step 6. The tidied co
 
 The driver uses the first entry of a role. The fixer of a ticket runs on the `implementer` list; the `fixer` list is only for the fix batch of the final review. The driver uses a later entry in two cases only: fix rounds 3 and 4 (the implementer list), and the correctness pass, which takes the first correctness entry of another provider than the first implementer entry. The reviewer never does the correctness pass: when the list has no such entry, or the CLI of that entry is not on PATH, the run ends with exit 3 before any agent. The `explorer` list is read and checked, but the driver starts no explorer.
 
-The defaults need both `claude` and `codex` on PATH. Read "Known limits" before you use them as they are.
+The defaults need both `claude` and `codex` on PATH. The `openai` defaults name the full Codex model names (`gpt-6-astra`, `gpt-6.1-sol`), because a Codex CLI that is signed in with a ChatGPT account does not accept the short aliases. Read "Known limits" before you use them as they are.
 
 ## Report schema per role
 

package/skills/implement-spec/SKILL.md

@@ -24,7 +24,7 @@ has passed. The review rounds adapt superpowers' subagent-driven-development
 Run the driver. It makes every choice of the run; you start it and relay its result.
 
 1. In the PR worktree, run `sh <skill-dir>/run.sh` with the flags the operator gave, unchanged. `<skill-dir>` is the directory of this file. The driver needs `--gate` and `--spec`: ask the operator for a flag that is missing. A run can take hours: run the command in the background and wait for it to exit.
-2. When it exits, relay `.agent/implement/summary.md` and the exit code: 0 is done, 1 is a BLOCKED ticket, 2 is parked on questions, 3 is invalid input. Relay the lines the driver printed after the summary too.
+2. When it exits, relay `.agent/implement/summary.md` and the exit code: 0 is done, 1 is a BLOCKED ticket, 2 is parked on questions, 3 is invalid input, 4 is stopped by a CLI failure (after the fix, the same command resumes). Relay the lines the driver printed after the summary too.
 3. With exit 2, and with exit 1 when the driver printed questions, show the operator those questions. When the operator answers, run the same command again with one `--answer <question id>=<option id>` for each answer.
 
 Do not answer a question for the operator. Do not edit `.agent/implement/`, the code or the branches during a run.

package/skills/implement-spec/driver.py

@@ -6,7 +6,7 @@
               [--dry-run]
 
 Run it in the PR worktree. Exit 0 = every ticket merged (and pushed, when unattended), 1 = a ticket or the end of
-run is BLOCKED, 2 = parked on a question, 3 = usage or validation error. README.md has the method and the files of
+run is BLOCKED, 2 = parked on a question, 3 = usage or validation error, 4 = stopped by a CLI failure. README.md has the method and the files of
 a run; ARCHITECTURE.md has the map of the modules and the rules the code keeps.
 """
 from __future__ import annotations
@@ -32,7 +32,7 @@ import driver_slots
 import driver_state
 import driver_summary
 import driver_tickets
-from driver_run import FINAL, OUT, Blocked, Run, during, ledger
+from driver_run import FINAL, OUT, Blocked, Halted, Run, during, ledger
 from driver_slots import git
 from driver_tickets import Ticket
 
@@ -133,7 +133,7 @@ def _resolve_conflict(ticket: Ticket, slot: str, run: Run, tip: str, files: list
             changed = driver_review.locked_changes(slot, tip, run.state.read()["tickets"][number]["locked"])
             if changed:
                 raise Blocked("; ".join(finding["title"] for finding in changed))
-    except Blocked:
+    except (Blocked, Halted):
         driver_merge.abort(slot)  # closes the merge when the agent did not commit it
         raise
     resolved = driver_slots.head(slot)
@@ -234,6 +234,12 @@ def _block(number: str, run: Run, ledger_line: int) -> None:
         ledger(f"Ticket {number}: {driver_decisions.decides(ask.kind, len(ask.subjects))} in {DECISIONS}.")
 
 
+def _halt(run: Run, owner: str, why: str) -> None:
+    """Start no other agent: the run ends with exit 4, and `owner` keeps its phase for the next run."""
+    run.halted.append(why)
+    ledger(f"{owner}: the run stops and the phase stays for the next run: {why}.")
+
+
 def _run_ticket(ticket: Ticket, slot_number: int, run: Run) -> bool:
     """Take one ticket from its recorded phase to merged or blocked. True: the slot is free again."""
     number, slot = ticket.number, driver_slots.path(slot_number)
@@ -247,11 +253,15 @@ def _run_ticket(ticket: Ticket, slot_number: int, run: Run) -> bool:
     except Blocked as blocked:
         _block(number, run, ledger(f"Ticket {number}: BLOCKED at {blocked}."))
         print(f"{ticket.file}: BLOCKED at {blocked}")
+    except Halted as halted:
+        _halt(run, f"Ticket {number}", str(halted))
     return driver_slots.release(slot)  # False: the slot keeps the uncommitted work of the blocked ticket
 
 
 def _next_ticket(tickets: list[Ticket], running: dict, told: set, run: Run, kept: dict) -> Ticket | None:
     """The first ticket that may start now. A ticket whose slot is kept for it goes first: it needs no free slot."""
+    if run.halted:
+        return None
     phases = {number: entry["phase"] for number, entry in run.state.read()["tickets"].items()}
     ready, holds = driver_graph.frontier(tickets, phases, {number for number, _ in running.values()})
     for hold in sorted(set(holds.items()) - told):
@@ -319,7 +329,13 @@ def _work(tickets: list[Ticket], slots: int, run: Run) -> tuple[bool, list[str]]
         if driver_slots.release("."):  # slot 1 is clean, so it goes back to the PR branch
             git(".", "checkout", "-q", run.pr)
     # Every ticket thread has ended, so every slot is idle: only now may the end of run rewrite the PR branch.
-    return (False, []) if only else driver_final.run(run, tickets)
+    if only:
+        return False, []
+    try:
+        return driver_final.run(run, tickets)
+    except Halted as halted:
+        _halt(run, "End of run", str(halted))
+        return False, []
 
 
 # ---------------------------------------------------------------- before the first agent: resume and answers
@@ -425,6 +441,17 @@ def _tell(args, code: int, open_questions: list[dict], blocked: list[str], pushe
         _write_stage(args.stage_json, code, len(open_questions), blocked)
 
 
+def _halted_exit(halted: list[str], final: dict) -> int:
+    """Exit 4 after a CLI failure: no ticket is BLOCKED by it, and the same command resumes the run."""
+    for why in halted:
+        print(f"implement-spec: the run stopped: {why}")
+    print("implement-spec: fix the CLI or the model entry (--models FILE), then run the same command again to "
+          "resume; no ticket is BLOCKED by this.")
+    if error := _publish_questions(final["run"]):
+        print(error)
+    return 4
+
+
 def _exit_code(final: dict, args, end_blocked: bool) -> int:
     """Publish the open questions, tell the operator or the dispatcher, and return the exit code."""
     if error := _publish_questions(final["run"]):
@@ -456,6 +483,8 @@ def _run(tickets: list[Ticket], models: dict[str, list[str]], args, kept: dict[s
     summary = driver_summary.render(final)
     (OUT / "summary.md").write_text(summary)
     print(summary + "".join(line + "\n" for line in lines), end="")
+    if run.halted:
+        return _halted_exit(run.halted, final)
     return _exit_code(final, args, end_blocked)
 
 
@@ -572,6 +601,10 @@ def main(argv: list[str] | None = None) -> int:
         if not (valid := _validated(args)):
             return 3
         tickets, models, kept = valid
+        # The CLIs answer before the first agent, so a model that the account cannot use stops no ticket.
+        if not args.runner and (errors := driver_agents.preflight(models)):
+            print("".join(error + "\n" for error in errors), end="")
+            return 3
         _print_width(tickets)
         return _run(tickets, models, args, kept)
 

package/skills/implement-spec/driver_agents.py

@@ -11,8 +11,10 @@ import re
 import shutil
 import signal
 import subprocess
+import tempfile
 import threading
 import time
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 
 SKILL = Path(__file__).resolve().parent
@@ -22,6 +24,9 @@ TIMEOUTS = {"explorer": 30, "test-writer": 30, "implementer": 90, "reviewer": 45
 PROVIDERS = {"anthropic": ("claude", ("low", "medium", "high", "xhigh", "max")),
              "openai": ("codex", ("minimal", "low", "medium", "high", "xhigh"))}
 READ_ONLY = ("reviewer", "correctness", "final-reviewer", "pr-writer")
+PREFLIGHT = "implement-spec preflight: reply with the word OK. Read no file and run no command.\n"
+# The time limit of one preflight call: a CLI that gives no answer in this time fails the preflight.
+PREFLIGHT_MINUTES = 5
 # A process group is here only while its leader is not reaped: then no other process can have its id.
 LIVE: set[int] = set()
 STOPPED = False
@@ -69,6 +74,45 @@ def load_models(path: str | None) -> tuple[dict[str, list[str]], list[str]]:
     return models, [error for error in found if error]
 
 
+def used_entries(models: dict[str, list[str]]) -> list[str]:
+    """Each entry the driver can start an agent on: the first of each role but the explorer, the correctness entry
+    and the second implementer entry (fix rounds 3 and 4)."""
+    entries = [entries[0] for role, entries in models.items() if role not in ("explorer", "correctness")]
+    entries += [correctness_entry(models), *models["implementer"][1:2]]
+    return sorted(set(entries))
+
+
+def preflight(models: dict[str, list[str]]) -> list[str]:
+    """Give one short prompt to each used entry, all at the same time. Returns one error per entry whose CLI fails:
+    a model that the account cannot use, a CLI that is not signed in."""
+    with tempfile.TemporaryDirectory(prefix="implement-spec-preflight-") as folder:
+        def check(index: int, entry: str) -> str:
+            prompt, log = (Path(folder) / f"{index}{suffix}" for suffix in (".prompt.md", ".log"))
+            prompt.write_text(PREFLIGHT)
+            # A read-only command: the agent can change nothing, and codex writes its answer to the -o file.
+            code = launch(command("reviewer", entry, str(Path(folder) / f"{index}.json")), prompt, log,
+                          PREFLIGHT_MINUTES * 60)
+            if code == 0:
+                return ""
+            why = f"no answer in {PREFLIGHT_MINUTES} minutes" if code is None else f"exit {code}"
+            cli = PROVIDERS[split(entry)[0]][0]
+            return f"model entry {entry}: the {cli} CLI failed the preflight ({why}): {last_words(log)}"
+
+        entries = used_entries(models)
+        with ThreadPoolExecutor(len(entries)) as pool:
+            return [error for error in pool.map(check, range(len(entries)), entries) if error]
+
+
+def last_words(log: Path) -> str:
+    """The last line of an agent log, or the `result` of the last stream-json line: the error a failed CLI gave."""
+    lines = [line for line in log.read_text(errors="replace").splitlines() if line.strip()] if log.exists() else []
+    if not lines:
+        return "no output"
+    with contextlib.suppress(ValueError, AttributeError):
+        return str(json.loads(lines[-1]).get("result") or lines[-1])[-500:]
+    return lines[-1][-500:]
+
+
 def command(role: str, entry: str, report: str) -> list[str]:
     """The CLI call for one agent; the prompt goes to its stdin."""
     provider, model, effort = split(entry)

package/skills/implement-spec/driver_final.py

@@ -29,7 +29,7 @@ import driver_decisions
 import driver_merge
 import driver_review
 import driver_tidy
-from driver_run import FINAL, OUT, Blocked, Run, during, ledger
+from driver_run import FINAL, OUT, Blocked, Halted, Run, during, ledger
 from driver_slots import git, head
 from driver_state import State
 from driver_tickets import Ticket
@@ -158,6 +158,9 @@ def _resolve_rebase_conflict(run: Run, env: dict, base: str, onto: str) -> None:
         run.agent("conflict", FINAL, ".", values, template="rebase-conflict", detached=True)
     except Blocked as blocked:
         error = str(blocked)
+    except Halted:
+        git(".", "rebase", "--abort")
+        raise
     if not error and _rebase_is_open():  # the agent resolved the files and did not go on
         subprocess.run(["git", "-c", "core.editor=true", "rebase", "--continue"], capture_output=True, env=env)
     if _rebase_is_open():
@@ -368,6 +371,8 @@ def _run_fixer(run: Run, tickets: list[Ticket], final: dict, tip: str) -> dict:
                          check={"owners": [ticket.number for ticket in tickets]})
     except Blocked as blocked:
         raise Blocked(f"{blocked}{_undo_rejected_batch(run, tip)}") from None
+    except Halted as halted:
+        raise Halted(f"{halted}{_undo_rejected_batch(run, tip)}") from None
 
 
 def _fix_batch(run: Run, tickets: list[Ticket], final: dict, tip: str) -> None:

package/skills/implement-spec/driver_run.py

@@ -1,6 +1,7 @@
 """What the ticket threads and the end of run share: the Run, one agent with its one rerun, the gate, the ledger.
 
 A step that cannot go on raises Blocked. The message says why, and `during` adds the step it happened in.
+A CLI that fails with no report raises Halted: that is the setup of the run, not the ticket.
 """
 from __future__ import annotations
 
@@ -34,6 +35,11 @@ class Blocked(Exception):
     """A ticket, or the end of run, cannot go on. The message says why."""
 
 
+class Halted(Exception):
+    """The CLI of an agent failed with no report, two times: a model the account cannot use, a CLI that is not
+    signed in. The run starts no other agent and ends with exit 4; the ticket keeps its phase for the next run."""
+
+
 @contextmanager
 def during(step: str) -> Iterator[None]:
     """Put the step in front of a Blocked that leaves the block: `<step>: <why>`."""
@@ -79,6 +85,7 @@ class Run:
     kept: dict[str, int]  # ticket number -> the slot that holds its uncommitted work from an earlier run
     merging: threading.Lock = field(default_factory=threading.Lock)  # held for one landing: merges are serial
     asks: dict[str, Ask] = field(default_factory=dict)  # ticket number -> its pending stop
+    halted: list[str] = field(default_factory=list)  # why the run starts no other agent; [] while it goes on
 
     def tip(self) -> str:
         return git(".", "rev-parse", f"refs/heads/{self.pr}").stdout.strip()
@@ -110,6 +117,9 @@ class Run:
                 result = review()
             except Blocked as blocked:
                 error = str(blocked)
+            except Halted:
+                _restore_if_changed(number, slot, branch, tip, runs_again=False)
+                raise
             left = _restore_if_changed(number, slot, branch, tip, runs_again=not (error or last))
             if error or not left:
                 break
@@ -244,7 +254,7 @@ def _attempts(run: Run, role: str, number: str, slot: str, values: dict[str, str
                "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)
-    minutes, error = run.args.timeout[role], ""
+    minutes, error, failed = run.args.timeout[role], "", ""
     for _ in range(2):
         prompt.write_text(text)
         report.unlink(missing_ok=True)
@@ -255,8 +265,13 @@ def _attempts(run: Run, role: str, number: str, slot: str, values: dict[str, str
         _record_attempt(run, role, number, entry, seconds, log, error)
         if not error:
             return json.loads(report.read_text())
+        # A CLI that exits with an error and no report did not do the role: the run setup is wrong, not the ticket.
+        failed = "" if code in (None, 0) or report.exists() else (
+            f"the {role} on {entry} exited {code} with no report: {driver_agents.last_words(log)}")
         # The rerun prompt is the first prompt, the rejection, then the same ending again.
         text += rerun_lines + driver_agents.tail(text, report_in_slot)
         if code is None:
             minutes *= 2
+    if failed:
+        raise Halted(failed)
     raise Blocked(error)

package/skills/implement-spec/models.json

@@ -1,11 +1,11 @@
 {
   "explorer": ["claude-sonnet-5@medium"],
-  "test-writer": ["claude-sonnet-5@medium", "openai/gpt-sol@medium"],
-  "implementer": ["claude-sonnet-5@medium", "openai/gpt-sol@medium"],
-  "reviewer": ["openai/gpt-astra@medium", "claude-opus-5@medium"],
-  "correctness": ["openai/gpt-astra@medium", "claude-opus-5@medium"],
+  "test-writer": ["claude-sonnet-5@medium", "openai/gpt-6.1-sol@medium"],
+  "implementer": ["claude-sonnet-5@medium", "openai/gpt-6.1-sol@medium"],
+  "reviewer": ["openai/gpt-6-astra@medium", "claude-opus-5@medium"],
+  "correctness": ["openai/gpt-6-astra@medium", "claude-opus-5@medium"],
   "fixer": ["claude-opus-5@medium"],
-  "final-reviewer": ["openai/gpt-astra@medium", "claude-opus-5@medium"],
+  "final-reviewer": ["openai/gpt-6-astra@medium", "claude-opus-5@medium"],
   "conflict": ["claude-opus-5@medium"],
   "pr-writer": ["claude-opus-5@medium"]
 }

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

@@ -22,6 +22,7 @@ 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"
+REFUSED = "ERROR: The 'gpt-astra' model is not supported when using Codex with a ChatGPT account."
 RUNNER = f"""#!{sys.executable}
 import json, os, subprocess, sys, time
 from pathlib import Path
@@ -69,7 +70,8 @@ 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."""
+    """A restricted PATH whose fake claude and codex append their argv (NUL-separated) and exit 1. They answer the
+    preflight prompt with exit 0 and log nothing, except for the model gpt-astra, which the account cannot use."""
     bin_dir = tmp_path / "bin"
     bin_dir.mkdir()
     for name in TOOLS:
@@ -77,7 +79,15 @@ def env(tmp_path):
             (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).write_text(f"""#!/bin/sh
+case "$(cat)" in *'implement-spec preflight'*)
+    case " $* " in *' gpt-astra '*) echo "{REFUSED}"; exit 1;; esac
+    exit 0;;
+esac
+printf '%s\\0' "$@" >> {log}
+printf '\\036' >> {log}
+exit 1
+""")
         (bin_dir / cli).chmod(0o755)
     return dict(os.environ, PATH=str(bin_dir)), tmp_path
 
@@ -267,6 +277,29 @@ def test_no_report_is_a_violation_with_one_rerun_then_blocked(env):
     assert any("01" in l and "BLOCKED" in l for l in w.ledger().splitlines()), w.ledger()
 
 
+def test_a_model_the_account_cannot_use_fails_the_preflight_with_exit_3_before_any_agent(env):
+    w = World(env, reviewer=["openai/gpt-astra@medium"])
+    proc = w.run({"test-writer": [tw()]}, runner=False)
+    assert proc.returncode == 3, proc.stdout + proc.stderr
+    assert f"model entry openai/gpt-astra@medium: the codex CLI failed the preflight (exit 1): {REFUSED}" \
+        in proc.stdout.splitlines(), proc.stdout
+    assert not launches(w.tmp, "claude") and not launches(w.tmp, "codex")
+    assert "ticket/01" not in git(w.repo, "branch", "--list") and not w.ledger()
+
+
+def test_a_cli_that_fails_with_no_report_stops_the_run_with_exit_4_and_the_same_command_resumes(env):
+    w = World(env, refactor=True)
+    plan = {"implementer": [{"stderr": REFUSED + "\n", "exit": 1}] * 2 + [impl()]}
+    proc = w.run(plan)
+    assert proc.returncode == 4, proc.stdout + proc.stderr
+    assert f"implement-spec: the run stopped: the implementer on anthropic/claude-opus-5@medium exited 1 with no " \
+        f"report: {REFUSED}" in proc.stdout.splitlines(), proc.stdout
+    assert "BLOCKED" not in w.ledger() and "Ticket 01: the run stops and the phase stays for the next run: the implementer" in w.ledger()
+    assert json.loads((w.repo / ".agent/implement/state.json").read_text())["tickets"]["01"]["phase"] == "implement"
+    ok(w.run(plan))
+    assert len(w.calls("implementer")) == 3
+
+
 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)]}))

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

@@ -175,7 +175,7 @@ def test_accepted_reports_end_the_run_with_exit_0(repo, tmp_path, capsys):
     assert [line.partition(" for ")[0] for line in ledger] == [
         "Ticket 01: test-writer ran on claude-sonnet-5@medium", "Ticket 01: implementer ran on claude-sonnet-5@medium",
         f"Ticket 01: the gate is green on {tip}, record .agent/implement/01/gate-{tip}.log.",
-        "Ticket 01: reviewer ran on openai/gpt-astra@medium",
+        "Ticket 01: reviewer ran on openai/gpt-6-astra@medium",
         f"Ticket 01: merged into feat/x as a fast-forward at {tip}."]
     assert ledger[1].endswith(", cost 0.25 USD: report accepted.")
     assert branches() == ["feat/x"] and "nothing to commit" in subprocess.run(
@@ -198,7 +198,7 @@ def prompt_of(tmp_path, role="implementer"):
 
 def test_an_agent_that_writes_no_report_is_rerun_once_then_blocks(repo, tmp_path, capsys):
     repo()
-    code, ledger = agents(tmp_path, capsys, "exit 7\n", "--only", "reviewer")
+    code, ledger = agents(tmp_path, capsys, "exit 0\n", "--only", "reviewer")
     assert code == 1 and len(ledger) == 3
     assert ledger[2].startswith("Ticket 01: BLOCKED at the reviewer: report .agent/implement/01/reviewer-0.json is not")
 
@@ -422,7 +422,7 @@ def test_a_merge_conflict_goes_to_the_conflict_agent_once_and_its_commit_is_gate
 
 def test_a_conflict_agent_that_does_not_resolve_blocks_the_ticket_and_keeps_its_branch(repo, tmp_path, capsys):
     two(repo)
-    stuck = '[ $role != conflict ] || exit 7\n'
+    stuck = '[ $role != conflict ] || exit 0\n'
     code, ledger, out = walk(tmp_path, capsys, stuck + "FILE=work.txt\n" + WORK + TOGETHER + REPORT)
     assert code == 1, out
     (line,) = [line for line in ledger if "BLOCKED" in line]
@@ -436,6 +436,19 @@ def test_a_conflict_agent_that_does_not_resolve_blocks_the_ticket_and_keeps_its_
         assert out_of("git", "-C", slot, "rev-parse", "-q", "--verify", "MERGE_HEAD") == ""
 
 
+def test_a_conflict_cli_that_fails_stops_the_run_and_leaves_no_open_merge(repo, tmp_path, capsys):
+    two(repo)
+    failing = '[ $role != conflict ] || { echo "ERROR: not signed in"; exit 7; }\n'
+    code, ledger, out = walk(tmp_path, capsys, failing + "FILE=work.txt\n" + WORK + TOGETHER + REPORT)
+    assert code == 4 and "with no report: ERROR: not signed in" in out, out
+    assert not [line for line in ledger if "BLOCKED" in line]
+    (number,) = [n for n, entry in state_of(tmp_path)["tickets"].items() if entry["phase"] == "merge"]
+    assert f"ticket/{number}" in branches()
+    for slot in (".", ".agent/worktrees/slot-2"):
+        assert out_of("git", "-C", slot, "status", "--porcelain") == ""
+        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):
     two(repo, second="01")
     code, ledger, out = walk(tmp_path, capsys, WORK + REPORT, gate="echo CHECK-OUTPUT; exit 1")
@@ -765,3 +778,36 @@ def test_a_rerun_after_an_interrupt_keeps_the_work_in_each_slot_and_reruns_the_r
     assert out_of("git", "show", "feat/x:wip-01.txt") == "half" and out_of("git", "show", "feat/x:wip-02.txt") == "half"
     assert [line for line in ledger if "Ticket 02: resumed in slot 2 with the work the interrupted implementer left" in line]
     assert out_of("git", "status", "--porcelain") == "" and branches() == ["feat/x"]
+
+
+def test_the_preflight_asks_each_used_entry_once_and_names_each_cli_that_fails(tmp_path, monkeypatch):
+    """claude answers; codex refuses gpt-astra, and the gpt-6.1-sol call never ends."""
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    (bin_dir / "claude").write_text('#!/bin/sh\ncat > /dev/null\necho "$*" >> "$(dirname "$0")/asked"\n')
+    (bin_dir / "codex").write_text('#!/bin/sh\ncat > /dev/null\necho "$*" >> "$(dirname "$0")/asked"\n'
+                                   'case "$*" in *gpt-astra*) echo "ERROR: not supported"; exit 1;; '
+                                   '*gpt-6.1-sol*) sleep 30;; esac\n')
+    for cli in ("claude", "codex"):
+        (bin_dir / cli).chmod(0o755)
+    monkeypatch.setenv("PATH", f"{bin_dir}{os.pathsep}{os.environ['PATH']}")
+    monkeypatch.setattr(driver_agents, "PREFLIGHT_MINUTES", 0.02)
+    models, _ = driver_agents.load_models(None)
+    models["reviewer"] = ["openai/gpt-astra@medium"]
+    assert driver_agents.used_entries(models) == ["claude-opus-5@medium", "claude-sonnet-5@medium",
+                                                  "openai/gpt-6-astra@medium", "openai/gpt-6.1-sol@medium",
+                                                  "openai/gpt-astra@medium"]
+    assert driver_agents.preflight(models) == [
+        "model entry openai/gpt-6.1-sol@medium: the codex CLI failed the preflight (no answer in 0.02 minutes): "
+        "no output",
+        "model entry openai/gpt-astra@medium: the codex CLI failed the preflight (exit 1): ERROR: not supported"]
+    assert len((bin_dir / "asked").read_text().splitlines()) == 5
+
+
+def test_last_words_takes_the_result_of_a_stream_json_line(tmp_path):
+    log = tmp_path / "agent.log"
+    log.write_text('{"type": "system"}\n{"type": "result", "is_error": true, "result": "There is an issue"}\n\n')
+    assert driver_agents.last_words(log) == "There is an issue"
+    log.write_text("ERROR: plain\n")
+    assert driver_agents.last_words(log) == "ERROR: plain"
+    assert driver_agents.last_words(tmp_path / "none.log") == "no output"

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

@@ -8,10 +8,10 @@ import pytest
 from test_cli import RUN, SKILL, drive, env, make_repo, three  # noqa: F401  (env is a fixture)
 
 STANDARD = {
-    "implementer": ["claude-sonnet-5@medium", "openai/gpt-sol@medium"],
-    "test-writer": ["claude-sonnet-5@medium", "openai/gpt-sol@medium"],
-    "reviewer": ["openai/gpt-astra@medium", "claude-opus-5@medium"],
-    "final-reviewer": ["openai/gpt-astra@medium", "claude-opus-5@medium"],
+    "implementer": ["claude-sonnet-5@medium", "openai/gpt-6.1-sol@medium"],
+    "test-writer": ["claude-sonnet-5@medium", "openai/gpt-6.1-sol@medium"],
+    "reviewer": ["openai/gpt-6-astra@medium", "claude-opus-5@medium"],
+    "final-reviewer": ["openai/gpt-6-astra@medium", "claude-opus-5@medium"],
 }
 ENTRY = re.compile(r"^(?:(?:anthropic|openai)/)?[\w.-]+@(?:minimal|low|medium|high|xhigh|max)$")
 

package/skills/pr-visual-diff/SKILL.md

@@ -45,7 +45,7 @@ file as JSON:
 | `deviceProjects` | the config's `projects` (default to a desktop + a mobile project) |
 | `baseBranch` | the repo's default branch (`main`/`master`; `git symbolic-ref refs/remotes/origin/HEAD`) |
 | `packageManager` | infer from lockfile: `pnpm-lock.yaml`→pnpm, `package-lock.json`→npm, `yarn.lock`→yarn, `bun.lockb`→bun |
-| `spinnerSelector` | the app's loading-indicator selector (search for a spinner/`role="status"`/`aria-busy` component) |
+| `spinnerSelector` | every loading indicator of the app, as one selector list: spinners and skeletons (search for a spinner, `role="status"`, `aria-busy`, a skeleton component, `animate-pulse`), e.g. `.animate-spin, .animate-pulse`. A skeleton left out lets a half-loaded view pass as a good shot |
 
 ### Preconditions gate
 
@@ -77,6 +77,14 @@ compact report: the screenshot file names + pinned URLs, the PR-body
 markdown, and any views it flagged. The main context creates/edits the PR from
 that report — it never reads a PNG.
 
+## Where the capture runs
+
+- **Local** (the default): steps 3–5 below, on this machine.
+- **Remote**: when the session instructions say so (the agent-ops box does),
+  or when this machine cannot start a Playwright browser. A GitHub workflow of
+  the target repo captures both sides and pushes the hidden ref; see "Remote
+  capture". Steps 1, 2 and 6 stay the same.
+
 ## Workflow
 
 ### 1. Map the diff to views, then get the user's go-ahead
@@ -96,6 +104,10 @@ hidden ref on the remote and embed them in the PR. Include the proposed plan: wh
 device projects — default to the config's `deviceProjects`; add more only when
 the change is layout-sensitive. If they decline, create the PR normally and stop.
 
+In an unattended session (nobody answers questions, as on the agent-ops box),
+do not ask: run the capture with the plan above and name the plan in the PR
+body.
+
 ### 2. Write the capture spec
 
 Copy `references/capture-spec-template.ts` from this skill into
@@ -133,7 +145,10 @@ That assertion is a backstop, not a substitute for looking: the subagent still
 Reads each PNG after capture — an empty state, error toast, or wrong content
 passes the spinner check but is still wrong. On a genuine failure, fix the spec
 (add mock stubs, a wait for a stable element, or correct the spinner selector)
-rather than shipping a bad screenshot.
+rather than shipping a bad screenshot. A fixed element (a mobile bottom nav, a
+sticky header) is drawn where the viewport was, so in a full-page shot it can
+float over the middle of the page: give such a view `fullPage: false`, or one
+shot per scroll position.
 
 ### 4. Capture "before" (merge base, temp worktree)
 
@@ -239,6 +254,74 @@ cell instead of an image:
 | **Mobile** | _New view_ | ![](<blob-url>?raw=true) |
 ```
 
+## Remote capture
+
+Replaces steps 3–5. The subagent rule above still holds.
+
+The steps run in one shared workflow, `.github/workflows/pr-visual-diff.yml` of
+jesdi/general-skills. Each target repo has a short caller of it, made from
+`references/capture-caller.yml` of this skill, which follows the main branch
+of general-skills: GitHub starts `workflow_dispatch` only in the target repo.
+
+**Precondition.** The default branch of the target repo has the caller,
+`.github/workflows/pr-visual-diff.yml`:
+
+```bash
+REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)
+gh api "repos/$REPO/contents/.github/workflows/pr-visual-diff.yml" --silent
+```
+
+If it does not, take no screenshots. Say in the PR body that the repo has no
+pr-visual-diff workflow, and that `references/capture-caller.yml` of this
+skill, filled from the discovery cache and merged to the default branch, adds
+it. Do not add it in this PR: `workflow_dispatch` runs only from the default
+branch.
+
+**Dispatch.** Push the PR branch first: the workflow checks out commits of
+origin. Write the filled spec of step 2 to a file, and a second copy whose
+`VIEWS` holds only the views that exist at the merge base (none: no Before).
+Then:
+
+```bash
+HEAD_SHA=$(git rev-parse HEAD)
+BASE=$(git merge-base origin/<baseBranch> HEAD)
+SLUG=$(git branch --show-current | tr / -)
+CAPTURE="${HEAD_SHA:0:12}-$(date +%s)"
+gh workflow run pr-visual-diff.yml --ref <baseBranch> \
+  -f capture="$CAPTURE" -f slug="$SLUG" -f head="$HEAD_SHA" -f base="$BASE" \
+  -f after_spec="$(base64 < <after-spec> | tr -d '\n')" \
+  -f before_spec="$(base64 < <before-spec> | tr -d '\n')" \
+  -f projects="<deviceProject>,<deviceProject>"
+```
+
+Leave `before_spec` empty when every view is new. `gh workflow run` prints no
+run id: find the run by its name `pr-visual-diff $CAPTURE` (try for up to a
+minute), then wait for it:
+
+```bash
+RUN=$(gh run list --workflow pr-visual-diff.yml --limit 20 --json databaseId,displayTitle \
+  --jq ".[] | select(.displayTitle == \"pr-visual-diff $CAPTURE\") | .databaseId")
+gh run watch "$RUN" --exit-status
+```
+
+**A failed run.** Read `gh run view "$RUN" --log-failed | tail -80`. Fix the
+spec as in step 3 (a mock stub, a wait, the spinner selector) and dispatch
+once more with a new `CAPTURE`. When the second run fails too, take no
+screenshots and say why in the PR body.
+
+**Read the shots back.** Fetch the hidden ref and look at every PNG, as in
+step 3:
+
+```bash
+git fetch origin "refs/pr-screenshots/$SLUG/$CAPTURE"
+SHA=$(git rev-parse FETCH_HEAD)
+mkdir -p <scratchpad>/shots && git archive "$SHA" | tar -x -C <scratchpad>/shots
+```
+
+A wrong shot is a failed run: fix the spec and dispatch again, under the same
+limit. Then embed with step 6, with `$SHA` in the URLs. The ref stays: it keeps
+the images alive.
+
 ## Adding shots to an existing PR
 
 Same flow; the only differences: diff against the PR's base branch

package/skills/pr-visual-diff/references/capture-caller.yml

@@ -0,0 +1,56 @@
+# pr-visual-diff remote capture of this repo. Template of the pr-visual-diff
+# skill (references/capture-caller.yml): copy it to
+# .github/workflows/pr-visual-diff.yml, replace every __PVD_*__ marker with the
+# value of the discovery cache, and merge it to the default branch:
+# workflow_dispatch runs only from there. The steps live in jesdi/general-skills
+# (.github/workflows/pr-visual-diff.yml) and follow its main branch, like every
+# jesdi skill follows its latest release.
+
+name: pr-visual-diff
+run-name: pr-visual-diff ${{ inputs.capture }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      capture:
+        description: 'Unique id of this capture; the last part of the hidden ref'
+        required: true
+      slug:
+        description: 'The PR branch with / as -'
+        required: true
+      head:
+        description: 'Commit captured as After'
+        required: true
+      base:
+        description: 'Commit captured as Before (the merge base)'
+        required: true
+      after_spec:
+        description: 'The filled capture spec, base64'
+        required: true
+      before_spec:
+        description: 'The filled capture spec of the views that exist at base, base64; empty: no Before'
+        required: false
+        default: ''
+      projects:
+        description: 'Playwright projects, separated by commas'
+        required: true
+
+jobs:
+  capture:
+    permissions:
+      contents: write  # only its publish job uses it, to push the hidden ref
+    uses: jesdi/general-skills/.github/workflows/pr-visual-diff.yml@main
+    with:
+      capture: ${{ inputs.capture }}
+      slug: ${{ inputs.slug }}
+      head: ${{ inputs.head }}
+      base: ${{ inputs.base }}
+      after_spec: ${{ inputs.after_spec }}
+      before_spec: ${{ inputs.before_spec }}
+      projects: ${{ inputs.projects }}
+      runner: __PVD_RUNNER__
+      frontend_dir: __PVD_FRONTEND_DIR__
+      specs_dir: __PVD_SPECS_DIR__
+      browsers: __PVD_BROWSERS__
+      node_version: '__PVD_NODE_VERSION__'
+      pnpm_version: '__PVD_PNPM_VERSION__'

package/skills/pr-visual-diff/references/capture-spec-template.ts

@@ -26,7 +26,7 @@ const OUT = process.env.PR_SHOT_DIR;
 const LABEL = process.env.PR_SHOT_LABEL ?? 'after';
 if (!OUT) throw new Error('PR_SHOT_DIR must be set to an absolute output directory');
 
-// Selector for this app's loading indicator. From config: <spinnerSelector>.
+// Every loading indicator of this app, spinners and skeletons. From config: <spinnerSelector>.
 const SPINNER = '__PVD_SPINNER_SELECTOR__';
 
 // Pin device-pixel-ratio to 1 for every project. Device descriptors (iPhone 14,

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-15T12:05:36.876Z",
+  "generatedAt": "2026-10-15T16:47:59.098Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,14 +46,14 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.9",
-      "hash": "sha256-a2864cb6013ba8ee10af5b597b4376b89507efce8c6acecfbeca5db7389623ea",
+      "version": "0.1.10",
+      "hash": "sha256-a0c42688cad43aece79d51d9e09644cc879518858781bf5563e6f8388d009a0c",
       "description": "Implement a specification in code."
     },
     {
       "name": "pr-visual-diff",
-      "version": "0.1.1",
-      "hash": "sha256-c90f308a7529ead883b4c379d034724a33da43e91f2d8ba0f2bdc5d79c894df2",
+      "version": "0.1.2",
+      "hash": "sha256-df10fb424564e7721856a88a9bafeeb077041244faa949711ff92d5490fb7854",
       "description": "Capture before/after screenshots of UI views with Playwright and embed them in a PR. Use this skill whenever creating or preparing a pull request that touches frontend code (components, views, styles, layout, Tailwind classes) — even if the user just says \"open a PR\" or \"create the PR\" after UI work, and especially if they mention screenshots, visual diff, before/after, or \"show what changed\". Also use when the user asks to add screenshots to an existing PR."
     },
     {