code-coordinator 0.5.66__tar.gz → 0.5.68__tar.gz

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.66
+Version: 0.5.68
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT
@@ -101,6 +101,7 @@ Every issue moves through four gated stages:
 
 Two rules shape the flow:
 
+- **A green Test verdict is only worth the suite behind it.** The Test stage runs `repos[].ci_command` when set, else `smoke_tests.default_command`, else `repos[].test_command`. If CI runs a *wider* suite than the gate does, "Test passed" means "some tests passed", not "the branch is good" — declare `ci_command` so the two agree (#2091). `dispatch_smoke` logs a warning for any GitHub-backed repo that hasn't.
 - **Test precedes Review.** The smoke test runs *before* the PR/review — the natural order. Review auto-dispatch is **held** until the work has a `passed`/`skipped` Test verdict. A work item left at *Pending Test* gets no review, so it never merges — this is the single most common reason a story silently stalls. Record the verdict with `coord test <id> --passed|--skipped|--fail`, or the **P / S / F** keys on the Test stage in the TUI. The displayed stage order and this gate both come from `pipeline.default_gates` in `coordinator.yml` (default `[test, review, merge]`).
 - **A failed test routes exactly like a request-changes review.** Both drop the issue back to a fix on the *same* branch (`coord fix`, or the interactive `--fix-of`), never an orphan.
 
@@ -427,6 +428,7 @@ repos:
     develop_branch: develop      # opt in to the milestone feature-branch model (see Milestones)
     build_command: "npm run build"
     test_command: "npm test"
+    ci_command: "npm run test:e2e" # what CI actually runs — the Test gate prefers this (#2091)
     artifact_paths:              # stash built binaries so `coord pull-artifact` can rsync them
       - dist/
 

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/README.md

@@ -61,6 +61,7 @@ Every issue moves through four gated stages:
 
 Two rules shape the flow:
 
+- **A green Test verdict is only worth the suite behind it.** The Test stage runs `repos[].ci_command` when set, else `smoke_tests.default_command`, else `repos[].test_command`. If CI runs a *wider* suite than the gate does, "Test passed" means "some tests passed", not "the branch is good" — declare `ci_command` so the two agree (#2091). `dispatch_smoke` logs a warning for any GitHub-backed repo that hasn't.
 - **Test precedes Review.** The smoke test runs *before* the PR/review — the natural order. Review auto-dispatch is **held** until the work has a `passed`/`skipped` Test verdict. A work item left at *Pending Test* gets no review, so it never merges — this is the single most common reason a story silently stalls. Record the verdict with `coord test <id> --passed|--skipped|--fail`, or the **P / S / F** keys on the Test stage in the TUI. The displayed stage order and this gate both come from `pipeline.default_gates` in `coordinator.yml` (default `[test, review, merge]`).
 - **A failed test routes exactly like a request-changes review.** Both drop the issue back to a fix on the *same* branch (`coord fix`, or the interactive `--fix-of`), never an orphan.
 
@@ -387,6 +388,7 @@ repos:
     develop_branch: develop      # opt in to the milestone feature-branch model (see Milestones)
     build_command: "npm run build"
     test_command: "npm test"
+    ci_command: "npm run test:e2e" # what CI actually runs — the Test gate prefers this (#2091)
     artifact_paths:              # stash built binaries so `coord pull-artifact` can rsync them
       - dist/
 

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.66
+Version: 0.5.68
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT
@@ -101,6 +101,7 @@ Every issue moves through four gated stages:
 
 Two rules shape the flow:
 
+- **A green Test verdict is only worth the suite behind it.** The Test stage runs `repos[].ci_command` when set, else `smoke_tests.default_command`, else `repos[].test_command`. If CI runs a *wider* suite than the gate does, "Test passed" means "some tests passed", not "the branch is good" — declare `ci_command` so the two agree (#2091). `dispatch_smoke` logs a warning for any GitHub-backed repo that hasn't.
 - **Test precedes Review.** The smoke test runs *before* the PR/review — the natural order. Review auto-dispatch is **held** until the work has a `passed`/`skipped` Test verdict. A work item left at *Pending Test* gets no review, so it never merges — this is the single most common reason a story silently stalls. Record the verdict with `coord test <id> --passed|--skipped|--fail`, or the **P / S / F** keys on the Test stage in the TUI. The displayed stage order and this gate both come from `pipeline.default_gates` in `coordinator.yml` (default `[test, review, merge]`).
 - **A failed test routes exactly like a request-changes review.** Both drop the issue back to a fix on the *same* branch (`coord fix`, or the interactive `--fix-of`), never an orphan.
 
@@ -427,6 +428,7 @@ repos:
     develop_branch: develop      # opt in to the milestone feature-branch model (see Milestones)
     build_command: "npm run build"
     test_command: "npm test"
+    ci_command: "npm run test:e2e" # what CI actually runs — the Test gate prefers this (#2091)
     artifact_paths:              # stash built binaries so `coord pull-artifact` can rsync them
       - dist/
 

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/code_coordinator.egg-info/SOURCES.txt

@@ -451,6 +451,7 @@ tests/test_bug_intake.py
 tests/test_build_worker_image_env_update.py
 tests/test_cargo_cache.py
 tests/test_ci_acceptance_gate_1950.py
+tests/test_ci_parity_2091.py
 tests/test_ci_store.py
 tests/test_claim.py
 tests/test_cli_acceptance.py

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/code_coordinator.egg-info/scm_file_list.json

@@ -481,6 +481,7 @@
     "tests/test_build_worker_image_env_update.py",
     "tests/test_cargo_cache.py",
     "tests/test_ci_acceptance_gate_1950.py",
+    "tests/test_ci_parity_2091.py",
     "tests/test_ci_store.py",
     "tests/test_claim.py",
     "tests/test_cli_acceptance.py",

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.66",
+  "tag": "0.5.68",
   "distance": 0,
-  "node": "g2a4b596d92f5df37f20c5e4da4b887658112a74f",
+  "node": "g5c48dfa28457562839e0f3dc02d1de4a685b0a3d",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/coord/commands/drive_queue.py

@@ -1006,6 +1006,105 @@ def _fetch_gate_a_pending(entries: list) -> dict[str, bool]:
     return pending
 
 
+def _fetch_live_ci_gate(
+    entries: list, config_path: Path | None
+) -> dict[str, bool]:
+    """``{entry_key: still_blocked}`` for every ``parked`` entry whose OWN
+    park reason is CI-shaped (#1891/#1892) — a FRESH, single-entry
+    re-derivation of the SAME gate ``coord merge --plan`` computes, taken
+    live, right now, this tick (#2182).
+
+    THE GAP THIS CLOSES. On the daemon host — the only machine that ever
+    runs this tick (``docs/AGENT_OPERATIONS.md``) — ``_fetch_board_view``
+    reads the local DB directly and never populates ``merge_plan`` at all
+    (see ``_local_merge_queue_rows``'s docstring): it is *computed*, not
+    stored, and computing it needs a live ``ci_store``/``gh_ops`` this
+    read-only board fetch deliberately does not build. So
+    ``IssueFacts.merge_ci_pending_live`` is unconditionally ``False`` on
+    every parked entry this tick ever sees, and the ONLY thing that used to
+    release such a park was :data:`coord.drive_queue.PARK_STALE_SECONDS` —
+    up to 45 minutes — even at the instant CI actually reports, because
+    nothing on the read path ever re-checked. claude-coordinator#2159 is
+    that gap caught live: at 03:25:46 UTC, ``coord merge --dry-run`` for the
+    entry read READY (no gate objection) while ``coord drive-queue list``,
+    reading the SAME board a moment later, still read ``parked`` — the two
+    surfaces disagreeing about the exact same fact.
+
+    THE FIX. Scoped to the bounded few entries actually sitting in
+    ``parked`` on a CI reason right now (typically 0-1, never the whole
+    merge queue — see :func:`coord.merge_queue.entry_gate_status`'s
+    docstring for why this deliberately does NOT call the whole-queue
+    :func:`coord.merge_queue.plan` instead), so paying for a live
+    ``gh``-backed check per entry, every ~3-minute tick, is the same
+    "small and predictable" cost an operator's own ``coord merge --plan``
+    already pays on demand — not the unbounded per-tick GitHub polling
+    #1344 removed from the read path.
+
+    Fails OPEN per entry and CLOSED overall in the sense that matters: a key
+    simply ABSENT from the returned dict (an unreadable config, a
+    ``ci_store`` that failed to build, an entry ``coord.merge_queue.
+    load_queue()`` no longer carries, or any other exception) leaves that
+    entry to :func:`coord.drive_queue.plan_tick`'s pre-#2182 fallback — the
+    #2158 :data:`~coord.drive_queue.PARK_STALE_SECONDS` ceiling — exactly as
+    if this function had never run. A transient failure here degrades to
+    the OLD (already-shipped, already-bounded) behaviour, never to a wedge
+    and never to a wrongly-forced resume.
+
+    Gated on ``resolve_board_service() is None`` (the daemon-host tick,
+    same guard :func:`_fetch_board_view` uses for its own local-DB top-up):
+    on a thin client the daemon's real ``GET /board`` already carries a live
+    ``merge_plan`` section, so ``build_board_view`` already resolves
+    ``merge_ci_pending_live=True`` there on its own and this function would
+    have nothing to add — worse, ``coord.state.load_board()`` guards against
+    being called from a thin client at all (#615).
+    """
+    from coord.merge_queue import is_ci_infra_reason, is_ci_pending_reason  # noqa: PLC0415
+
+    targets = [
+        e for e in entries
+        if e.state == STATE_PARKED
+        and (
+            is_ci_pending_reason(getattr(e, "last_reason", "") or "")
+            or is_ci_infra_reason(getattr(e, "last_reason", "") or "")
+        )
+    ]
+    if not targets:
+        return {}
+
+    from coord.board_service import resolve as resolve_board_service  # noqa: PLC0415
+
+    if resolve_board_service() is not None:
+        return {}
+
+    try:
+        from coord import github_ops as _gh_ops  # noqa: PLC0415
+        from coord import merge_queue as _mq  # noqa: PLC0415
+        from coord.ci_store import build_ci_store  # noqa: PLC0415
+        from coord.commands._common import _load_config  # noqa: PLC0415
+        from coord.state import load_board as _load_board  # noqa: PLC0415
+
+        cfg = _load_config(config_path)
+        board = _load_board()
+        ci_store = build_ci_store(cfg.ci_store.type)
+        queue_by_key = {
+            entry_key(q.repo_name, q.issue_number): q for q in _mq.load_queue()
+        }
+    except Exception:  # noqa: BLE001 — see the fail-soft note above
+        return {}
+
+    overrides: dict[str, bool] = {}
+    for e in targets:
+        q = queue_by_key.get(e.key)
+        if q is None or not q.pr_number:
+            continue
+        try:
+            status, _reason = _mq.entry_gate_status(q, board, cfg, ci_store, _gh_ops)
+        except Exception:  # noqa: BLE001 — leave this one entry to the ceiling
+            continue
+        overrides[e.key] = status != _mq.PLAN_READY
+    return overrides
+
+
 def _launch_argv(entry: QueueEntry, config_path: Path | None) -> list[str]:
     """The ``coord drive --tmux`` argv for *entry*.
 
@@ -1318,6 +1417,14 @@ def drive_queue_tick(
         # tick when no entry is parked that way — which is the common case.
         gate_a_pending = _fetch_gate_a_pending(entries)
 
+        # #2182: for every entry parked on a CI reason, a fresh single-entry
+        # re-derivation of its gate, taken live THIS tick — see
+        # `_fetch_live_ci_gate`'s docstring for the gap this closes (a park
+        # on the daemon-host tick could previously be released only by the
+        # #2158 45-minute ceiling, never by CI actually reporting, because
+        # this tick's board read never computes a live `merge_plan`).
+        live_ci_gate = _fetch_live_ci_gate(entries, config_path)
+
         # #2101: release cordons. THIS is the hole the issue names — the
         # queue's launcher had zero pause awareness (`coord/drive.py` checks
         # pause only when routing a *worker*), so a cordoned host kept getting
@@ -1349,6 +1456,7 @@ def drive_queue_tick(
             exit_dead_end=exit_dead_end,
             gate_a_pending=gate_a_pending,
             cordons=cordons,
+            live_ci_gate=live_ci_gate,
         )
 
         if reconcile_only:

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/coord/commands/plan_followup.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 import sys
 import time
+from dataclasses import dataclass
 from pathlib import Path
 
 import click
@@ -470,7 +471,69 @@ def review(assignment_id: str, config_path: Path) -> None:
         click.echo(f"  pr: {assignment.pr_url}")
 
 
-def _ci_failure_story(cfg: Config, assignment) -> str | None:
+@dataclass(frozen=True)
+class CiRead:
+    """#2091: the outcome of the live-CI read, with "did not read" separated
+    from "read it, it was green".
+
+    Before #2091 this path collapsed both into a bare ``None``, and the
+    refusal message told the operator only that no red CI was found.  In
+    coord-portal #14 the PR *was* red (``gh pr checks 42`` said so) — the
+    read had simply never happened, and the operator was left to guess which
+    of six silent short-circuits fired.  ``unread_reason`` names it.
+
+    Invariants:
+
+    * ``story`` set                          → CI was read and is RED.
+    * ``story is None`` and no ``unread_reason``  → CI was read, nothing red.
+    * ``unread_reason`` set                  → **no read happened**; this is
+      not evidence of green, and callers must say so out loud.
+    """
+
+    story: str | None = None
+    unread_reason: str | None = None
+    pr_number: int | None = None
+
+    @property
+    def is_red(self) -> bool:
+        return self.story is not None
+
+    @property
+    def was_read(self) -> bool:
+        return self.unread_reason is None
+
+
+def _resolve_pr_number(repo_github: str, assignment) -> int | None:
+    """PR number for *assignment*, from its ``pr_url`` or (#2091) its branch.
+
+    The stored ``pr_url`` is missing on any row whose PR was opened out of
+    band, or that predates PR creation — and that alone used to silently
+    disable the whole live-CI fallback.  Fall back to asking GitHub which PR
+    has this branch as its head, which is the same question ``gh pr checks``
+    answers from a checkout.
+    """
+    from coord.drive import _extract_pr_number
+
+    pr_number = _extract_pr_number(getattr(assignment, "pr_url", None) or "")
+    if pr_number is not None:
+        return pr_number
+
+    branch = getattr(assignment, "branch", None)
+    if not branch:
+        return None
+    try:
+        from coord import github_ops  # noqa: PLC0415
+
+        pr = github_ops.find_pr_for_branch(repo_github, branch)
+    except Exception:  # noqa: BLE001 — advisory lookup, never fatal
+        return None
+    if not isinstance(pr, dict):
+        return None
+    number = pr.get("number")
+    return number if isinstance(number, int) else None
+
+
+def _read_ci(cfg: Config, assignment) -> CiRead:
     """#1622 (part 3): a rendered summary of *assignment*'s FAILED CI checks.
 
     The third legitimate fix trigger, alongside a request-changes review and a
@@ -479,37 +542,70 @@ def _ci_failure_story(cfg: Config, assignment) -> str | None:
     checkout — and the fix has to land on the *existing* branch, because the
     thing being fixed is what gates the merge.
 
-    Read-only and fail-quiet: returns ``None`` when CI is not configured
-    (``ci_store.type: none`` ⇒ :class:`coord.ci_store.NoOpCi`, whose
-    ``is_available`` is False), when the branch has no PR to read checks for,
-    when the read raises, or when every completed check is affirmatively
-    passing.  ``None`` therefore means "no CI evidence of a failure", never
-    "CI is green" — the caller must not treat it as a verdict.
+    Read-only and fail-quiet, but no longer fail-*silent* (#2091): every path
+    that declines to read returns a :class:`CiRead` carrying the reason, so
+    the caller can distinguish "CI is green" from "nobody looked".
     """
     from coord.ci_store import build_ci_store, failed_checks, summarize
-    from coord.drive import _extract_pr_number
 
     repo = cfg.repo(assignment.repo_name)
-    if repo is None or not repo.github:
-        return None
-
-    pr_number = _extract_pr_number(assignment.pr_url or "")
-    if pr_number is None:
-        return None
+    if repo is None:
+        return CiRead(unread_reason=f"repo {assignment.repo_name!r} is not in coordinator.yml")
+    if not repo.github:
+        return CiRead(
+            unread_reason=f"repo {repo.name!r} has no `github:` slug configured"
+        )
 
+    # Availability first (#2091): `_resolve_pr_number`'s branch fallback can
+    # shell out to `gh`, and there is no point paying for that when the store
+    # will refuse to read anything anyway.
     store = build_ci_store(cfg.ci_store.type)
     if not store.is_available:
-        return None
+        return CiRead(
+            unread_reason=(
+                f"ci_store.type is {cfg.ci_store.type!r}, so live CI is never "
+                "read — set it to 'github' in coordinator.yml"
+            ),
+        )
+
+    pr_number = _resolve_pr_number(repo.github, assignment)
+    if pr_number is None:
+        return CiRead(
+            unread_reason=(
+                "no PR could be resolved for this row (its `pr_url` is empty "
+                f"and no open PR has head branch {getattr(assignment, 'branch', None)!r})"
+            )
+        )
 
     try:
         checks = store.list_checks_for_pr(repo.github, pr_number)
     except Exception as exc:  # noqa: BLE001 — CI read is advisory, never fatal
         click.echo(f"warning: could not read CI checks for PR #{pr_number}: {exc}", err=True)
-        return None
+        return CiRead(
+            pr_number=pr_number,
+            unread_reason=f"the CI read for PR #{pr_number} raised: {exc}",
+        )
+
+    if not checks:
+        return CiRead(
+            pr_number=pr_number,
+            unread_reason=f"PR #{pr_number} reported no checks at all",
+        )
 
     failed = failed_checks(checks)
     if not failed:
-        return None
+        # A genuine read that found nothing red. Note this still includes the
+        # case where every check is *pending* — `failed_checks` only considers
+        # completed ones — so say which, rather than implying a settled green.
+        if not any(c.status == "completed" for c in checks):
+            return CiRead(
+                pr_number=pr_number,
+                unread_reason=(
+                    f"every check on PR #{pr_number} is still running "
+                    f"({summarize(checks)}) — no completed verdict yet"
+                ),
+            )
+        return CiRead(pr_number=pr_number)
 
     lines = [
         f"CI on PR #{pr_number} is RED ({summarize(checks)}).",
@@ -525,7 +621,7 @@ def _ci_failure_story(cfg: Config, assignment) -> str | None:
         "reproduce locally where you can, and fix the root cause on THIS "
         "branch — a new branch would not carry the change CI is gating on.",
     ]
-    return "\n".join(lines)
+    return CiRead(story="\n".join(lines), pr_number=pr_number)
 
 
 def _fix_from_review(
@@ -695,8 +791,10 @@ def _fix_from_review(
         "work that ran under claude-pty, or (#2051) dispatch a WORK-row fix "
         "when neither the test verdict nor a live CI read shows a failure — "
         "for when the caller knows the PR is red but the check missed it "
-        "(ci_store not configured, a transient read error). Does NOT override "
-        "max_review_iterations or the #522 terminal-work guard."
+        "(ci_store not configured, a transient read error). Since #2091 the "
+        "refusal names which of those it was, so check the `note:` line "
+        "before reaching for this. Does NOT override max_review_iterations "
+        "or the #522 terminal-work guard."
     ),
 )
 def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> None:
@@ -729,17 +827,37 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
     # #1622 (part 3): red CI is the third trigger.  Only consulted when the
     # local test gate has NOT already failed, so the cheap in-DB path stays
     # zero-I/O and the existing failure story keeps priority.
-    ci_story = None if test_failed else _ci_failure_story(cfg, assignment)
+    ci_read = CiRead() if test_failed else _read_ci(cfg, assignment)
+    ci_story = ci_read.story
+
+    # #2091: the stored Test verdict says PASSED while the branch's live CI
+    # says RED — the coord-portal #14 shape.  Both are "the tests", and they
+    # disagree; that is a fact about the Test gate (it ran a narrower suite
+    # than CI), not a detail of this dispatch, so name it rather than
+    # quietly preferring one.
+    if ci_read.is_red and (
+        assignment.test_state == "passed" or assignment.smoke_test == "pass"
+    ):
+        stored_verdict = assignment.test_state or assignment.smoke_test
+        click.echo(
+            f"conflict (#2091): assignment {assignment_id} has a stored Test "
+            f"verdict of {stored_verdict!r} "
+            f"but CI on PR #{ci_read.pr_number} is RED on the same branch. "
+            "The Test stage ran a narrower suite than CI — set "
+            f"repos[{assignment.repo_name}].ci_command to what CI runs so "
+            "the gate stops reporting green on a red branch.",
+            err=True,
+        )
 
     # #2051: none of the three doors (failed test verdict, red CI, or the
-    # review-id door handled above) is open.  `_ci_failure_story` is
-    # read-only and fail-quiet (see its docstring) — it returns `None` for
-    # "no evidence of a failure", never "CI is green" — so a caller who
-    # KNOWS the PR is red (ci_store not configured for this repo, a
-    # transient GitHub API error, a check that hasn't reported yet) would
-    # otherwise be stranded with no headless door onto the ORIGINAL branch.
-    # `--force` is that caller's release valve; it is NOT a way to skip the
-    # #555 / #522 / max_review_iterations guards, which sit elsewhere.
+    # review-id door handled above) is open.  `_read_ci` is read-only and
+    # fail-quiet (see :class:`CiRead`) — a missing story means "no CI
+    # evidence of a failure", never "CI is green" — so a caller who KNOWS
+    # the PR is red (ci_store not configured for this repo, a transient
+    # GitHub API error, a check that hasn't reported yet) would otherwise be
+    # stranded with no headless door onto the ORIGINAL branch.  `--force` is
+    # that caller's release valve; it is NOT a way to skip the #555 / #522 /
+    # max_review_iterations guards, which sit elsewhere.
     forced_without_evidence = False
     if not test_failed and ci_story is None:
         if not force:
@@ -752,6 +870,23 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
                 "with --force.",
                 err=True,
             )
+            # #2091: say WHY there is no CI evidence.  Before this, six
+            # distinct short-circuits (unconfigured ci_store, a row with no
+            # pr_url, an unknown repo, ...) were all indistinguishable from
+            # "CI is green", so an operator staring at a red `gh pr checks`
+            # had no way to tell that the documented fallback never ran.
+            if not ci_read.was_read:
+                click.echo(
+                    "  note: live CI was NOT read for this row, so this is "
+                    f"not a green-CI finding — {ci_read.unread_reason}.",
+                    err=True,
+                )
+            elif ci_read.pr_number is not None:
+                click.echo(
+                    f"  note: live CI on PR #{ci_read.pr_number} was read and "
+                    "reported no failing completed check.",
+                    err=True,
+                )
             sys.exit(1)
         if not guidance:
             # There's no failed verdict, CI read, or test-output file to

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/coord/config.py

@@ -1880,6 +1880,17 @@ def _parse_repos(raw: Any) -> list[Repo]:
         test_command = entry.get("test_command")
         if test_command is not None and not isinstance(test_command, str):
             raise ConfigError(f"repos[{i}].test_command must be a string")
+        # #2091: ci_command — the command this repo's CI actually runs.  The
+        # Test stage prefers it over `test_command` so a green Test verdict
+        # is CI-equivalent instead of "some subset of CI passed".
+        ci_command = entry.get("ci_command")
+        if ci_command is not None and not isinstance(ci_command, str):
+            raise ConfigError(f"repos[{i}].ci_command must be a string")
+        if isinstance(ci_command, str) and not ci_command.strip():
+            raise ConfigError(
+                f"repos[{i}].ci_command must be a non-empty string (omit the "
+                "key entirely to fall back to test_command)"
+            )
         # #296: run_cmd — optional shell command to launch the app for manual
         # smoke testing.  Surfaced in the TUI Test stage detail panel.
         run_cmd = entry.get("run_cmd")
@@ -1933,6 +1944,7 @@ def _parse_repos(raw: Any) -> list[Repo]:
                 develop_branch=develop_branch,
                 build_command=build_command,
                 test_command=test_command,
+                ci_command=ci_command,
                 run_cmd=run_cmd,
                 worker_permissions=worker_permissions,
                 housekeeping=housekeeping,

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/coord/drive_queue.py

@@ -1932,6 +1932,7 @@ def plan_tick(
     exit_dead_end: Mapping[str, bool] | None = None,
     gate_a_pending: Mapping[str, bool] | None = None,
     cordons: Mapping[str, str] | None = None,
+    live_ci_gate: Mapping[str, bool] | None = None,
 ) -> TickPlan:
     """Decide one tick.  Pure; the caller executes the returned plan.
 
@@ -2008,6 +2009,21 @@ def plan_tick(
     #2110 deadlock, re-created by the very mechanism meant to end it.  A
     cordoned tick is exactly `--reconcile-only`.
 
+    *live_ci_gate* maps a `parked` entry's key to whether a FRESH,
+    single-entry re-derivation of its gate — computed by the shell THIS
+    tick, via :func:`coord.merge_queue.entry_gate_status` with a live
+    ``ci_store``/``gh_ops``, the same backend ``coord merge --plan`` builds
+    — still finds it blocked (#2182). A key present here is authoritative
+    over both the cached board's `merge_ci_pending` and the #2158 staleness
+    ceiling below: there is no ceiling to apply to a reading taken just now.
+    A key ABSENT (the entry isn't CI-parked, or the shell's live check
+    itself couldn't be made — no PR yet, an unreadable config, a `ci_store`
+    that failed to build) falls through unchanged to the pre-#2182 path,
+    the #2158 ceiling included — see
+    :func:`coord.commands.drive_queue._fetch_live_ci_gate` for the shell
+    side, which computes this ONLY for the bounded set of entries currently
+    `parked` on a CI reason, never the whole queue.
+
     The algorithm, from #1754, plus #1757's step 2, #1891's step 1b, and
     #2055's extension of it:
 
@@ -2164,6 +2180,39 @@ def plan_tick(
             # relaunch a gave-up entry outside the `blocked`/`failed`
             # attempt-tracking this function's docstring describes (#2055).
             continue
+        # #2182: a FRESH, single-entry re-derivation of this exact entry's
+        # gate, taken by the shell THIS tick (see the `live_ci_gate`
+        # parameter doc above) — authoritative over both the cached board
+        # reading below and the #2158 staleness ceiling, because there is no
+        # staleness to a reading computed just now. Bypasses that whole
+        # apparatus entirely rather than layering on top of it: a `True`
+        # here means the SAME check `coord merge --plan` would run still
+        # finds this entry blocked (stay parked, no ceiling needed — held
+        # for as long as the live check keeps saying so, exactly like a
+        # live `merge_plan` reason always was); a `False` means the plan
+        # reads READY right now (resume immediately). A MISSING key — the
+        # entry isn't CI-parked, or the shell's live check itself could not
+        # be made — falls through unchanged to the pre-#2182 path.
+        live_override = (live_ci_gate or {}).get(entry.key)
+        if live_override is not None:
+            if live_override:
+                continue
+            reason = (
+                f"live re-check of {entry.key}'s gate this tick reads READY "
+                "(coord merge --plan agrees) — resuming from parked without "
+                "spending an attempt (#1891, #2182)"
+            )
+            reconciles.append(
+                Reconcile(
+                    entry.key,
+                    "resumed",
+                    reason,
+                    occupies=False,
+                    updates={"state": STATE_WAITING, "last_reason": reason},
+                )
+            )
+            states[entry.key] = STATE_WAITING
+            continue
         # #2158: a park whose CI reading can still refresh itself is held for
         # as long as it keeps saying so. One that CANNOT — the reading came
         # only from the raw `merge_queue` row's frozen `error`, which is

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/coord/merge_queue.py

@@ -3244,6 +3244,45 @@ def _entry_gate_status(
     return PLAN_READY, None
 
 
+def entry_gate_status(
+    entry: "QueuedMerge",
+    board,
+    config,
+    ci_store: "CiStore | None" = None,
+    gh_ops: "GhOps | None" = None,
+) -> tuple[str, str | None]:
+    """Public seam onto :func:`_entry_gate_status`, for callers outside this
+    module that need a fresh, SINGLE-entry re-derivation of the gate — not
+    the whole-queue :func:`plan`.
+
+    #2182: ``coord.drive_queue``'s park/resume machinery (#1891/#1892) used
+    to release a `parked` entry only two ways — the cached board's own
+    `merge_plan` reason re-deriving itself (only true off a live daemon
+    `/board`, never on the daemon-host tick itself, which reads the local DB
+    directly and never computes `merge_plan` at all — see
+    ``coord.commands.drive_queue._local_merge_queue_rows``), or
+    :data:`coord.drive_queue.PARK_STALE_SECONDS` ageing the frozen reading
+    out after 45 minutes. Both leave a genuinely-clear gate undetected for
+    up to the ceiling, even though ``coord merge --plan`` can answer correctly on
+    demand at any moment — the same disagreement claude-coordinator#2159
+    surfaced (the queue read `parked` while `--plan` read READY, at the SAME
+    instant, off the SAME board).
+
+    ``coord.commands.drive_queue._fetch_live_ci_gate`` calls this directly,
+    once per currently-`parked` entry, with a LIVE ``ci_store``/``gh_ops`` —
+    the same live backend ``coord merge --plan``'s local branch builds — so
+    the two readings can no longer disagree. Deliberately NOT routed through
+    :func:`plan`: that function evaluates *every* PENDING queue entry with a
+    PR, so handing it a live backend would pay for a `gh` call per entry in
+    the whole merge queue on every 3-minute tick, not just the bounded
+    handful currently parked — reintroducing the unbounded-`gh`-polling
+    shape #1344 removed from the read path. A single-entry call, made only
+    for entries already sitting in `parked`, keeps the cost exactly where
+    the issue says it should be: small and predictable.
+    """
+    return _entry_gate_status(entry, board, config, ci_store, gh_ops)
+
+
 # ── Merge plan (#776) ────────────────────────────────────────────────────────
 
 @dataclass

{code_coordinator-0.5.66 → code_coordinator-0.5.68}/coord/models.py

@@ -56,6 +56,21 @@ class Repo:
     develop_branch: str | None = None
     build_command: str | None = None
     test_command: str | None = None
+    # #2091: the command this repo's CI actually runs — the "CI-equivalent"
+    # suite.  The Test stage (`coord.smoke`) prefers this over
+    # `test_command`/`smoke_tests.default_command`, so a green Test verdict
+    # means the same thing a green CI run does.
+    #
+    # Why this is a SEPARATE field and not just "set test_command to the CI
+    # command": `test_command` is also what a human runs locally and what
+    # several narrower call sites use; it is routinely (and legitimately) a
+    # fast subset — coord-portal's was a ~2 min slice while CI ran a 45 min
+    # `npm run test:e2e` across two Playwright projects.  That divergence is
+    # fine as long as the Test GATE runs the wider one, which is what this
+    # field declares.  Leave it unset and the gate falls back to the old
+    # behaviour, but `dispatch_smoke` logs that the verdict it is about to
+    # produce is narrower than CI (see `resolve_smoke_command`).
+    ci_command: str | None = None
     # #296: optional shell command to interactively run the app for manual
     # smoke testing.  Surfaced in the TUI Test stage detail panel so the
     # tester knows exactly what to launch.