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

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

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

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

{code_coordinator-0.5.65 → code_coordinator-0.5.67}/coord/agent_app.py

@@ -1463,13 +1463,23 @@ def build_app(
         installed, and keeps a ``.bak`` of each — see
         :mod:`coord.deploy_units` for why both are deliberate.
 
-        Also asserts every installed *timer* is enabled and running
+        Also asserts every installed *timer* is enabled
         (:func:`coord.deploy_units.enable_timers`, #2082): refreshing a
         timer's content has never implied enabling it, and that gap is
         exactly how ``coord-release-propagate.timer`` reached this host with
         matching content and sat disabled for a day with nothing noticing.
-        ``enable --now`` is idempotent, so this runs on every call, not just
-        when content changed — an already-enabled timer is untouched.
+        This runs on every non-dry-run call, not just when content changed —
+        an already-enabled timer's *enablement* is untouched (idempotent).
+
+        It does **not**, as of #2124, force a start (``--now``) on a timer
+        that is already enabled: that used to restart a timer an operator
+        had deliberately stopped moments earlier — the exact window the
+        documented manual-roll sequence exists to create — because ``enable
+        --now`` cannot tell "never enabled" (#2082's actual bug) apart from
+        "enabled, but stopped on purpose" (never a bug at all). See
+        :func:`coord.deploy_units.enable_timers` for how it now tells the
+        two apart, and ``timers_enabled[<unit>]["changed"]`` below for
+        which case each timer landed in.
         """
         from coord import deploy_units as du  # noqa: PLC0415
         from coord.brain import AGENT_PORT  # noqa: PLC0415
@@ -1504,10 +1514,10 @@ def build_app(
         if not dry_run:
             timer_results = du.enable_timers(report)
             payload["timers_enabled"] = {
-                name: {"ok": ok, "detail": detail}
-                for name, (ok, detail) in timer_results.items()
+                name: {"ok": ok, "changed": changed, "detail": detail}
+                for name, (ok, changed, detail) in timer_results.items()
             }
-            if any(not ok for ok, _ in timer_results.values()):
+            if any(not ok for ok, _changed, _detail in timer_results.values()):
                 payload["ok"] = False
         return JSONResponse(payload, status_code=200 if payload.get("ok") else 500)
 

{code_coordinator-0.5.65 → 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.65 → code_coordinator-0.5.67}/coord/commands/release.py

@@ -16,6 +16,7 @@ via setuptools-scm). It does not push, tag, or modify anything itself.
 
 from __future__ import annotations
 
+import re
 import subprocess
 import sys
 from pathlib import Path
@@ -1339,7 +1340,26 @@ def _roll_units(machine, *, agent_port: int) -> tuple[bool | None, str]:
     Returns ``ok=None`` when this host offers no channel for the lane at all
     (see :func:`_roll_tui` and #2052): the run is not accountable for a lane
     it was structurally unable to roll.
+
+    Also names every timer whose *enablement* state this call changed
+    (#2124 item 3) — and, separately, every timer it deliberately left
+    alone because it was already enabled (see
+    :func:`coord.deploy_units.enable_timers`) — so "the queue came back
+    mid-roll" (or, after this fix, "it didn't") is legible in this output
+    rather than reconstructed afterwards from journal timestamps.
+
+    ``ok`` (#2124 review) reflects every way ``agent_app.py``'s
+    ``deploy_units`` endpoint can fail, not just a failed timer: a unit
+    whose install itself failed (``action == "failed"`` — e.g. an unreadable
+    installed unit file, :mod:`coord.deploy_units` lines ~249/264/284), a
+    top-level ``error``, or a ``daemon-reload`` that was attempted and
+    failed. Before this check existed, ``ok`` was derived from
+    ``failed_timers`` alone, so any of those three could return HTTP 500
+    with ``payload["ok"]=False`` and still be recorded here as a green
+    lane — exactly the "unconfirmed success" defect #2096 exists to catch.
     """
+    from coord.deploy_units import ACTION_FAILED  # noqa: PLC0415
+
     status, body, error = _post(
         f"http://{machine.host}:{agent_port}/deploy-units", {}, timeout=30.0
     )
@@ -1352,11 +1372,24 @@ def _roll_units(machine, *, agent_port: int) -> tuple[bool | None, str]:
         # gate to revert everything else this run got right (#2052).
         return None, ("agent has no /deploy-units yet (predates #1835) — "
                       "the next propagation will roll this lane")
-    if status != 200:
+    # The endpoint (`agent_app.py`'s `deploy_units`) returns HTTP 500 — with
+    # the SAME body shape as 200 — whenever a daemon-reload or a single
+    # timer's enablement fails. That is exactly the partial-failure path
+    # this function exists to narrate in detail, so a 500 *with a `units`
+    # body* must still be parsed below rather than treated as opaque. A 500
+    # WITHOUT a `units` body is a different, genuinely-unexpected failure
+    # (an unhandled exception, a proxy error, ...) and must still
+    # short-circuit, or a real crash would be misread as "nothing to
+    # report" / a false-positive success.
+    if status != 200 and not (status == 500 and "units" in body):
         return False, str(body.get("error") or body.get("summary") or f"HTTP {status}")
     units = body.get("units") or []
     changed = [u.get("name") for u in units if u.get("action") == "updated"]
     new = [u.get("name") for u in units if u.get("action") == "new"]
+    failed_units = {
+        (u.get("name") or "?"): (u.get("detail") or "?")
+        for u in units if u.get("action") == ACTION_FAILED
+    }
     parts = []
     parts.append(f"{len(changed)} unit(s) refreshed" if changed else "units already current")
     if body.get("reloaded"):
@@ -1366,7 +1399,79 @@ def _roll_units(machine, *, agent_port: int) -> tuple[bool | None, str]:
             f"{len(new)} packaged unit(s) NOT installed here ({', '.join(sorted(map(str, new)))}) "
             "— a release does not decide which services a host runs"
         )
-    return True, "; ".join(parts)
+    if failed_units:
+        parts.append(
+            "FAILED to install unit(s): "
+            + ", ".join(f"{u} ({detail})" for u, detail in sorted(failed_units.items()))
+        )
+
+    # A daemon-reload is only attempted when a unit's bytes actually
+    # changed (`agent_app.py`'s `deploy_units`); "not reloaded" is a
+    # failure only when the report itself says a reload was attempted
+    # (`body["changed"]`, `InstallReport.changed`) — absent that, "not
+    # reloaded" just means there was nothing to reload, never a failure.
+    reload_failed = bool(body.get("changed")) and not body.get("reloaded")
+    if reload_failed:
+        parts.append(
+            "daemon-reload FAILED: " + str(body.get("reload_detail") or "?")
+        )
+
+    top_level_error = body.get("error")
+    if top_level_error:
+        parts.append(f"deploy-units error: {top_level_error}")
+
+    timers = body.get("timers_enabled") or {}
+    started = sorted(
+        name for name, r in timers.items()
+        if isinstance(r, dict) and r.get("ok") and r.get("changed")
+    )
+    # Held timers (confirmed already-enabled, left alone) split on the
+    # confirmed `ActiveState` carried in `enable_timers`'s own detail text
+    # (coord/deploy_units.py's `already enabled (ActiveState=...)` branch)
+    # — NOT on `changed` alone, which is equally true for the #2124 case
+    # (operator stopped it) and for the routine, overwhelmingly common case
+    # of a timer that was never touched because it is already enabled AND
+    # already running. Reporting "left stopped as-is" for the latter names
+    # a state (stopped) this call never confirmed — the #2124 review's
+    # reporting-accuracy fix.
+    held_stopped = []
+    held_other = []
+    for name, r in timers.items():
+        if not (isinstance(r, dict) and r.get("ok") and not r.get("changed")):
+            continue
+        match = re.search(r"ActiveState=(\w+)", r.get("detail") or "")
+        if match and match.group(1) == "inactive":
+            held_stopped.append(name)
+        else:
+            held_other.append(name)
+    held_stopped.sort()
+    held_other.sort()
+    failed_timers = {
+        name: (r.get("detail") or "?")
+        for name, r in timers.items() if isinstance(r, dict) and not r.get("ok")
+    }
+    if started:
+        parts.append(f"enabled timer(s): {', '.join(started)}")
+    if held_stopped:
+        # Confirmed inactive (ActiveState=inactive) and deliberately left
+        # alone — the #2124 fix in one word: a timer an operator stopped is
+        # still here.
+        parts.append(
+            f"left stopped as-is (already enabled, #2124): {', '.join(held_stopped)}"
+        )
+    if held_other:
+        # Already enabled and left alone, but NOT confirmed stopped — most
+        # commonly a timer that is already enabled and already running
+        # normally. Reported distinctly so it never gets read as "the
+        # timer I stopped is still stopped" for a timer nobody stopped.
+        parts.append(f"already enabled (unchanged): {', '.join(held_other)}")
+    if failed_timers:
+        parts.append(
+            "FAILED to enable timer(s): "
+            + ", ".join(f"{u} ({detail})" for u, detail in sorted(failed_timers.items()))
+        )
+    ok = not (failed_units or reload_failed or top_level_error or failed_timers)
+    return ok, "; ".join(parts)
 
 
 def _roll_tui(

{code_coordinator-0.5.65 → 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,