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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.66
+Version: 0.5.67
 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.67}/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.67}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.66
+Version: 0.5.67
 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.67}/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.67}/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.67}/code_coordinator.egg-info/scm_version.json

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

{code_coordinator-0.5.66 → code_coordinator-0.5.67}/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.67}/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.67}/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.

{code_coordinator-0.5.66 → code_coordinator-0.5.67}/coord/revalidate.py

@@ -656,7 +656,20 @@ def revalidate(
             ok=False, kind=KIND_SETUP,
             reason=f"no repo config for {repo_name!r}",
         )
-    test_command = repo_cfg.test_command
+    # #2091: revalidation WRITES a test verdict, so it is bound by the same
+    # rule as the Test stage — a verdict is only worth what the suite behind
+    # it is worth. When the repo declares what CI runs, re-verify with THAT;
+    # otherwise nothing changes (`ci_command` is unset for every repo that
+    # has not opted in). Deliberately narrower than
+    # `coord.smoke.resolve_smoke_command`: this path has never consulted
+    # `smoke_tests.default_command` and #2091 is not the issue to change that.
+    # `getattr`: *config* here is duck-typed (`coord merge --revalidate` passes
+    # the real Config; tests and the daemon pass lighter stand-ins), so a
+    # hard attribute read would turn a missing shim into an AttributeError
+    # mid-revalidation.
+    test_command = (
+        getattr(repo_cfg, "ci_command", None) or ""
+    ).strip() or repo_cfg.test_command
     if not test_command:
         # Refusing here is the safe direction: with nothing to run, "passed"
         # would be a claim about a suite that never executed — the exact lie

{code_coordinator-0.5.66 → code_coordinator-0.5.67}/coord/smoke.py

