ctrlrelay 0.7.0__tar.gz → 0.8.1__tar.gz

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-09-04
+
+### Fixed
+
+- **`ctrlrelay ci wait` was unconditionally broken on `gh` releases without
+  `--json` support on `pr checks`** (confirmed on gh 2.45.0, the current
+  Ubuntu 24.04 package — no newer version exists in the distro repos, so
+  this wasn't an "apt upgrade" problem for anyone on that platform).
+  `GitHubCLI.get_pr_checks` shelled out to `gh pr checks --json ...`; on an
+  affected install every single poll failed with `unknown flag: --json`,
+  which `PRVerifier.wait_for_checks` treats as transient and retries —
+  so every `ci wait` call was guaranteed to eat its full timeout and then
+  fail, regardless of the PR's actual state. Reproduced directly and
+  confirmed as the likely cause behind some "session never signaled DONE"
+  reports. Switched to `gh pr view --json statusCheckRollup`, stable since
+  early gh 2.x and always exit-0 regardless of check state, with a new
+  normalizer mapping its two GraphQL shapes (`CheckRun` and the legacy
+  `StatusContext`) into the `{name, state, bucket, link}` shape
+  `PRVerifier` already expects. See #145.
+
+## [0.8.0] - 2026-09-04
+
+### Added
+
+- **`ci_wait_timeout_seconds`: per-repo cap on the dev pipeline's
+  `ctrlrelay ci wait` call.** The dev pipeline prompt tells Claude to run
+  `ctrlrelay ci wait --pr <PR> --repo <repo> --timeout 600` before
+  signaling DONE — a single blocking call, hardcoded to 10 minutes, that
+  generates zero tokens while it polls GitHub. Measured directly on a real
+  session: two `ci wait` calls accounted for 12 of a 26-minute run, versus
+  under 35K output tokens generated the whole time — the wall-clock cost
+  is CI runtime, not model work. `ci_wait_timeout_seconds` (default `600`,
+  unchanged behavior) lets a repo with a faster CI suite cap that single
+  call lower instead of always budgeting the full 10 minutes.
+
 ## [0.7.0] - 2026-09-04
 
 ### Added
@@ -1232,7 +1267,9 @@ pipeline).
   per-phase implementation plans (Phase 0 through Phase 4).
 - `docs/Claude_Code_Project_Guide.md` — project development guide.
 
