@caddis/cli 0.4.56 → 0.4.58

package/bundles/antigravity-plugin/hooks.json

@@ -9,7 +9,8 @@
             "command": "python guard_agy.py",
             "windows": "python guard_agy.py",
             "linux": "python3 guard_agy.py",
-            "osx": "python3 guard_agy.py"
+            "osx": "python3 guard_agy.py",
+            "timeout": 30
           }
         ]
       }

package/bundles/antigravity-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "caddis",
-  "version": "1.3.142",
+  "version": "1.3.144",
   "description": "caddis — agent-agnostic dev harness as an Antigravity (agy) plugin: TDD skills + commands, single-sourced with the Claude Code plugin."
 }

package/bundles/antigravity-plugin/scripts/caddis_adhoc.py

@@ -12,6 +12,7 @@ import ast
 import json
 import os
 import re
+import secrets
 import shutil
 import subprocess
 import sys
@@ -131,7 +132,8 @@ def slugify_prompt(prompt: str) -> str:
     if not slug:
         slug = "task"
     date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-    return f"{date_str}-{slug}"
+    # Random suffix: two runs on the same day and topic must never share a branch, plan or run dir.
+    return f"{date_str}-{slug}-{secrets.token_hex(3)}"
 
 
 def synthesize_plan(
@@ -168,18 +170,73 @@ Task requirements are met, existing tests pass, and new test assertions verify t
     return plan_path, slug, title
 
 
+def session_key() -> str:
+    """Id of this agent session, safe in a file name. One checkout can host several sessions."""
+    for var in ("CADDIS_SESSION_ID", "CLAUDE_SESSION_ID", "CLAUDE_CODE_SESSION_ID"):
+        raw = os.environ.get(var, "").strip()
+        key = re.sub(r"[^A-Za-z0-9_-]", "-", raw)[:64].strip("-")
+        if key:
+            return key
+    return "nosession"
+
+
+def _adhoc_dir(repo: Path) -> Path:
+    return repo / ".caddis" / "orchestrator" / "adhoc"
+
+
 def adhoc_latest_path(repo: Path) -> Path:
-    return repo / ".caddis" / "orchestrator" / "adhoc" / "latest.json"
+    return _adhoc_dir(repo) / f"latest-{session_key()}.json"
+
+
+def write_latest(repo: Path, state: dict) -> None:
+    path = adhoc_latest_path(repo)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(state, indent=2) + "\n", encoding="utf-8")
 
 
 def read_latest(repo: Path) -> dict | None:
     path = adhoc_latest_path(repo)
     if not path.is_file():
-        return None
+        # Migration: the old single latest.json belongs to whoever reads it first. The rename is
+        # atomic, so exactly one session adopts it and no other session ever sees it.
+        legacy = _adhoc_dir(repo) / "latest.json"
+        if not legacy.is_file():
+            return None
+        try:
+            os.replace(legacy, path)
+        except OSError:
+            return None
     try:
-        return json.loads(path.read_text(encoding="utf-8"))
+        data = json.loads(path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
         return None
+    return data if isinstance(data, dict) else None
+
+
+def move_branch(repo: Path, branch: str, commit_sha: str, base_sha: str) -> str:
+    """Point `branch` at `commit_sha`. Return "" on success, else why it was refused.
+
+    An existing branch is moved only when its tip is merged into the base, equals the new commit, or
+    is the tip this session recorded for it. Otherwise it holds work that moving would orphan.
+    """
+    tip = git_output(repo, "rev-parse", "--verify", "--quiet", f"refs/heads/{branch}")
+    if tip and tip != commit_sha:
+        merged = subprocess.run(
+            ["git", "-C", str(repo), "merge-base", "--is-ancestor", tip, base_sha],
+            capture_output=True,
+        ).returncode == 0
+        state = read_latest(repo) or {}
+        own = state.get("branch") == branch and state.get("commit_sha") == tip
+        if not merged and not own:
+            return (f"branch '{branch}' has commits not merged into {base_sha[:7]} "
+                    f"(tip {tip[:7]}); refusing to move it. Delete or merge it first.")
+    res = subprocess.run(
+        ["git", "-C", str(repo), "branch", "-f", branch, commit_sha],
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+    )
+    if res.returncode != 0:
+        return f"branch update failed: {res.stderr.strip()}"
+    return ""
 
 
 # Tool caches every gate run regenerates. They are the only ignored files a worktree may be
@@ -355,7 +412,7 @@ def run_adhoc(
         }
         if len(kept_paths) > 1:
             state["kept_worktrees"] = [str(path) for path in kept_paths]
-        adhoc_latest_path(repo).write_text(json.dumps(state, indent=2) + "\n", encoding="utf-8")
+        write_latest(repo, state)
         return EXIT_FAIL
 
     worktree_str = packet.get("worktree")
@@ -468,20 +525,14 @@ def run_adhoc(
 
         if not reason:
             try:
-                branch_res = subprocess.run(
-                    ["git", "-C", str(repo), "branch", "-f", adhoc_branch, commit_sha],
-                    capture_output=True, text=True, encoding="utf-8", errors="replace",
-                )
-                if branch_res.returncode != 0:
-                    reason = f"branch update failed: {branch_res.stderr.strip()}"
-                else:
+                reason = move_branch(repo, adhoc_branch, commit_sha, base_sha)
+                if not reason:
                     # An OSError from the helper (git not runnable) lands in the `except OSError` below.
                     problem = caddis_worktree_safety.safe_remove_worktree(repo, wt_path)
                     if problem or wt_path.exists():
                         reason = problem or f"worktree remove failed: {wt_path}"
                     else:
-                        kept_worktree = None
-                        subprocess.run(["git", "-C", str(repo), "worktree", "prune"], capture_output=True)
+                        kept_worktree = None  # `git worktree remove` dropped its registration; no prune (robustness #19)
                         attempt_branch = packet.get("branch")
                         if attempt_branch and attempt_branch != adhoc_branch:
                             subprocess.run(
@@ -503,7 +554,7 @@ def run_adhoc(
     diff_stat = git_output(repo, "diff", "--shortstat", base_sha, diff_ref)
     diff_names = verified_names or changed_files
 
-    # Save state to latest.json
+    # Save this session's state (latest-<session>.json)
     state = {
         "slug": slug,
         "title": title,
@@ -525,7 +576,7 @@ def run_adhoc(
         "plan_path": plan_rel,
         "created": datetime.now(timezone.utc).isoformat(),
     }
-    adhoc_latest_path(repo).write_text(json.dumps(state, indent=2) + "\n", encoding="utf-8")
+    write_latest(repo, state)
 
     # Render Verdict Card
     is_success = not reason and kept_worktree is None
@@ -618,13 +669,8 @@ def drop_adhoc(repo: Path) -> int:
         if problem:
             print(f"[mmr] Could not remove kept worktree: {problem}")
             return EXIT_FAIL
-        pruned = subprocess.run(
-            ["git", "-C", str(repo), "worktree", "prune"],
-            capture_output=True, text=True, encoding="utf-8", errors="replace",
-        )
-        if pruned.returncode != 0:
-            print(f"[mmr] Could not prune worktrees: {pruned.stderr.strip()}")
-            return EXIT_FAIL
+        # No `git worktree prune` here: it drops the registrations of every other worktree whose folder is missing
+        # for the moment, and `git worktree remove` has already dropped this one (robustness #19).
 
     if branch:
         subprocess.run(["git", "-C", str(repo), "branch", "-D", branch], capture_output=True)

package/bundles/antigravity-plugin/scripts/caddis_checkout_guard.py

@@ -3,6 +3,11 @@
 `shared` (handoff-integrity Phase 5, the design of fleet-handoff Phase 2): a checkout is shared when its root
 `AGENTS.md` says `Shared checkout: yes`, or when `git status` lists a path this session did not change. In a
 shared checkout handoff writes no tracked file there; it uses `caddis_docs_pr.py` instead.
+
+`checkout_is_shared` and `foreign_changes` (robustness #11) are the two halves of that test. `caddis_lanes.py accept`
+calls them before it fast-forwards the session checkout, and the commands that switch, rebase or pull run
+`shared` first (pr-merge, ship-pr, ship-merge, cloud-phases). A linked worktree is never shared: AGENTS.md is
+tracked, so a worktree carries the line too, but the worktree is the safe place the rule sends the work to.
 """
 
 from __future__ import annotations
@@ -79,28 +84,74 @@ def _norm(path: str) -> str:
     return path.strip().replace("\\", "/")
 
 
-def is_shared_checkout(root: Path, own_files: set[str]) -> tuple[bool, str]:
-    """(True, reason) when handoff must not write tracked files in `root`; else (False, "").
+class CheckoutStatusError(OSError):
+    """`git status` could not run in the checkout, so foreign changes cannot be ruled out."""
 
-    `Shared checkout: no` in AGENTS.md never hides a change this session did not make. When git status cannot
-    run, the checkout counts as shared: a wrong "no" could commit another session's files.
-    """
-    agents = Path(root) / "AGENTS.md"
+
+def _repo_top(start: Path) -> Path:
+    """The nearest folder at or above `start` that holds `.git` (a folder or a gitfile); `start` when none does."""
+    here = Path(start).resolve()
+    for folder in (here, *here.parents):
+        if (folder / ".git").exists():
+            return folder
+    return here
+
+
+def is_linked_worktree(top: Path) -> bool:
+    """True when `top/.git` is a gitfile that points into `<repo>/.git/worktrees/` (a `git worktree add` tree)."""
+    gitfile = Path(top) / ".git"
+    if not gitfile.is_file():
+        return False
     try:
-        text = agents.read_text(encoding="utf-8", errors="replace") if agents.is_file() else ""
+        line = gitfile.read_text(encoding="utf-8", errors="replace").strip()
     except OSError:
-        text = ""
-    if SHARED_RE.search(text):
-        return True, "AGENTS.md says Shared checkout: yes"
+        return False
+    return line.lower().startswith("gitdir:") and "/worktrees/" in line.replace("\\", "/").lower()
+
+
+def checkout_is_shared(root: Path) -> bool:
+    """True when the repo that holds `root` says `Shared checkout: yes` in its top `AGENTS.md` (any case).
+
+    A linked worktree is never shared (see the module note). A missing or unreadable AGENTS.md means no."""
+    top = _repo_top(Path(root))
+    if is_linked_worktree(top):
+        return False
+    try:
+        text = (top / "AGENTS.md").read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return False
+    return bool(SHARED_RE.search(text))
+
+
+def foreign_changes(root: Path, own_files: set[str] | None = None) -> list[str]:
+    """The dirty paths in `root` that are not in `own_files`, in `git status` order. A rename counts both paths.
+
+    Without session tracking (`own_files` None or empty), every dirty path counts. Raises CheckoutStatusError
+    when `git status` fails: the caller must then treat the checkout as unsafe."""
     ret, lines = get_porcelain_lines(Path(root))
     if ret != 0:
-        return True, "git status failed, so changes by other sessions cannot be ruled out"
-    own = {_norm(p) for p in own_files}
+        raise CheckoutStatusError(f"git status failed in {root}")
+    own = {_norm(p) for p in (own_files or set())}
     foreign: list[str] = []
     for entry in lines:
         for path in entry_paths(entry):
             if _norm(path) not in own and path not in foreign:
                 foreign.append(path)
+    return foreign
+
+
+def is_shared_checkout(root: Path, own_files: set[str]) -> tuple[bool, str]:
+    """(True, reason) when handoff must not write tracked files in `root`; else (False, "").
+
+    `Shared checkout: no` in AGENTS.md never hides a change this session did not make. When git status cannot
+    run, the checkout counts as shared: a wrong "no" could commit another session's files.
+    """
+    if checkout_is_shared(Path(root)):
+        return True, "AGENTS.md says Shared checkout: yes"
+    try:
+        foreign = foreign_changes(Path(root), own_files)
+    except CheckoutStatusError:
+        return True, "git status failed, so changes by other sessions cannot be ruled out"
     if foreign:
         return True, "changes not made by this session: " + ", ".join(foreign[:3])
     return False, ""

package/bundles/antigravity-plugin/scripts/caddis_docs_pr.py

@@ -209,11 +209,10 @@ def _remove(main: Path, worktree: Path, branch: str) -> None:
         caddis_worktree_safety.safe_remove_worktree(main, worktree, force_locked=True, env=roadmap._quiet_env())
     except OSError:
         pass
-    for args in (("worktree", "prune"), ("branch", "-D", branch)):
-        try:
-            _git(main, *args, check=False)
-        except (roadmap.RoadmapError, OSError):
-            pass
+    try:  # no `git worktree prune`: it would drop other tools' registrations too (robustness #19)
+        _git(main, "branch", "-D", branch, check=False)
+    except (roadmap.RoadmapError, OSError):
+        pass
     if worktree.exists():
         caddis_worktree_safety.remove_tree(worktree)
 
@@ -234,6 +233,7 @@ def finish(worktree: Path, title: str, body: str, out=print) -> int:
         out("PR: none")
         return caddis_exit.CLEAN
     pushed = False
+    pushed_tip = ""
     try:
         gh_repo = roadmap.gh_repo_of(main)
         if gh_repo is None:
@@ -242,14 +242,15 @@ def finish(worktree: Path, title: str, body: str, out=print) -> int:
         _git(worktree, "commit", "--quiet", "-m", title)
         _git(worktree, "push", "--quiet", "-u", "origin", branch)
         pushed = True
+        pushed_tip = _git(worktree, "rev-parse", "HEAD").stdout.strip()  # the only tip we may delete
         url = open_pr(gh_repo, branch, base, title, body)
     except (DocsPrError, roadmap.RoadmapError, OSError) as exc:
         out(f"docs PR failed: {exc}")
         out(f"PATCH: {patch}")
         if pushed:
-            try:
-                _git(main, "push", "--quiet", "origin", "--delete", branch, check=False)
-            except (roadmap.RoadmapError, OSError):
+            try:  # only while the remote tip is still the commit we pushed
+                _git(main, *caddis_worktree_safety.remote_delete_args(branch, pushed_tip), check=False)
+            except (roadmap.RoadmapError, OSError, ValueError):
                 pass
         _remove(main, worktree, branch)
         return getattr(exc, "code", caddis_exit.NOT_RUN)

package/bundles/antigravity-plugin/scripts/caddis_gate.py

@@ -602,7 +602,26 @@ def is_test_file(path: str) -> bool:
     return False
 
 
+_STEERING_FILENAMES = {"conftest.py", "pytest.ini", "pyproject.toml", "setup.cfg", "tox.ini"}
+
+
+def is_review_steering_file(path: str) -> bool:
+    """True for config that steers reviews, merges or tests: never tier 0, and never a 0-reviewer "1-small".
+
+    `.caddis/*.toml` (review/implement routing, merge-chain checks, spend cap), any `conftest.py`, the pytest and
+    packaging config, and `.github/workflows/**`. A fix diff that changes these can turn a gate off, so it is reviewed.
+    """
+    norm = path.replace("\\", "/").lower().removeprefix("./")
+    if norm.startswith(".caddis/") and norm.endswith(".toml"):
+        return True
+    if norm.startswith(".github/workflows/"):
+        return True
+    return norm.rsplit("/", 1)[-1] in _STEERING_FILENAMES
+
+
 def is_tier0_file(path: str) -> bool:
+    if is_review_steering_file(path):
+        return False
     norm = path.replace("\\", "/").lower()
     if norm.startswith("./"):
         norm = norm[2:]
@@ -685,6 +704,8 @@ def review_tier(files: list[tuple[str, int]], plan_risk: str = "normal") -> str:
     non_tier0_lines = sum(lines for _, lines in non_tier0)
     if review_triggers(non_tier0_paths, non_tier0_lines):
         return "2"
+    if any(is_review_steering_file(p) for p in non_tier0_paths):
+        return "1"
     has_test = any(is_test_file(p) for p, _ in files)
     if non_tier0_lines <= 40 and has_test:
         return "1-small"

package/bundles/antigravity-plugin/scripts/caddis_lanes.py

@@ -33,6 +33,7 @@ except ModuleNotFoundError as exc:
     import caddis_exit
     from caddis_heavy_slot import HeavySlotBusy, heavy_slot
 
+import caddis_checkout_guard
 import caddis_routing
 import caddis_redact
 import caddis_spend
@@ -274,7 +275,6 @@ def remove_phase_worktree(
         problem = f"worktree remove left {resolved} on disk"
     if problem:
         raise LaneConfigError(problem)
-    _git_output(repo_root, "worktree", "prune")
     if delete_branch:
         _git_output(repo_root, "branch", "-D", "--", wt.branch)
 
@@ -1265,7 +1265,10 @@ def child_env(base: dict, lane: str, model: str) -> dict:
     for name in LANE_SECRET_VARS:
         env.pop(name, None)
     env.update(LANE_NO_PROMPT_ENV)
-    env["CADDIS_HEADLESS"] = "1"
+    try:
+        env = caddis_spend.bump_headless_depth(env)  # sets CADDIS_HEADLESS=1 and the depth (robustness #19)
+    except caddis_spend.HeadlessDepthExceeded as exc:
+        raise LaneConfigError(str(exc)) from exc
     if lane == "glm":
         env["OSS_MODEL"] = model
     return env
@@ -2165,6 +2168,28 @@ def _printable(value: object) -> str:
     return _CONTROL_CHARS.sub("", text)
 
 
+# Accept fast-forwards the SESSION checkout. In a checkout a dev service serves from, or one that holds a peer's
+# uncommitted edits, that moves files under them (robustness #11). The lane's own scaffolding is not a peer's change.
+_LANE_OWN_PREFIX = ".caddis/orchestrator/"
+
+
+def shared_checkout_reason(repo: Path) -> str:
+    """Why accept must not fast-forward `repo`, or ''. Shared (AGENTS.md) and/or foreign changes (git status):
+    every reason that holds, joined with "; ", so an --allow-shared audit records all of them."""
+    reasons = []
+    if caddis_checkout_guard.checkout_is_shared(repo):
+        reasons.append("AGENTS.md says Shared checkout: yes")
+    try:
+        dirty = caddis_checkout_guard.foreign_changes(repo)
+    except caddis_checkout_guard.CheckoutStatusError:
+        reasons.append("git status failed, so changes by other sessions cannot be ruled out")
+        dirty = []
+    foreign = [path for path in dirty if not path.replace("\\", "/").startswith(_LANE_OWN_PREFIX)]
+    if foreign:
+        reasons.append("changes not made by this lane: " + ", ".join(foreign[:3]))
+    return "; ".join(reasons)
+
+
 def _accept_command(
     args,
     repo: Path,
@@ -2221,6 +2246,16 @@ def _accept_command(
             or packet["worktree_digest"] != worktree_digest(wt.path, files)):
         print("refusing: worktree changed since check")
         return EXIT_FAIL
+    unsafe = shared_checkout_reason(repo)
+    if unsafe and not getattr(args, "allow_shared", False):
+        print(f"refusing: the session checkout is not safe to fast-forward ({_printable(unsafe)}). "
+              "Run the programme from a worktree of origin/<default> under %TEMP% (git worktree add), "
+              "or pass --allow-shared to fast-forward here anyway")
+        return EXIT_USAGE
+    if unsafe:
+        packet["allow_shared"] = unsafe
+        write_packet(packet_path, packet)
+        print(f"ALLOW SHARED: {_printable(unsafe)}")
     if args.override_review is not None:
         packet["override_review"] = args.override_review
         write_packet(packet_path, packet)
@@ -2458,6 +2493,8 @@ def main(argv: list[str] | None = None) -> int:
     _add_phase_arguments(accept)
     accept.add_argument("--message", required=True)
     accept.add_argument("--override-review")
+    accept.add_argument("--allow-shared", action="store_true",
+                        help="fast-forward a shared checkout or one with foreign changes anyway (recorded)")
     abandon = subparsers.add_parser("abandon")
     _add_phase_arguments(abandon)
     finish = subparsers.add_parser("finish")

package/bundles/antigravity-plugin/scripts/caddis_merge_chain.py

@@ -1,14 +1,16 @@
 """Merge pull requests one at a time, from green CI to a verified deploy, and stop the line at the first problem.
 
 For each PR (design section 11): when BEHIND, update the branch and cancel the old head's runs (force-cancel after
-2 minutes); a cancelled run on the head is re-run, never merged on; "no checks reported" waits; a failed check stops;
-no merge while a push run is in progress on the default branch; squash merge with --match-head-commit; then the merge
-SHA must get a push run, and `caddis_prod_check.py` must pass before the next PR starts. A STOP file is checked before
-each update-branch and each merge. --dry-run makes read-only `gh` calls and prints what it would do.
+2 minutes); a cancelled run on the head is re-run, never merged on; "checks green" is ci-watch's verdict on the
+`statusCheckRollup` of the PR's `headRefOid` (never the `gh pr checks` table, which can show an older head); "no
+checks reported" waits, then stops; every check skipped stops (no job ran), both unless --allow-no-checks; a failed
+check stops; no merge while a push run is in progress on the default branch; squash merge with --match-head-commit;
+then the merge SHA must get a push run, and `caddis_prod_check.py` must pass before the next PR starts. A STOP file is
+checked before each update-branch and each merge. --dry-run makes read-only `gh` calls and prints what it would do.
 
 Exit 0 when every PR merged and verified; 1 at the first stop; 3 when the profile cannot be read.
 
-Usage: caddis_merge_chain.py [--repo PATH] [--gh-repo OWNER/NAME] [--docs-only] [--dry-run]
+Usage: caddis_merge_chain.py [--repo PATH] [--gh-repo OWNER/NAME] [--docs-only] [--dry-run] [--allow-no-checks]
                              [--stop-file PATH ...] <pr> [<pr> ...]
 """
 
@@ -21,13 +23,15 @@ from pathlib import Path
 
 try:
     import caddis_exit
+    import caddis_lanes
     import caddis_prod_check as prod
 except ModuleNotFoundError as exc:
-    if exc.name not in {"caddis_exit", "caddis_prod_check"}:
+    if exc.name not in {"caddis_exit", "caddis_lanes", "caddis_prod_check", "caddis_heavy_slot", "caddis_routing"}:
         raise
     sys.path.insert(0, str(Path(__file__).resolve().parent))
     sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "claude-harness" / "scripts"))
     import caddis_exit
+    import caddis_lanes
     import caddis_prod_check as prod
 
 MAX_ATTEMPTS = 8
@@ -45,6 +49,7 @@ class Stop(Exception):
 class ChainContext(prod.Context):
     stop_files: list[Path] = field(default_factory=list)
     docs_only: bool = False
+    allow_no_checks: bool = False
 
 
 def _stop_check(ctx: ChainContext, before: str) -> None:
@@ -90,26 +95,63 @@ def _head_run(ctx: ChainContext, branch: str, head: str) -> dict | None:
     return next((r for r in runs if r.get("headSha") == head), None)  # type: ignore[union-attr]
 
 
-def _wait_checks(ctx: ChainContext, pr: int) -> str:
-    """Return 'pass', 'fail' or 'cancel'. Raise Stop when no check reports in time."""
+def _rollup_state(rollup: object, allow_no_checks: bool) -> tuple[str, str]:
+    """(state, detail) from the head's `statusCheckRollup`, by ci-watch's own verdict (`caddis_lanes._rollup_verdict`).
+
+    state is 'pass', 'fail', 'cancel', 'pending', 'none' (no check reported) or 'skipped' (every check skipped).
+    A check that only SKIPPED or NEUTRAL ran no job, so a rollup with no SUCCESS proves nothing: 'skipped', unless
+    the owner passed --allow-no-checks for a repo that has no CI at all.
+    """
+    verdict = caddis_lanes._rollup_verdict(rollup)
+    if verdict is None:
+        return ("pass", "no checks reported (--allow-no-checks)") if allow_no_checks else ("none", "")
+    _green, failed, unfinished = verdict
+    if failed:
+        cancelled = {str(i.get("name") or i.get("context") or "?") for i in rollup  # type: ignore[union-attr]
+                     if isinstance(i, dict) and str(i.get("conclusion") or "").upper() == "CANCELLED"}
+        return ("cancel" if set(failed) <= cancelled else "fail"), ", ".join(failed)
+    if unfinished:
+        return "pending", ", ".join(unfinished)
+    ran = sum(1 for i in rollup if isinstance(i, dict)  # type: ignore[union-attr]
+              and str(i.get("conclusion") or i.get("state") or "").upper() == "SUCCESS")
+    if not ran:
+        return ("pass", "every check skipped (--allow-no-checks)") if allow_no_checks else ("skipped", "")
+    return "pass", ""
+
+
+def _wait_checks(ctx: ChainContext, pr: int, head: str) -> str:
+    """Return 'pass', 'fail', 'cancel' or 'moved' for the commit `head`. Raise Stop when no proof comes in time.
+
+    The verdict is ci-watch's: the `statusCheckRollup` of the PR's `headRefOid`, read in one `gh pr view`. The
+    `gh pr checks` table is never read: it can still show an older head's checks.
+    """
     deadline = ctx.clock.now() + CHECKS_WAIT_MINUTES * 60
     while True:
-        proc = ctx.gh("pr", "checks", str(pr), "--json", "name,bucket")
-        if proc.rc != 0 and not proc.out.strip() and "no checks reported" not in proc.err + proc.out:
+        proc = ctx.gh("pr", "view", "--json", "headRefOid,statusCheckRollup", str(pr))
+        if proc.rc != 0:
             # Auth or network failure: say so now instead of waiting 30 minutes as if no check had started.
-            raise Stop(f"#{pr}: gh pr checks failed: {(proc.err or proc.out).strip()[:300]}")
-        buckets: list[str] = []
+            raise Stop(f"#{pr}: gh pr view failed: {(proc.err or proc.out).strip()[:300]}")
         try:
-            buckets = [c.get("bucket", "") for c in prod.json.loads(proc.out)] if proc.out.strip() else []
+            data = prod.json.loads(proc.out) if proc.out.strip() else {}
         except ValueError:
-            buckets = []
-        if "fail" in buckets:
-            return "fail"
-        if "cancel" in buckets:
-            return "cancel"
-        if buckets and "pending" not in buckets:
+            data = {}
+        if not isinstance(data, dict):
+            data = {}
+        if data.get("headRefOid") != head:
+            ctx.out(f"  #{pr}: the head is now {str(data.get('headRefOid'))[:12]}, not {head[:12]}; reading again")
+            return "moved"
+        state, detail = _rollup_state(data.get("statusCheckRollup"), ctx.allow_no_checks)
+        if state == "pass":
+            if detail:
+                ctx.out(f"  #{pr}: WARNING: {detail} on head {head[:12]}")
             return "pass"
-        waiting = "no checks reported yet" if not buckets else "checks pending"
+        if state in ("fail", "cancel"):
+            return state
+        if state == "skipped":
+            raise Stop(f"#{pr}: every check on head {head[:12]} was skipped: no job ran, so this is not a pass. "
+                       "If this repo has no CI at all, run again with --allow-no-checks")
+        waiting = (f"checks pending ({detail})" if state == "pending" else
+                   "no checks reported yet (if this repo has no CI at all, run again with --allow-no-checks)")
         if ctx.clock.now() >= deadline:
             raise Stop(f"#{pr}: {waiting} after {CHECKS_WAIT_MINUTES} min")
         if ctx.dry_run:
@@ -159,10 +201,10 @@ def merge_one(ctx: ChainContext, pr: int) -> str | None:
                 ctx.out(f"  WARNING: re-run of {run['databaseId']} refused: {(rerun.err or rerun.out).strip()[:200]}")
             ctx.clock.sleep(60)
             continue
-        result = _wait_checks(ctx, pr)
+        result = _wait_checks(ctx, pr, head)
         if result == "fail":
             raise Stop(f"#{pr}: CI failed on head {head[:12]}")
-        if result == "cancel":
+        if result in ("cancel", "moved"):
             continue
         if ctx.dry_run:
             ctx.out(f"#{pr} ({merge_state}): checks green; would wait for idle push runs, then squash-merge {head[:12]}")
@@ -219,6 +261,8 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--profile", type=Path, help="default: <repo>/.caddis/prod-check.toml")
     parser.add_argument("--docs-only", action="store_true", help="the PRs change docs only: expect no deploy")
     parser.add_argument("--dry-run", action="store_true", help="read-only gh calls; print the steps")
+    parser.add_argument("--allow-no-checks", action="store_true",
+                        help="the repo has no CI: accept a head with no check, or with every check skipped")
     parser.add_argument("--stop-file", type=Path, action="append", default=[],
                         help="extra STOP file (~/.caddis/STOP is always checked)")
     args = parser.parse_args(argv)
@@ -229,6 +273,7 @@ def main(argv: list[str] | None = None) -> int:
         return caddis_exit.NOT_RUN
     ctx = ChainContext(run=prod.real_runner(args.repo), clock=prod.Clock(), profile=profile, repo=args.repo,
                        gh_repo=args.gh_repo, dry_run=args.dry_run, docs_only=args.docs_only,
+                       allow_no_checks=args.allow_no_checks,
                        stop_files=[Path.home() / ".caddis" / "STOP", *args.stop_file])
     return merge_chain(ctx, args.prs)