code-coordinator 0.5.449__tar.gz → 0.5.450__tar.gz

{code_coordinator-0.5.449 → code_coordinator-0.5.450}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.449
+Version: 0.5.450
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.449 → code_coordinator-0.5.450}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.449
+Version: 0.5.450
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.449 → code_coordinator-0.5.450}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.449",
+  "tag": "0.5.450",
   "distance": 0,
-  "node": "g7dfdcb7b4d399030cd2ec41d318600ac37e88140",
+  "node": "g6d7a8b2b3bfaa147e2a191a6475f1bdbbf4cac6e",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-11"

{code_coordinator-0.5.449 → code_coordinator-0.5.450}/coord/commands/gates.py

@@ -45,9 +45,11 @@ def _gates_via_daemon(svc, params: dict) -> None:
     help=(
         "Print a work row's gate columns (test_state, smoke_test, test_reason, "
         "test_toolchain, review_state, review_verdict, review_of_assignment_id), "
-        "plus the LIVE review/test/merge gate decision — including whether a recorded verdict "
-        "is #1479-stale (recorded against a base/branch SHA that has since "
-        "moved) and the SHAs compared. Read-only: never mutates board state."
+        "plus the LIVE review/test/uat/merge gate decision — including whether a recorded "
+        "verdict is #1479-stale (recorded against a base/branch SHA that has since "
+        "moved) and the SHAs compared. A gate that does not apply (e.g. uat, when "
+        "not configured for this repo) is still shown, with an explicit reason. "
+        "Read-only: never mutates board state."
     )
 )
 @click.argument("repo")

{code_coordinator-0.5.449 → code_coordinator-0.5.450}/coord/gates.py

