@jesdi/skills 0.0.33 → 0.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jesdi/skills",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "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
@@ -103,6 +107,8 @@ and do not know about the run, except `driver_run.py`, which the three deciding
   A timeout doubles the time of the rerun.
 - Fix rounds stop at 4, and round 3 goes to the next implementer entry. The correctness pass never runs on the
   provider of the implementer.
+- A red gate on a fixer's commit is a finding of the next round (`driver_fixloop._gate`), so it blocks only after
+  round 4.
 
 ### Questions
 

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": …}`:
@@ -80,7 +82,7 @@ Everything is under `.agent/`, which is never committed.
 | `.agent/implement/<NN>/` | One folder for each ticket. |
 | `.agent/implement/<NN>/<role>-<K>.json`, `.log`, `.prompt.md` | The report, the log and the prompt of one agent. K is the fix round. |
 | `.agent/implement/<NN>/gate-<sha7>.log` | One gate record: start, commit, status, command, output, exit, the state after the command, end. |
-| `.agent/implement/<NN>/findings-<K>.json` | The merged findings of the review after fix round K. |
+| `.agent/implement/<NN>/findings-<K>.json` | The merged findings of the review after fix round K, or the red gate of round K. |
 | `.agent/implement/final/` | The same files for the end of run, and `pr-body.md`: the pr-writer's body, then the facts of the run. |
 | `.agent/implement/pycache/` | Compiled Python of the gate, kept out of the slots. |
 | `.agent/implement-review.html` | The page with the open questions. |
@@ -117,6 +119,8 @@ Rules for each agent:
 
 A fix round is one **fixer** (`prompts/fixer.md`), then the gate on the new tip, then a re-review of the range of the fix. A mutation proof is repeated only when the fix changed its production line.
 
+A red gate on the commit of a fixer is a critical finding with source `gate`. Its file is the gate record, and the record holds the output. No review runs on that tip, and the next round starts. The re-review after that round covers each fix since the last review and repeats each proof that one of them made due. A red gate after round 4 blocks the ticket, as does a red gate on the commit of the implementer or of a fixture correction.
+
 - Rounds 1 and 2 run on the first entry of the implementer list.
 - Rounds 3 and 4 run on the second entry of the implementer list. When the list has one entry, they stay on it and the ledger says so.
 - There is no ruling at round 2.
@@ -158,7 +162,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_fixloop.py

@@ -30,8 +30,9 @@ class Job:
     tip: str
     previous: str = ""  # the tip before the last fix; "" makes the next review a full one
     proofs: set[tuple[str, int]] = field(default_factory=set)  # mutation proofs so far, at `tip`
-    again: list[str] = field(default_factory=list)  # `file:line` of each proof the last fix made due again
+    again: set[tuple[str, int]] = field(default_factory=set)  # each proof at `tip` that a fix made due again
     corrected: bool = False  # the last step was a fixture correction
+    red: bool = False  # the gate of `tip` is red, so no review saw it
 
     def pointers(self, review: int) -> dict[str, str]:
         """The values of a prompt; `review` is the round whose findings the agent reads."""
@@ -39,7 +40,7 @@ class Job:
         findings = os.path.relpath(OUT / self.ticket.number / f"findings-{review}.json", self.slot)
         return {**self.values, "start_sha": self.tip, "from_sha": self.previous, "round": str(self.round),
                 "locked": " ".join(entry["locked"]), "test_writer_sha": str(entry["test_writer_sha"] or ""),
-                "findings": findings, "proofs": " ".join(self.again)}
+                "findings": findings, "proofs": " ".join(f"{file}:{line}" for file, line in sorted(self.again))}
 
 
 def entry(models: dict[str, list[str]], round: int) -> str:
@@ -129,12 +130,16 @@ def _fix(job: Job) -> None:
     with during(f"fix round {job.round}"):
         run.agent("fixer", number, job.slot, job.pointers(job.round - 1), entry=on, fix_round=job.round)
     before, job.tip = job.tip, driver_slots.head(job.slot)
-    # No review has seen a fixture correction, so the review after a fix on a corrected tip is a full one.
-    job.previous, job.corrected = "" if job.corrected else before, False
     run.state.ticket(number, tip=job.tip)
     followed = driver_review.follow(job.slot, before, job.tip, job.proofs)