@@ -378,6 +378,75 @@ def _capability_probe_reasons(
     return unmet_capabilities(required_caps, probes)
 
 
+# ── CI-equivalence of the Test-stage command (#2091) ────────────────────────
+
+
+@dataclass(frozen=True)
+class SmokeCommand:
+    """Which command the Test stage will run, and how faithful it is to CI.
+
+    #2091: the Test verdict is what gates review and merge, so what it
+    *means* depends entirely on which suite produced it.  coord-portal #14
+    recorded ``test_passed`` in 1m51s on a commit whose CI failed
+    deterministically after 44m57s — the gate simply never ran the suite
+    (``npm run test:e2e``) that catches it.  Resolution is therefore no
+    longer an anonymous ``a or b``: the chosen command carries its
+    provenance so callers can say out loud whether a green verdict is
+    CI-equivalent or merely "some tests passed".
+
+    ``ci_equivalent`` is a *declaration*, not a proof — it is True exactly
+    when the operator pointed ``repos[].ci_command`` at what CI runs.  It
+    can still be a lie if the config drifts from the workflow file; what it
+    buys is that the un-declared case stops looking identical to the
+    declared one.
+    """
+
+    command: str | None
+    source: str
+    ci_equivalent: bool
+
+    def briefing_note(self) -> str:
+        """One line for the smoke agent's briefing naming the command's origin."""
+        if self.ci_equivalent:
+            return (
+                f"- Suite: `{self.source}` — this is the repo's declared "
+                "CI-equivalent command, so this verdict carries the same "
+                "weight as a CI run."
+            )
+        return (
+            f"- Suite: `{self.source}` — this repo has not declared a "
+            "`ci_command`, so this run may be NARROWER than CI (#2091). "
+            "Passing here does not prove CI is green."
+        )
+
+
+def resolve_smoke_command(repo, smoke_cfg: SmokeTestsConfig) -> SmokeCommand:
+    """Pick the Test-stage command for *repo*, best (most CI-faithful) first.
+
+    Precedence, deliberately with the per-repo CI declaration on top:
+
+    1. ``repos[].ci_command`` — what this repo's CI actually runs (#2091).
+    2. ``smoke_tests.default_command`` — the fleet-wide fallback.
+    3. ``repos[].test_command`` — the local/quick suite.
+
+    ``smoke_tests.default_command`` outranking ``test_command`` is the
+    pre-existing #1021 behaviour and is preserved; ``ci_command`` is inserted
+    *above* both because a global default cannot possibly be more faithful to
+    one repo's CI than that repo's own declaration.
+    """
+    ci_command = (getattr(repo, "ci_command", None) or "").strip() or None
+    if ci_command:
+        return SmokeCommand(ci_command, f"repos[{repo.name}].ci_command", True)
+    if smoke_cfg.default_command:
+        return SmokeCommand(
+            smoke_cfg.default_command, "smoke_tests.default_command", False
+        )
+    test_command = getattr(repo, "test_command", None)
+    if test_command:
+        return SmokeCommand(test_command, f"repos[{repo.name}].test_command", False)
+    return SmokeCommand(None, "unconfigured", False)
+
+
 # ── Briefing ────────────────────────────────────────────────────────────────
 
 
@@ -392,6 +461,7 @@ def build_smoke_briefing(
     required_caps: list[str],
     timeout_seconds: int,
     is_worker: bool,
+    command_source: SmokeCommand | None = None,
 ) -> str:
     lines: list[str] = []
     lines.append(f"# Smoke test: {repo_github} branch `{branch}`")
@@ -403,6 +473,11 @@ def build_smoke_briefing(
     lines.append("## Context")
     lines.append(f"- Repo: {repo_github} (local name: {repo_name})")
     lines.append(f"- Branch: {branch}")
+    if command_source is not None:
+        # #2091: name the suite's provenance so a reader of the transcript can
+        # tell a CI-equivalent green from a narrower one without going back to
+        # coordinator.yml.
+        lines.append(command_source.briefing_note())
     if required_caps:
         lines.append(f"- Required capabilities: {', '.join(required_caps)}")
     if is_worker:
@@ -716,7 +791,10 @@ def dispatch_smoke(
 
     touched = diff_lookup(repo.github, completed.branch)
     required_caps = match_rules(touched, smoke_cfg.capability_rules)
-    smoke_command = smoke_cfg.default_command or repo.test_command
+    # #2091: resolve *with* provenance — the Test verdict this dispatch will
+    # produce is only as meaningful as the suite behind it.
+    resolved = resolve_smoke_command(repo, smoke_cfg)
+    smoke_command = resolved.command
 
     if not required_caps:
         # #1426: a capability-rule miss used to mean "skip silently" — the
@@ -746,13 +824,31 @@ def dispatch_smoke(
     if smoke_command is None:
         logger.warning(
             "dispatch_smoke: %s#%s needs capabilities %s but no smoke "
-            "command is configured (smoke_tests.default_command or this "
-            "repo's test_command) — skipping. Configure one so the Test "
-            "stage stops silently no-oping for this repo.",
+            "command is configured (repos[].ci_command, "
+            "smoke_tests.default_command, or this repo's test_command) — "
+            "skipping. Configure one so the Test stage stops silently "
+            "no-oping for this repo.",
             completed.repo_name, completed.issue_number, required_caps,
         )
         return None
 
+    if not resolved.ci_equivalent and repo.github:
+        # #2091: the repo HAS CI (it has a `github:` slug, so a PR gets
+        # checks) but has not declared what CI runs, so the verdict this
+        # dispatch produces is "some tests passed", not "the branch is
+        # good".  That is exactly the coord-portal #14 shape — a 1m51s green
+        # Test verdict on a commit whose 44m57s CI run was red — so say it
+        # once per dispatch rather than letting the gap stay invisible.
+        logger.warning(
+            "dispatch_smoke: %s#%s Test verdict will NOT be CI-equivalent — "
+            "running %s (%s) while CI runs whatever %s's workflows say. Set "
+            "repos[%s].ci_command to the command CI runs so a green Test "
+            "verdict means the branch is good, not just that a subset "
+            "passed (#2091).",
+            completed.repo_name, completed.issue_number,
+            smoke_command, resolved.source, repo.github, repo.name,
+        )
+
     # #1672: the FULL capability-matched candidate list, best first. Picking
     # one machine and giving up on it meant a single bad candidate ended the
     # whole Test stage — #1678, where the router re-chose the same unhealthy
@@ -823,6 +919,7 @@ def dispatch_smoke(
             required_caps=required_caps,
             timeout_seconds=smoke_cfg.timeout_seconds,
             is_worker=choice.is_worker,
+            command_source=resolved,
         )
 
         # #2168: pin the Test stage's model to avoid the agent falling

{code_coordinator-0.5.66 → code_coordinator-0.5.67}/coordinator.example.yml

@@ -61,6 +61,23 @@ repos:
     # machine's repo_paths checkout needs a `quadraui` sibling directory —
     # true for every machine below (repo_paths list quadraui alongside it).
     test_command: "scripts/coord-test-runner.sh . --base-ref origin/main --repo code-coordinator"
+    # #2091: `ci_command` is the command THIS REPO'S CI actually runs. The
+    # Test stage prefers it over `test_command` (and over
+    # `smoke_tests.default_command`), so a green Test verdict means the same
+    # thing a green CI run does.
+    #
+    # Set it whenever CI runs a WIDER suite than `test_command` — that gap is
+    # a silent false green: coord-portal #14 recorded `test_passed` in 1m51s
+    # on a commit whose CI `npm run test:e2e` failed deterministically after
+    # 44m57s (36 mobile Playwright tests, every click ~70px off target). The
+    # Test verdict gates review and merge, so a gate running a strict subset
+    # of CI means "some tests passed", not "the branch is good".
+    #
+    # Leave it unset when `test_command` IS what CI runs — as here, where
+    # .github/workflows points at the same coord-test-runner.sh arms.
+    # `dispatch_smoke` logs a warning for any repo with a `github:` slug and
+    # no `ci_command`, naming the verdict as narrower than CI.
+    # ci_command: "npm run test:e2e"
     # artifact_paths: []  # no compiled binaries to stash for a Python package
 
 machines:

{code_coordinator-0.5.66 → code_coordinator-0.5.67}/docs/OPERATING_GOTCHAS.md

@@ -340,6 +340,41 @@ Two config keys are load-bearing for that, both on the **daemon host's**
   `scripts/coord-test-runner.sh`, because the repo is two codebases and a bare
   `pytest` or `cargo test` would run the wrong suite or miss half the diff.
 
+**The Test gate is only as good as the command it runs (#2091).** The gate does
+not discover a repo's CI; it runs whatever `coordinator.yml` names, and nothing
+previously checked that against what CI runs. coord-portal #14 is the worked
+example: the Test stage recorded `test_passed` in **1m51s** while CI's
+`npm run test:e2e` on the *same commit* failed after **44m57s** — 36 `[mobile]`
+Playwright tests, all deterministic, none of them in the suite the gate ran.
+Because `pipeline.default_gates` puts Test *before* Review, that false green
+green-lit broken code into review; only the separate CI check gate stopped the
+merge.
+
+Resolution order is now `repos[].ci_command` → `smoke_tests.default_command` →
+`repos[].test_command`. **Set `ci_command` to the command your CI workflow
+runs** whenever it is wider than `test_command` (which is legitimately a fast
+local subset). `dispatch_smoke` logs a warning naming the gap for any repo with
+a `github:` slug and no `ci_command`, and the smoke agent's briefing states
+whether the run is CI-equivalent, so a transcript answers the question on its
+own. `coord merge --revalidate` follows the same preference — a re-verify that
+overwrote a verdict with a *narrower* suite would reintroduce the same lie.
+
+The declaration is not proof: nothing diffs `ci_command` against
+`.github/workflows/**`, so it can drift. What it buys is that the undeclared
+case stops looking identical to the declared one.
+
+**`coord fix` used to say "no red CI" when it never looked (#2091, same
+episode).** The live-CI fallback short-circuits for six distinct reasons —
+`ci_store.type: none`, a row with no `pr_url`, an unconfigured repo, a repo with
+no `github:` slug, a read that raised, checks that are all still pending — and
+every one of them used to render as the same refusal text as a genuinely green
+PR. The refusal now names the short-circuit (`note: live CI was NOT read for
+this row … because …`) and distinguishes it from `note: live CI on PR #N was
+read and reported no failing completed check`. A row with no `pr_url` also falls
+back to resolving the PR from its branch. If the stored verdict says `passed`
+while the live read says RED, `coord fix` prints an explicit `conflict (#2091)`
+line rather than silently preferring one.
+
 **A systemd user unit's PATH is not a login shell's (#1814).** `coord serve`
 runs as a systemd *user* unit, and `coord merge --revalidate` runs its composed
 suite inside that daemon process. systemd never sources `~/.profile`, so