@@ -1,6 +1,6 @@
 """#1657: ``coord gates <repo> <issue>`` — read a work row's gate columns
-plus the LIVE gate decision (review / test / merge), without a hand-extracted
-bearer token and a raw ``/board`` curl.
+plus the LIVE gate decision (review / test / uat / merge), without a
+hand-extracted bearer token and a raw ``/board`` curl.
 
 Two things were missing before this module existed:
 
@@ -24,6 +24,12 @@ reuses ``coord.merge_queue``'s own review/smoke gate functions
 :func:`~coord.merge_queue.evaluate_smoke_verdict`) rather than
 re-implementing the #1479 freshness math a second time, so this can never
 drift from what ``coord merge``/``coord merge --plan`` actually decide.
+#3273 (S-5 of #3261): any OTHER gate described in
+``coord.pipeline.GATE_REGISTRY`` (today just ``"uat"``) is walked generically
+rather than hardcoded here — a gate added to that registry in the future
+needs no further change to this module, and one that doesn't currently
+apply (not configured, an exempt issue, ...) is reported with an explicit
+reason rather than silently omitted.
 
 Read-only by construction: nothing in this module calls ``save_board``,
 ``save_queue``, or any ``gh`` write. The synthetic
@@ -680,20 +686,64 @@ def build_gate_report(
             "round has actually been tested (#2024)."
         )
 
+    # #3273 (S-5 of #3261): walk every OTHER registry-backed gate (today just
+    # "uat" — "review"/"test" stay the bespoke blocks above, since they carry
+    # richer per-gate detail — #1479 SHA staleness anchors, #1956 verdict-
+    # unparseable detection — that doesn't fit GateSpec's generic
+    # ``(ok, message)`` evaluator shape; see #3273's epic-closing comment on
+    # #3261 for why that's a real seam, not an oversight). This is what lets
+    # a gate added to `coord.pipeline.GATE_REGISTRY` in the future show up
+    # here with zero further changes to this module, and it's what fixes the
+    # actual #3273 gap: before this, `coord gates` never even asked about
+    # UAT, so it could print "merge READY" for an entry `coord merge` would
+    # refuse outright on `uat_required`.
+    from coord.pipeline import GATE_REGISTRY  # noqa: PLC0415
+
+    registry_decisions: dict[str, GateDecision] = {}
+    for gate_name, spec in GATE_REGISTRY.items():
+        if gate_name in ("review", "test"):
+            continue  # already covered by the bespoke blocks above
+        gate_required = spec.applies(entry, config)
+        if not gate_required:
+            decision = GateDecision(
+                gate=gate_name,
+                required=False,
+                ok=True,
+                reason=spec.explain_inapplicable(entry, config)
+                if spec.explain_inapplicable is not None
+                else None,
+            )
+        else:
+            gate_ok, gate_message = spec.evaluate(entry, board, config, gh_ops)
+            decision = GateDecision(
+                gate=gate_name,
+                required=True,
+                ok=gate_ok,
+                reason=(gate_message or None) if not gate_ok else None,
+            )
+        registry_decisions[gate_name] = decision
+        report.decisions.append(decision)
+
     merge_blocked_gate: str | None = None
     if review_required and not review_ok:
         merge_blocked_gate = REVIEW_REQUIRED
     elif smoke_required and not test_ok:
         merge_blocked_gate = SMOKE_REQUIRED
+    else:
+        for gate_name, decision in registry_decisions.items():
+            if decision.required and not decision.ok:
+                merge_blocked_gate = f"{gate_name}_required"
+                break
     merge_decision = GateDecision(
         gate="merge", required=True, ok=merge_blocked_gate is None, reason=merge_blocked_gate,
     )
     report.decisions.append(merge_decision)
     if merge_decision.ok:
+        gate_names_summary = "/".join(["review", "test", *registry_decisions.keys()])
         report.notes.append(
-            "merge READY reflects the review/test gates only — CI checks and the "
-            "#1318 epic-closing-keyword guard are evaluated live by `coord merge`/"
-            "`coord merge --plan`, not by `coord gates`."
+            f"merge READY reflects the {gate_names_summary} gates only — CI checks "
+            "and the #1318 epic-closing-keyword guard are evaluated live by "
+            "`coord merge`/`coord merge --plan`, not by `coord gates`."
         )
 
     # #3236: the apply-verdict gate, appended ONLY when a --hold-after entry
@@ -808,6 +858,30 @@ def format_gate_report(report: GateReport) -> str:
                 lines.append(f"           {test.reason}")
             else:
                 lines.append(f"  test   : BLOCKED — {test.reason}")
+        # #3273 (S-5 of #3261): any other registry-backed gate (today just
+        # "uat") renders generically here, in `report.decisions`' own
+        # insertion order — a gate GATE_REGISTRY grows in the future needs no
+        # new branch here, and — the actual fix this slice makes — a
+        # skipped/inapplicable one (UAT not configured, or an exempt issue)
+        # gets an explicit reason instead of being silently omitted like it
+        # was before #3273.
+        _KNOWN_GATE_LINES = ("review", "test", "merge", "apply")
+        for decision in report.decisions:
+            if decision.gate in _KNOWN_GATE_LINES:
+                continue
+            label = f"{decision.gate:<6}"
+            if not decision.required:
+                lines.append(
+                    f"  {label} : not required"
+                    + (f" — {decision.reason}" if decision.reason else "")
+                )
+            elif decision.ok:
+                lines.append(
+                    f"  {label} : passed"
+                    + (f" (recorded on {decision.assignment_id})" if decision.assignment_id else "")
+                )
+            else:
+                lines.append(f"  {label} : BLOCKED — {decision.reason}")
         merge = by_gate.get("merge")
         if merge is not None:
             lines.append(

{code_coordinator-0.5.449 → code_coordinator-0.5.450}/coord/merge_queue.py

@@ -1005,10 +1005,15 @@ def _uat_repo_for(entry, config):
         return None
 
 
-def requires_uat(entry: "QueuedMerge", config) -> bool:
-    """True when *entry* must have a recorded UAT verdict before merging.
-
-    See the module-comment above this function for the two-part opt-in.
+def _uat_applicability(entry: "QueuedMerge", config) -> tuple[bool, str | None]:
+    """``(applies, reason_if_not)`` — the single source both :func:`requires_uat`
+    and :func:`uat_inapplicable_reason` (#3273, S-5 of #3261) read, so a
+    caller asking "does UAT gate this entry" and one asking "why not" can
+    never disagree about which condition actually decided it (#2096: one
+    question, one answer). *reason* is only meaningful when *applies* is
+    ``False`` — always ``None`` on the ``True`` branch.
+
+    See the module comment above this function for the two-part opt-in.
     Duck-typed on ``entry.repo_name``/``entry.required_gates``, matching
     :func:`requires_review`/:func:`requires_smoke`.
 
@@ -1027,18 +1032,43 @@ def requires_uat(entry: "QueuedMerge", config) -> bool:
     """
     pipeline = getattr(config, "pipeline", None)
     if pipeline is None or config is None:
-        return False
+        return False, "no pipeline configuration available"
     if not _gate_in_effective_gates("uat", entry, config):
-        return False
+        return False, '"uat" is not in this entry\'s effective gate list (required_gates / pipeline.default_gates)'
     repo = _uat_repo_for(entry, config)
     if repo is None:
-        return False
+        return False, f"repo {getattr(entry, 'repo_name', None)!r} not found in configuration"
     uat_checks_cfg = getattr(repo, "uat_checks", None)
-    if uat_checks_cfg is not None and uat_checks_cfg.is_exempt(
-        getattr(entry, "issue_number", None)
-    ):
-        return False
-    return bool(repo.uat_preview) or bool(getattr(repo, "uat_live_preview", False))
+    issue_number = getattr(entry, "issue_number", None)
+    if uat_checks_cfg is not None and uat_checks_cfg.is_exempt(issue_number):
+        return False, f"issue #{issue_number} is exempt via this repo's uat_checks.exempt"
+    if not (bool(repo.uat_preview) or bool(getattr(repo, "uat_live_preview", False))):
+        return False, "repo has neither uat_preview nor uat_live_preview configured"
+    return True, None
+
+
+def requires_uat(entry: "QueuedMerge", config) -> bool:
+    """True when *entry* must have a recorded UAT verdict before merging.
+
+    Delegates entirely to :func:`_uat_applicability` — see that function's
+    docstring for the full two-part opt-in this decides.
+    """
+    return _uat_applicability(entry, config)[0]
+
+
+def uat_inapplicable_reason(entry: "QueuedMerge", config) -> str | None:
+    """Human-readable reason UAT does *not* gate *entry*, or ``None`` when it
+    does (i.e. :func:`requires_uat` would return ``True``).
+
+    #3273 (S-5 of #3261): the ``coord gates`` render path used to omit the
+    UAT gate entirely rather than say why it isn't running — this is what
+    lets it render "uat : not required — <reason>" instead of silently
+    dropping the gate, mirroring how ``milestone_gate.plan_sequence`` gives
+    every remaining gate an explicit reason rather than skipping the ones
+    that won't fire. Shares :func:`_uat_applicability` with
+    :func:`requires_uat` so the two can never drift apart on WHY.
+    """
+    return _uat_applicability(entry, config)[1]
 
 
 def _uat_branch_work(entry: "QueuedMerge", board) -> list:

{code_coordinator-0.5.449 → code_coordinator-0.5.450}/coord/pipeline.py

@@ -32,7 +32,12 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Callable
 
-from coord.merge_queue import evaluate_uat_verdict, is_uat_gate_reason, requires_uat
+from coord.merge_queue import (
+    evaluate_uat_verdict,
+    is_uat_gate_reason,
+    requires_uat,
+    uat_inapplicable_reason,
+)
 
 if TYPE_CHECKING:
     from coord.config import Config
@@ -187,6 +192,17 @@ class GateSpec:
     #: for the same allowance).
     identifies_reason: Callable[[str], bool] | None = None
 