-    job.proofs = set(followed)
-    job.again = [f"{file}:{line}" for (file, line), changed in sorted(followed.items()) if changed]
+    due = {proof for proof, changed in followed.items() if changed}
+    if job.red:
+        # No review saw `before`: the next review covers the fix before it too, and its due proofs stay due.
+        due |= set(driver_review.follow(job.slot, before, job.tip, job.again))
+    else:
+        # No review has seen a fixture correction, so the review after a fix on a corrected tip is a full one.
+        job.previous = "" if job.corrected else before
+    job.corrected, job.proofs, job.again = False, set(followed), due
 
 
 def _act_on(job: Job, found: list[dict]) -> bool:
@@ -157,14 +162,33 @@ def _act_on(job: Job, found: list[dict]) -> bool:
     return False
 
 
+def _gate(job: Job) -> list[dict]:
+    """Gate the tip. A red gate on a fixer's commit before round 4 is a finding for the next round; any other red
+    gate blocks. Returns the findings: the red gate, or none."""
+    run, number = job.run, job.ticket.number
+    job.red = False
+    with during("the gate"):
+        if not 0 < job.round < ROUNDS or job.corrected:
+            run.gate(number, job.slot, job.tip)
+            return []
+        record = run.red_gate(number, job.slot, job.tip)
+    if not record:
+        return []
+    job.red, path = True, os.path.relpath(record, job.slot)
+    found = [{"severity": "critical", "file": path, "line": 0, "title": f"the gate is red on {job.tip[:7]}",
+              "evidence": f"the output of the gate in {path}", "kind": "code", "source": "gate"}]
+    (OUT / number / f"findings-{job.round}.json").write_text(json.dumps(found, indent=1) + "\n")
+    return _log_findings(job, found)
+
+
 def run(ticket: Ticket, slot: str, run: Run, values: dict[str, str]) -> None:
     """Gate, review and fix the ticket tip until a review leaves no finding open."""
     state = run.state.read()["tickets"][ticket.number]
     job = Job(ticket, slot, run, values, state["round"], state["tip"])
     while True:
-        with during("the gate"):
-            run.gate(ticket.number, slot, job.tip)
-        with during("the review"):
-            found = _review(job)
+        found = _gate(job)
+        if not found:
+            with during("the review"):
+                found = _review(job)
         if _act_on(job, found):
             return

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
@@ -119,8 +129,13 @@ class Run:
 
     def gate(self, number: str, slot: str, commit: str) -> None:
         """Gate `commit` in the slot, unless a green record names it already."""
+        if record := self.red_gate(number, slot, commit):
+            raise Blocked(f"the gate is red on {commit[:7]}, record {record}")
+
+    def red_gate(self, number: str, slot: str, commit: str) -> str:
+        """`gate`, for a caller that acts on a red gate: returns its record, or "" when the gate is green."""
         if commit in _gate_record(self.state.read(), number)["green_gates"]:
-            return
+            return ""
         at = driver_slots.head(slot)
         if at != commit:
             raise Blocked(f"the slot is at {at[:7]}, not at {commit[:7]}: the gate did not run")
@@ -133,8 +148,9 @@ class Run:
 
         self.state.update(count)
         if not green:
-            raise Blocked(f"the gate is red on {commit[:7]}, record {record}")
+            return str(record)
         ledger(f"{_owner(number)}: the gate is green on {commit[:7]}, record {record}.")