-[Unreleased]: https://github.com/AInvirion/ctrlrelay/compare/v0.7.0...HEAD
+[Unreleased]: https://github.com/AInvirion/ctrlrelay/compare/v0.8.1...HEAD
+[0.8.1]: https://github.com/AInvirion/ctrlrelay/compare/v0.8.0...v0.8.1
+[0.8.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.5.0...v0.6.0
 [0.1.3]: https://github.com/AInvirion/ctrlrelay/releases/tag/v0.1.3

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ctrlrelay
-Version: 0.7.0
+Version: 0.8.1
 Summary: Local-first orchestrator for headless coding agents across multiple GitHub repos
 Project-URL: Homepage, https://github.com/AInvirion/ctrlrelay
 Project-URL: Documentation, https://ainvirion.github.io/ctrlrelay/

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/config/orchestrator.yaml.example

@@ -146,3 +146,9 @@ repos: []
   #     # Matching is case-insensitive. Defaults to [] (assignment alone
   #     # is sufficient, same as today).
   #     require_labels: []
+  #     # Hard cap, in seconds, on the single `ctrlrelay ci wait` call the
+  #     # dev pipeline prompt runs before signaling DONE. Lower this to
+  #     # match how long this repo's CI actually takes — no tokens are
+  #     # generated while blocked in this call, so a slow default here
+  #     # just adds idle wall-clock time. Defaults to 600 (10 minutes).
+  #     ci_wait_timeout_seconds: 600

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/docs/configuration.md

@@ -201,6 +201,7 @@ and ask the operator), or `never` (skip).
 | `exclude_labels` | `["manual", "operator", "instruction"]` | Issue labels that tell the poller "this isn't for the agent". See [exclude_labels](#reposautomationexclude_labels) below. |
 | `include_labels` | `[]` | Issue labels that opt an issue **into** the dev pipeline regardless of who is (or isn't) assigned. See [include_labels](#reposautomationinclude_labels) below. |
 | `require_labels` | `[]` | Issue labels that gate the plain-assignment trigger: when set, assignment alone is no longer enough — the issue must also carry one of these labels. See [require_labels](#reposautomationrequire_labels) below. |
+| `ci_wait_timeout_seconds` | `600` | Hard cap, in seconds, on the single `ctrlrelay ci wait` call the dev pipeline prompt tells Claude to run before signaling DONE. See [ci_wait_timeout_seconds](#reposautomationci_wait_timeout_seconds) below. |
 
 The current secops and dev pipelines read these settings to bias their prompts
 to Claude — they're not enforced by hard-coded checks.
@@ -345,6 +346,31 @@ repos:
   picked up yet.
 - `exclude_labels` is still checked first, same precedence as always.
 
+### repos[].automation.ci_wait_timeout_seconds
+
+The dev pipeline prompt tells Claude to run `ctrlrelay ci wait --pr <PR>
+--repo <repo> --timeout <N>` before signaling DONE — a single blocking call
+that polls GitHub every 15s until CI finishes, fails, or the timeout hits.
+No tokens get generated while it's blocked; on a repo with a slow CI suite,
+that one call can eat most of a session's wall-clock time.
+
+```yaml
+repos:
+  - name: "your-org/your-repo"
+    local_path: "~/Projects/your-repo"
+    automation:
+      ci_wait_timeout_seconds: 300
+```
+
+- Default: `600` (10 minutes).
+- Lower it to match how long the repo's CI actually takes — a repo with a
+  2-minute CI suite gains nothing from a 10-minute cap.
+- A timeout here isn't a failure: `ctrlrelay ci wait` exits 2 (not 1) when
+  the deadline hits with checks still pending, and the prompt tells Claude
+  to treat that as acceptable and hand off rather than loop.
+- This does not change the overall session timeout (`agent.default_timeout_seconds`,
+  default 1800s) — it only bounds the one `ci wait` call.
+
 ## schedules
 
 In-process cron jobs run by the poller daemon. All expressions are

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ctrlrelay"
-version = "0.7.0"
+version = "0.8.1"
 description = "Local-first orchestrator for headless coding agents across multiple GitHub repos"
 readme = "README.md"
 requires-python = ">=3.12"

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/src/ctrlrelay/cli.py

@@ -748,6 +748,7 @@ def run_dev(
             state_db=db,
             transport=None,
             contexts_dir=config.paths.contexts,
+            ci_wait_timeout_seconds=repo_config.automation.ci_wait_timeout_seconds,
         )
 
     try:
@@ -1273,6 +1274,7 @@ def poller_start(
                         state_db=state_db,
                         transport=connected_transport,
                         contexts_dir=config.paths.contexts,
+                        ci_wait_timeout_seconds=repo_config.automation.ci_wait_timeout_seconds,
                     )
 
                 # Lock-conflict retry hook. The poller marks issues seen

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/src/ctrlrelay/core/config.py

@@ -201,6 +201,13 @@ class AutomationConfig(BaseModel):
     # precedence so "not for the agent at all" overrides "agent does
     # this but differently".
     task_labels: list[str] = Field(default_factory=lambda: ["task"])
+    # Hard cap, in seconds, on a single `ctrlrelay ci wait` call the dev
+    # pipeline prompt tells Claude to run before signaling DONE. A repo
+    # with slow CI can eat most of a session's wall-clock time sitting
+    # in this one blocking call generating zero tokens; a fast-CI repo
+    # doesn't need anywhere near the 600s default. Lower this per-repo
+    # to match how long that repo's CI actually takes.
+    ci_wait_timeout_seconds: int = 600
 
 
 _REPO_NAME_RE = re.compile(r"^[A-Za-z0-9._-]+/[A-Za-z0-9._-]+$")

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/src/ctrlrelay/core/github.py

@@ -13,6 +13,65 @@ class GitHubError(Exception):
     """Raised when gh CLI operations fail."""
 
 
+# CheckRun.conclusion values (only present once status == "COMPLETED").
+_CHECK_RUN_PASS = frozenset({"SUCCESS", "NEUTRAL"})
+_CHECK_RUN_SKIP = frozenset({"SKIPPED"})
+_CHECK_RUN_CANCEL = frozenset({"CANCELLED"})
+# StatusContext.state values (the legacy commit-status API, e.g. CLA bots).
+_STATUS_CONTEXT_PASS = frozenset({"SUCCESS"})
+_STATUS_CONTEXT_PENDING = frozenset({"PENDING", "EXPECTED"})
+
+
+def _normalize_check(entry: dict[str, Any]) -> dict[str, Any]:
+    """Map one `statusCheckRollup` entry to the `{name, state, bucket,
+    link}` shape `PRVerifier` expects (see #145).
+
+    `statusCheckRollup` mixes two GraphQL shapes: `CheckRun` (Actions
+    jobs, CodeQL — `status`/`conclusion`) and `StatusContext` (the
+    legacy commit-status API, e.g. CLA bots — `state`). `bucket` is
+    the only field the rest of the app actually branches on; `state`
+    is carried through for parity/debugging.
+    """
+    if entry.get("__typename") == "StatusContext":
+        state = entry.get("state", "")
+        if state in _STATUS_CONTEXT_PASS:
+            bucket = "pass"
+        elif state in _STATUS_CONTEXT_PENDING:
+            bucket = "pending"
+        else:
+            bucket = "fail"
+        return {
+            "name": entry.get("context", ""),
+            "state": state,
+            "bucket": bucket,
+            "link": entry.get("targetUrl", ""),
+        }
+
+    status = entry.get("status", "")
+    conclusion = entry.get("conclusion")
+    if status != "COMPLETED":
+        bucket = "pending"
+        state = status
+    elif conclusion in _CHECK_RUN_PASS:
+        bucket = "pass"
+        state = conclusion
+    elif conclusion in _CHECK_RUN_SKIP:
+        bucket = "skipping"
+        state = conclusion
+    elif conclusion in _CHECK_RUN_CANCEL:
+        bucket = "cancel"
+        state = conclusion
+    else:
+        bucket = "fail"
+        state = conclusion or "FAILURE"
+    return {
+        "name": entry.get("name", ""),
+        "state": state,
+        "bucket": bucket,
+        "link": entry.get("detailsUrl", ""),
+    }
+
+
 def _find_gh() -> str:
     """Find gh binary, checking common paths if not in PATH."""
     gh = shutil.which("gh")
@@ -146,57 +205,30 @@ class GitHubCLI:
     ) -> list[dict[str, Any]]:
         """Get status checks for a PR.
 
-        Bypasses `_run_gh` because we need to inspect stdout, stderr, and the
-        exit code independently. `gh pr checks`:
-          - prints a JSON array on stdout when checks exist (exits non-zero
-            when any are pending or failing — the payload is still valid)
-          - prints "no checks reported on the '<branch>' branch" to stderr
-            and exits non-zero when the PR has no checks at all
-          - emits arbitrary errors to stderr (auth, network, missing PR) on
-            non-zero exit with empty stdout
-
-        We return [] only for the "no checks reported" case. Real failures
-        raise GitHubError so callers can distinguish "no CI configured" from
-        "gh is broken".
+        Uses `gh pr view --json statusCheckRollup` rather than `gh pr
+        checks --json ...` — the latter's `--json` flag isn't available
+        on `gh` releases before it was added (confirmed absent on gh
+        2.45.0, the current Ubuntu 24.04 package with no newer version
+        in the distro repos), which made this unconditionally broken on
+        those installs regardless of the PR's actual state (#145).
+
+        `gh pr view --json` always exits 0 once the PR itself resolves —
+        the check states live in the JSON, not the exit code — so unlike
+        the old implementation, a non-zero exit here is always a genuine
+        failure (auth, network, missing PR): `_run_gh` already raises
+        `GitHubError` for that case. No checks yet (or ever) on the PR
+        just means an empty `statusCheckRollup` list — the ambiguity
+        between "not registered yet" and "no CI configured" is handled
+        by `PRVerifier`'s empty-streak retry, not here.
         """
-        cmd = [
-            self.gh_binary,
-            "pr", "checks",
-            str(pr_number),
+        stdout = await self._run_gh(
+            "pr", "view", str(pr_number),
             "--repo", repo,
-            "--json", "name,state,bucket,link",
-        ]
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
+            "--json", "statusCheckRollup",
         )
-        try:
-            stdout_bytes, stderr_bytes = await asyncio.wait_for(
-                proc.communicate(), timeout=self.timeout,
-            )
-        except asyncio.TimeoutError:
-            proc.kill()
-            try:
-                await proc.wait()
-            except Exception:
-                pass
-            raise
-        stdout = stdout_bytes.decode().strip()
-        stderr = stderr_bytes.decode().strip()
-
-        # JSON payload on stdout — always trust it, regardless of exit code.
-        if stdout:
-            return json.loads(stdout)
-
-        # No stdout. Distinguish "no CI configured" from genuine failures by
-        # looking for gh's well-known "no checks reported" message.
-        if "no checks reported" in stderr.lower():
-            return []
-
-        # Anything else is an honest-to-goodness failure. Don't pretend the
-        # repo has no CI.
-        raise GitHubError(f"gh pr checks failed: {stderr}")
+        payload = json.loads(stdout)
+        rollup = payload.get("statusCheckRollup") or []
+        return [_normalize_check(entry) for entry in rollup]
 
     def all_checks_passed(self, checks: list[dict[str, Any]]) -> bool:
         """Check if all PR checks passed."""

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/src/ctrlrelay/pipelines/dev.py

@@ -330,6 +330,7 @@ class DevPipeline:
         issue_title = extra.get("issue_title", "")
         issue_body = extra.get("issue_body", "")
         branch_name = extra.get("branch_name", "")
+        ci_wait_timeout_seconds = extra.get("ci_wait_timeout_seconds", 600)
         state_file_path = str(state_file) if state_file else "/tmp/state.json"
 
         return f"""You are working on issue #{issue_number} in repository {repo}.
@@ -349,7 +350,7 @@ Execute the following workflow:
 4. Push the branch and open a PR that references the issue
 5. Before signaling DONE, verify the PR is mergeable:
    - Wait for CI by running EXACTLY this command (do NOT improvise bash):
-     `ctrlrelay ci wait --pr <PR> --repo {repo} --timeout 600`
+     `ctrlrelay ci wait --pr <PR> --repo {repo} --timeout {ci_wait_timeout_seconds}`
      Exit codes: 0 = all checks passed, 1 = a check failed (investigate,
      fix, push, then re-run the wait), 2 = hard timeout while CI is still
      pending (treat as acceptable — hand off and let the orchestrator
@@ -608,6 +609,7 @@ async def run_dev_issue(
     max_fix_attempts: int = DEFAULT_MAX_FIX_ATTEMPTS,
     max_blocked_rounds: int = DEFAULT_MAX_BLOCKED_ROUNDS,
     pr_verifier: PRVerifier | None = None,
+    ci_wait_timeout_seconds: int = 600,
 ) -> PipelineResult:
     """Run dev pipeline for a single issue."""
     session_id = f"dev-{repo.replace('/', '-')}-{issue_number}-{uuid.uuid4().hex[:8]}"
@@ -715,6 +717,7 @@ async def run_dev_issue(
                 "issue_title": issue.get("title", ""),
                 "issue_body": issue.get("body", ""),
                 "branch_name": branch_name,
+                "ci_wait_timeout_seconds": ci_wait_timeout_seconds,
             },
         )
 

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/tests/test_config.py

@@ -640,3 +640,67 @@ class TestAutomationRequireLabels:
 
         assert config.repos[0].automation.require_labels == ["ctrlrelay:auto"]
         assert config.repos[1].automation.require_labels == []
+
+
+class TestAutomationCiWaitTimeout:
+    """ci_wait_timeout_seconds caps the single `ctrlrelay ci wait` call the
+    dev pipeline prompt tells Claude to run before signaling DONE. Default
+    600 preserves today's behavior."""
+
+    def test_default_ci_wait_timeout_is_600(self) -> None:
+        auto = AutomationConfig()
+        assert auto.ci_wait_timeout_seconds == 600
+
+    def test_ci_wait_timeout_override_accepts_int(self) -> None:
+        auto = AutomationConfig(ci_wait_timeout_seconds=300)
+        assert auto.ci_wait_timeout_seconds == 300
+
+    def test_config_without_ci_wait_timeout_key_defaults_to_600(
+        self, sample_config_dict: dict, tmp_path: Path
+    ) -> None:
+        sample_config_dict["repos"] = [
+            {
+                "name": "owner/repo",
+                "local_path": "~/Projects/repo",
+                "automation": {"dependabot_patch": "auto"},
+            }
+        ]
+        cfg_path = tmp_path / "cfg.yaml"
+        cfg_path.write_text(yaml.dump(sample_config_dict))
+
+        config = load_config(cfg_path)
+
+        assert config.repos[0].automation.ci_wait_timeout_seconds == 600
+
+    def test_ci_wait_timeout_from_yaml(
+        self, sample_config_dict: dict, tmp_path: Path
+    ) -> None:
+        sample_config_dict["repos"] = [
+            {
+                "name": "owner/repo",
+                "local_path": "~/Projects/repo",
+                "automation": {"ci_wait_timeout_seconds": 300},
+            }
+        ]
+        cfg_path = tmp_path / "cfg.yaml"
+        cfg_path.write_text(yaml.dump(sample_config_dict))
+
+        config = load_config(cfg_path)
+
+        assert config.repos[0].automation.ci_wait_timeout_seconds == 300
+
+    def test_ci_wait_timeout_rejects_non_int(
+        self, sample_config_dict: dict, tmp_path: Path
+    ) -> None:
+        sample_config_dict["repos"] = [
+            {
+                "name": "owner/repo",
+                "local_path": "~/Projects/repo",
+                "automation": {"ci_wait_timeout_seconds": "fast"},
+            }
+        ]
+        cfg_path = tmp_path / "cfg.yaml"
+        cfg_path.write_text(yaml.dump(sample_config_dict))
+
+        with pytest.raises(ConfigError, match="ci_wait_timeout_seconds"):
+            load_config(cfg_path)

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/tests/test_dev_pipeline.py

@@ -61,6 +61,65 @@ class TestDevPipeline:
             "prompt should explicitly ban `until`/`while` bash CI-wait loops"
         )
 
+    def test_prompt_uses_default_ci_wait_timeout_when_not_configured(self) -> None:
+        """No ci_wait_timeout_seconds in extra: falls back to 600, matching
+        AutomationConfig's default so an unconfigured repo behaves as before."""
+        from ctrlrelay.pipelines.dev import DevPipeline
+
+        pipeline = DevPipeline(
+            dispatcher=MagicMock(),
+            github=MagicMock(),
+            worktree=MagicMock(),
+            dashboard=None,
+            state_db=MagicMock(),
+            transport=None,
+        )
+
+        prompt = pipeline._build_prompt(
+            repo="owner/repo",
+            issue_number=42,
+            extra={
+                "issue_title": "t",
+                "issue_body": "b",
+                "branch_name": "fix/issue-42",
+            },
+            session_id="dev-42",
+            state_file=Path("/tmp/state.json"),
+        )
+
+        assert "ctrlrelay ci wait --pr <PR> --repo owner/repo --timeout 600" in prompt
+
+    def test_prompt_uses_configured_ci_wait_timeout(self) -> None:
+        """A repo with a slow (or fast) CI can override the 600s default so
+        the dev pipeline doesn't spend most of a session blocked in one
+        `ctrlrelay ci wait` call."""
+        from ctrlrelay.pipelines.dev import DevPipeline
+
+        pipeline = DevPipeline(
+            dispatcher=MagicMock(),
+            github=MagicMock(),
+            worktree=MagicMock(),
+            dashboard=None,
+            state_db=MagicMock(),
+            transport=None,
+        )
+
+        prompt = pipeline._build_prompt(
+            repo="owner/repo",
+            issue_number=42,
+            extra={
+                "issue_title": "t",
+                "issue_body": "b",
+                "branch_name": "fix/issue-42",
+                "ci_wait_timeout_seconds": 300,
+            },
+            session_id="dev-42",
+            state_file=Path("/tmp/state.json"),
+        )
+
+        assert "ctrlrelay ci wait --pr <PR> --repo owner/repo --timeout 300" in prompt
+        assert "--timeout 600" not in prompt
+
     @pytest.mark.asyncio
     async def test_run_dispatches_claude_session(self, tmp_path: Path) -> None:
         """Should dispatch Claude session with issue context."""

{ctrlrelay-0.7.0 → ctrlrelay-0.8.1}/tests/test_github.py

@@ -98,14 +98,55 @@ class TestGitHubCLI:
             assert "--squash" in args
 
     @pytest.mark.asyncio
-    async def test_get_pr_checks(self) -> None:
-        """Should get PR check status using the bucket field."""
+    async def test_get_pr_checks_uses_pr_view_not_pr_checks(self) -> None:
+        """`gh pr checks --json` isn't available on gh releases before it
+        shipped (confirmed absent on gh 2.45.0, the current Ubuntu 24.04
+        package - #145) - get_pr_checks must use `gh pr view --json
+        statusCheckRollup` instead, which has been stable since early gh 2.x."""
         from ctrlrelay.core.github import GitHubCLI
 
-        mock_output = json.dumps([
-            {"name": "tests", "state": "SUCCESS", "bucket": "pass"},
-            {"name": "lint", "state": "SUCCESS", "bucket": "pass"},
-        ])
+        mock_output = json.dumps({"statusCheckRollup": []})
+
+        mock_proc = MagicMock()
+        mock_proc.communicate = AsyncMock(return_value=(mock_output.encode(), b""))
+        mock_proc.returncode = 0
+
+        with patch(
+            "asyncio.create_subprocess_exec", AsyncMock(return_value=mock_proc)
+        ) as mock_exec:
+            gh = GitHubCLI()
+            await gh.get_pr_checks("owner/repo", 42)
+
+        args = mock_exec.call_args[0]
+        assert "checks" not in args
+        assert ("pr", "view", "42") == args[1:4]
+        assert "--repo" in args and "owner/repo" in args
+        assert "statusCheckRollup" in args
+
+    @pytest.mark.asyncio
+    async def test_get_pr_checks_normalizes_check_run_entries(self) -> None:
+        """CheckRun entries (Actions jobs, CodeQL) use status/conclusion,
+        not state - must be mapped into the {name, state, bucket, link}
+        shape PRVerifier's bucket logic expects."""
+        from ctrlrelay.core.github import GitHubCLI
+
+        mock_output = json.dumps({"statusCheckRollup": [
+            {
+                "__typename": "CheckRun", "name": "pytest",
+                "status": "COMPLETED", "conclusion": "SUCCESS",
+                "detailsUrl": "https://example.com/1",
+            },
+            {
+                "__typename": "CheckRun", "name": "lint",
+                "status": "IN_PROGRESS", "conclusion": None,
+                "detailsUrl": "https://example.com/2",
+            },
+            {
+                "__typename": "CheckRun", "name": "flaky-e2e",
+                "status": "COMPLETED", "conclusion": "FAILURE",
+                "detailsUrl": "https://example.com/3",
+            },
+        ]})
 
         mock_proc = MagicMock()
         mock_proc.communicate = AsyncMock(return_value=(mock_output.encode(), b""))
@@ -115,45 +156,54 @@ class TestGitHubCLI:
             gh = GitHubCLI()
             checks = await gh.get_pr_checks("owner/repo", 42)
 
-        assert len(checks) == 2
-        assert all(c["bucket"] == "pass" for c in checks)
+        by_name = {c["name"]: c for c in checks}
+        assert by_name["pytest"]["bucket"] == "pass"
+        assert by_name["lint"]["bucket"] == "pending"
+        assert by_name["flaky-e2e"]["bucket"] == "fail"
 
     @pytest.mark.asyncio
-    async def test_get_pr_checks_parses_json_on_nonzero_exit(self) -> None:
-        """`gh pr checks` exits non-zero while checks are pending/failing, but
-        still prints the JSON payload to stdout. get_pr_checks must parse it
-        instead of silently returning []."""
-
+    async def test_get_pr_checks_normalizes_status_context_entries(self) -> None:
+        """StatusContext entries (the legacy commit-status API, e.g. CLA
+        bots) use `state` and `context` instead of CheckRun's fields."""
         from ctrlrelay.core.github import GitHubCLI
 
-        mock_output = json.dumps([
-            {"name": "ci", "state": "IN_PROGRESS", "bucket": "pending"},
-        ])
+        mock_output = json.dumps({"statusCheckRollup": [
+            {
+                "__typename": "StatusContext",
+                "context": "verification/cla-signed",
+                "state": "SUCCESS",
+                "targetUrl": "https://example.com/cla",
+            },
+        ]})
 
         mock_proc = MagicMock()
         mock_proc.communicate = AsyncMock(return_value=(mock_output.encode(), b""))
-        mock_proc.returncode = 1  # non-zero, checks still pending
+        mock_proc.returncode = 0
 
         with patch("asyncio.create_subprocess_exec", AsyncMock(return_value=mock_proc)):
             gh = GitHubCLI()
             checks = await gh.get_pr_checks("owner/repo", 42)
 
-        assert len(checks) == 1
-        assert checks[0]["bucket"] == "pending"
+        assert checks == [{
+            "name": "verification/cla-signed",
+            "state": "SUCCESS",
+            "bucket": "pass",
+            "link": "https://example.com/cla",
+        }]
 
     @pytest.mark.asyncio
     async def test_get_pr_checks_returns_empty_when_no_checks_reported(self) -> None:
-        """gh prints 'no checks reported on the <branch> branch' to stderr
-        and exits non-zero when the PR genuinely has no CI. Treat that as []."""
+        """A PR with no CI at all (or checks not registered yet) just comes
+        back as an empty statusCheckRollup - gh pr view exits 0 either way,
+        no stderr-message sniffing needed."""
 
         from ctrlrelay.core.github import GitHubCLI
 
         mock_proc = MagicMock()
         mock_proc.communicate = AsyncMock(return_value=(
-            b"",
-            b"no checks reported on the 'fix/issue-10' branch\n",
+            json.dumps({"statusCheckRollup": []}).encode(), b"",
         ))
-        mock_proc.returncode = 1
+        mock_proc.returncode = 0
 
         with patch("asyncio.create_subprocess_exec", AsyncMock(return_value=mock_proc)):
             gh = GitHubCLI()
@@ -163,9 +213,9 @@ class TestGitHubCLI:
 
     @pytest.mark.asyncio
     async def test_get_pr_checks_raises_on_genuine_failure(self) -> None:
-        """Auth/network/missing-PR failures print errors to stderr and leave
-        stdout empty. Must raise GitHubError rather than silently returning []
-        (which would be indistinguishable from 'no CI configured')."""
+        """Auth/network/missing-PR failures exit non-zero with an error on
+        stderr. Must raise GitHubError (via _run_gh) rather than silently
+        returning [] (which would be indistinguishable from 'no CI configured')."""
 
         from ctrlrelay.core.github import GitHubCLI, GitHubError