+    #: ``(entry, config) -> str | None`` — a human-readable reason THIS gate
+    #: does not apply to *entry*, populated only when ``applies`` would
+    #: return ``False`` (``None`` on the ``applies=True`` branch). #3273
+    #: (S-5 of #3261): this is what lets a render path (``coord gates``) walk
+    #: every registry gate and give the skipped ones an explicit reason
+    #: ("UAT not configured for this repo", "issue exempt via
+    #: uat_checks.exempt", ...) instead of silently omitting them — the same
+    #: posture ``milestone_gate.plan_sequence`` already takes for the
+    #: Gate-A..D walk. ``None`` for a gate that hasn't grown this yet.
+    explain_inapplicable: Callable[["QueuedMerge", "Config"], str | None] | None = None
+
 
 GATE_REGISTRY: dict[str, GateSpec] = {
     "uat": GateSpec(
@@ -196,6 +212,7 @@ GATE_REGISTRY: dict[str, GateSpec] = {
         verdicts=("passed", "failed", None),
         fail_route="coord.drive._park_uat_fixup_dispatch_failure",
         identifies_reason=is_uat_gate_reason,
+        explain_inapplicable=uat_inapplicable_reason,
     ),
 }
 

{code_coordinator-0.5.449 → code_coordinator-0.5.450}/tests/test_gates.py

@@ -510,6 +510,144 @@ class TestDecision:
         assert by_gate["review"].verdict_unparseable is False
 
 
+# ── UAT gate, registry-walked (#3273, S-5 of #3261) ─────────────────────────
+#
+# Before this slice `coord gates` never asked about UAT at all — it could
+# print "merge READY" for an entry `coord merge` would refuse outright on
+# `uat_required`, and a repo that opted out of UAT (no uat_preview/
+# uat_live_preview, or an exempt issue) got no line and no reason at all.
+# These pin the fix: the gate is walked from `coord.pipeline.GATE_REGISTRY`,
+# so it always appears, with an explicit reason on every "won't run" branch.
+
+class TestUatGateDecision:
+    def test_uat_not_in_default_gates_is_reported_not_required_with_reason(
+        self, config: Config,
+    ) -> None:
+        # This fixture's `config.pipeline.default_gates` (the PipelineConfig
+        # default) has no "uat" at all — the overwhelming common case today.
+        work = _work(test_state="passed")
+        review = _review("w1", verdict="approve")
+        board = Board(active=[], completed=[work, review])
+        report = build_gate_report(board, config, "api", 42, gh_ops=FakeGh())
+
+        by_gate = {d.gate: d for d in report.decisions}
+        assert "uat" in by_gate  # never silently omitted
+        assert by_gate["uat"].required is False
+        assert by_gate["uat"].ok is True
+        assert "effective gate list" in (by_gate["uat"].reason or "")
+
+    def test_uat_in_gates_but_repo_not_opted_in_reports_specific_reason(
+        self, config: Config,
+    ) -> None:
+        config.pipeline = PipelineConfig(default_gates=["test", "review", "uat", "merge"])
+        # `config`'s "api" repo has neither uat_preview nor uat_live_preview.
+        work = _work(test_state="passed")
+        review = _review("w1", verdict="approve")
+        board = Board(active=[], completed=[work, review])
+        report = build_gate_report(board, config, "api", 42, gh_ops=FakeGh())
+
+        by_gate = {d.gate: d for d in report.decisions}
+        assert by_gate["uat"].required is False
+        assert "uat_preview" in by_gate["uat"].reason
+        assert "uat_live_preview" in by_gate["uat"].reason
+        # Not being required, UAT must not be what a green merge is hiding.
+        assert by_gate["merge"].ok is True
+
+    def test_uat_exempt_issue_reports_exempt_reason(self, config: Config) -> None:
+        from coord.uat_checks import UatCheckConfig
+
+        config.repos = [
+            Repo(
+                name="api", github="acme/api", default_branch="main",
+                uat_preview="https://preview.example/{branch}",
+                uat_checks=UatCheckConfig(exempt_issues=frozenset({42})),
+            ),
+        ]
+        config.pipeline = PipelineConfig(default_gates=["test", "review", "uat", "merge"])
+        work = _work(test_state="passed")
+        review = _review("w1", verdict="approve")
+        board = Board(active=[], completed=[work, review])
+        report = build_gate_report(board, config, "api", 42, gh_ops=FakeGh())
+
+        by_gate = {d.gate: d for d in report.decisions}
+        assert by_gate["uat"].required is False
+        assert "exempt" in by_gate["uat"].reason
+        assert by_gate["merge"].ok is True
+
+    def test_uat_required_and_missing_blocks_merge_with_uat_required(
+        self, config: Config,
+    ) -> None:
+        config.repos = [
+            Repo(
+                name="api", github="acme/api", default_branch="main",
+                uat_preview="https://preview.example/{branch}",
+            ),
+        ]
+        config.pipeline = PipelineConfig(default_gates=["test", "review", "uat", "merge"])
+        work = _work(test_state="passed")  # no uat_state recorded at all
+        review = _review("w1", verdict="approve")
+        board = Board(active=[], completed=[work, review])
+        report = build_gate_report(board, config, "api", 42, gh_ops=FakeGh())
+
+        by_gate = {d.gate: d for d in report.decisions}
+        assert by_gate["uat"].required is True
+        assert by_gate["uat"].ok is False
+        assert "uat verdict" in by_gate["uat"].reason
+        # The whole point of #3273: a gate this module never used to ask
+        # about now actually blocks the merge decision, by name.
+        assert by_gate["merge"].ok is False
+        assert by_gate["merge"].reason == "uat_required"
+
+    def test_uat_passed_merge_ready(self, config: Config) -> None:
+        config.repos = [
+            Repo(
+                name="api", github="acme/api", default_branch="main",
+                uat_preview="https://preview.example/{branch}",
+            ),
+        ]
+        config.pipeline = PipelineConfig(default_gates=["test", "review", "uat", "merge"])
+        work = _work(test_state="passed")
+        work.uat_state = "passed"
+        review = _review("w1", verdict="approve")
+        board = Board(active=[], completed=[work, review])
+        report = build_gate_report(board, config, "api", 42, gh_ops=FakeGh())
+
+        by_gate = {d.gate: d for d in report.decisions}
+        assert by_gate["uat"].required is True
+        assert by_gate["uat"].ok is True
+        assert by_gate["merge"].ok is True
+
+    def test_format_gate_report_renders_uat_blocked_line(self, config: Config) -> None:
+        config.repos = [
+            Repo(
+                name="api", github="acme/api", default_branch="main",
+                uat_preview="https://preview.example/{branch}",
+            ),
+        ]
+        config.pipeline = PipelineConfig(default_gates=["test", "review", "uat", "merge"])
+        work = _work(test_state="passed")
+        review = _review("w1", verdict="approve")
+        board = Board(active=[], completed=[work, review])
+        report = build_gate_report(board, config, "api", 42, gh_ops=FakeGh())
+
+        text = format_gate_report(report)
+        assert "uat" in text
+        assert "BLOCKED" in text
+        assert "merge  : BLOCKED — uat_required" in text
+
+    def test_format_gate_report_renders_uat_not_required_reason(
+        self, config: Config,
+    ) -> None:
+        work = _work(test_state="passed")
+        review = _review("w1", verdict="approve")
+        board = Board(active=[], completed=[work, review])
+        report = build_gate_report(board, config, "api", 42, gh_ops=FakeGh())
+
+        text = format_gate_report(report)
+        assert "uat" in text
+        assert "not required" in text
+
+
 # ── apply-verdict gate (#3236) ──────────────────────────────────────────────
 #
 # `coord gates` must be able to tell "merged, not yet applied" apart from
@@ -769,7 +907,11 @@ class TestFormatting:
         assert reloaded["repo_name"] == "api"
         assert reloaded["issue_number"] == 42
         assert len(reloaded["rows"]) == 2
-        assert len(reloaded["decisions"]) == 3
+        # #3273 (S-5 of #3261): review/test/merge plus the registry-backed
+        # "uat" gate, walked from `coord.pipeline.GATE_REGISTRY` — not
+        # silently omitted just because this fixture's repo has no
+        # uat_preview/uat_live_preview configured.
+        assert len(reloaded["decisions"]) == 4
         assert reloaded["rows"][0]["test_toolchain"] == "node 20.11.0"
 
     def test_never_mutates_board_or_calls_write_seams(