+        return ""
 
     def restore_locked_files(self, number: str, slot: str) -> list[str]:
         """Before a test-writer correction: put each locked file the implementer changed back to its locked
@@ -244,7 +260,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 +271,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/prompts/fixer.md

@@ -10,6 +10,7 @@ Findings of the review: {findings}
 Fix each finding of severity critical or important in the findings file. Leave the minor findings: the final review gets them. Leave each finding of kind `fixture`: the test-writer corrects those.
 Never edit a locked file. The one exception is a finding `locked file changed`: make that file equal to its content at {test_writer_sha}.
 Use targeted tests while you work. The driver runs the gate on your final commit, and a re-review reads the lines you changed.
+A finding from the `gate` is a red gate: its file is the gate record. Read the output there and make the gate green.
 Commit your work on the checked-out ticket branch. Do not dispatch subagents.
 In `ticket`, give the number of the ticket that owns your commits. In `green`, give the summary lines of the passing test output.
 

package/skills/implement-spec/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_fixloop.py

@@ -311,6 +311,34 @@ def test_four_rounds_then_blocked_with_the_escalation_at_round_3(tmp_path):
     assert rig.state()["tickets"]["03"]["phase"] == "merged"
 
 
+def test_a_red_gate_on_a_fixer_commit_starts_the_next_round_with_the_record_as_evidence(tmp_path):
+    """Issue 64: the gate of a fix round is red. That is a finding for the next round, not a BLOCKED ticket."""
+    rig = Inside(tmp_path, gate={"subjects": ["fix: 01 round 1"]})
+    rig.run(plan(**{"01/reviewer": [review("01", [STUCK], lines=(2,)), review("01", lines=(2,))],
+                    "01/fixer": [fix("01", 1), fix("01", 2, files={"demo/other.py": "x = 1\n"})]}))
+    assert rig.code == 0, rig.ledger()
+    assert [call["role"] for call in rig.calls("01")] == ["test-writer", "implementer", "reviewer", "fixer", "fixer",
+                                                         "reviewer"]
+    first, second = (call["sha"] for call in rig.calls("01", "fixer"))
+    record = f".agent/implement/01/gate-{first[:7]}.log"
+    (gate,) = json.loads((rig.folder() / "findings-1.json").read_text())
+    assert (gate["source"], gate["severity"], gate["kind"]) == ("gate", "critical", "code")
+    assert gate["title"] == f"the gate is red on {first[:7]}" and record in gate["evidence"]
+    assert rig.led(f"Ticket 01: critical finding of kind code from the gate at {record}:0: the gate is red on {first[:7]}.")
+    assert "findings-1.json" in rig.prompt("fixer-2") and rig.state()["tickets"]["01"]["round"] == 2
+    # No review saw the red tip: the re-review covers both fixes, and the proof that round 1 made due stays due.
+    again = rig.prompt("reviewer-2")
+    assert f"The fix is {rig.sha('01', 'implementer')}..{second}" in again and "demo/export.py:2" in again
+
+
+def test_a_red_gate_on_the_fixer_commit_of_round_4_blocks_the_ticket(tmp_path):
+    rig = Inside(tmp_path, gate={"subjects": ["fix: 01 round 4"]})
+    rig.run(plan(**{"01/reviewer": [review("01", [STUCK])] * 4, "01/fixer": [fix("01", n) for n in (1, 2, 3, 4)]}))
+    last = rig.calls("01", "fixer")[-1]["sha"]
+    assert f"BLOCKED at the gate: the gate is red on {last[:7]}" in blocked(rig)
+    assert len(rig.calls("01", "reviewer")) == 4 and not (rig.folder() / "findings-4.json").exists()
+
+
 def test_round_3_stays_on_its_entry_when_the_implementer_has_no_next_entry(tmp_path):
     rig = Inside(tmp_path, ONE, {"implementer": [OPUS]})
     rig.run(plan(**{"01/reviewer": [review("01", [STUCK])] * 3 + [review("01")], "01/fixer": [fix("01", n) for n in (1, 2, 3)]}))

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/implement-spec/tests/test_walk.py

@@ -102,7 +102,8 @@ def git(*a):
 conf = json.loads((rig / "gate.json").read_text())
 (rig / "gates").mkdir(exist_ok=True)
 branch = git("rev-parse", "--abbrev-ref", "HEAD")
-code = 1 if conf.get("all") or branch in conf.get("red", []) else 0
+subject = git("log", "-1", "--format=%s")
+code = 1 if conf.get("all") or branch in conf.get("red", []) or subject in conf.get("subjects", []) else 0
 rec = dict(t0=time.time(), cwd=os.path.realpath(os.getcwd()), commit=git("rev-parse", "HEAD"), branch=branch,
            status=git("status", "--short"), base=os.environ.get("IMPLEMENT_SPEC_BASE"),
            pycache=os.environ.get("PYTHONPYCACHEPREFIX"), exit=code)

package/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-15T12:44:26.687Z",
+  "generatedAt": "2026-10-15T17:09:44.505Z",
   "skills": [
     {
       "name": "backlog",
@@ -46,8 +46,8 @@
     },
     {
       "name": "implement-spec",
-      "version": "0.1.9",
-      "hash": "sha256-a2864cb6013ba8ee10af5b597b4376b89507efce8c6acecfbeca5db7389623ea",
+      "version": "0.1.11",
+      "hash": "sha256-c58d05ad78d3d1ae1381c02a96f4e5ca64f6387cea2b16ac5e1997bf52767467",
       "description": "Implement a specification in code."
     },
     {