code-coordinator 0.5.540__tar.gz → 0.5.541__tar.gz

{code_coordinator-0.5.540 → code_coordinator-0.5.541}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.540",
+  "tag": "0.5.541",
   "distance": 0,
-  "node": "g4350dd13ffcba5e53083059269232d07634c175d",
+  "node": "g86827ed61aa79dc5a11cdfbac183ed00d6439c84",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.540 → code_coordinator-0.5.541}/coord/commands/release.py

@@ -1901,6 +1901,24 @@ def _run_drain(
     :func:`_drain_remaining_hosts` reports nothing left behind, *
     deadline_seconds* elapses, or an attempt comes back with a real failure.
 
+    #3081: a ``STATUS_HOLDING`` attempt is NOT one of those "nothing left
+    behind" outcomes, even though it is a reported exit-0 no-op for a
+    single-shot ``coord release propagate`` — see :data:`rp.STATUS_HOLDING`'s
+    own docstring. The `--min-behind` gate it fires is evaluated **fleet-wide**
+    against whatever version most of the fleet is already on, which can go
+    quiet the moment the TARGET drifts (a new release publishes mid-drain)
+    even though a host this SAME `--drain` session cordoned earlier is still
+    nowhere near current. A holding attempt also returns before
+    :func:`_apply_cordons` ever runs, so its own `record.cordons` is empty —
+    reading that as "every previously-cordoned host converged" is exactly how
+    a host still on the old version got reported "reached the target" and
+    left cordoned with exit 0. So: `remaining` carries the previous attempt's
+    set forward unchanged through a holding attempt (nothing this attempt
+    says can prove a host current), and the loop only exits 0 on
+    ``STATUS_HOLDING`` when nothing is left outstanding — otherwise it names
+    the stragglers and exits 1, the same "unconfirmed success is a defect"
+    rule every other status in this loop already follows.
+
     Never lets a single attempt actually terminate the process: each call is
     ``release_propagate.callback(...)`` — the plain function Click wraps,
     invoked directly rather than through Click's own dispatch — with its
@@ -1989,8 +2007,25 @@ def _run_drain(
             )
             sys.exit(exit_code)
 
-        remaining = _drain_remaining_hosts(record)
         status = record.status
+        if status == rp.STATUS_HOLDING:
+            # #3081: a holding attempt returns from `release_propagate`
+            # BEFORE `_apply_cordons` ever runs (see the #2583 gate's own
+            # comment: "a held run genuinely cordons nothing and touches no
+            # host") — so `record.cordons` is empty on THIS attempt by
+            # construction, not because every host this drain session had
+            # cordoned actually rolled. Diffing that empty dict against
+            # `last_remaining` the same way a real attempt's cordon plan is
+            # diffed reads every previously-cordoned host as having "reached
+            # the target" on the very next holding attempt — the exact false
+            # report #3081 reproduced (dell64, still on 0.5.351 and still
+            # cordoned, printed as "reached the target"). No per-host
+            # comparison happened this attempt, so nothing this attempt says
+            # can move a host out of `remaining` — carry the previous
+            # attempt's set forward unchanged instead.
+            remaining = last_remaining if last_remaining is not None else set()
+        else:
+            remaining = _drain_remaining_hosts(record)
         if last_remaining is None:
             suffix = f" — still behind: {', '.join(sorted(remaining))}" if remaining else ""
             _echo(f"[drain] attempt {attempt}: {status}{suffix}")
@@ -2013,6 +2048,25 @@ def _run_drain(
             )
             sys.exit(exit_code)
         if status == rp.STATUS_HOLDING:
+            if remaining:
+                # #3081: holding must never be reported the same as "nothing
+                # is outstanding" — this run (an earlier attempt in the SAME
+                # `--drain` invocation) cordoned these hosts and they were
+                # never confirmed rolled. Exiting 0 here is exactly the
+                # defect this closes: a cordoned, behind host left invisible
+                # to any wrapper reading the exit code. Name it and fail.
+                stragglers = ", ".join(sorted(remaining))
+                _echo(
+                    "[drain] holding — not enough drift to roll yet "
+                    f"(--min-behind) — still behind and left cordoned: "
+                    f"{stragglers}",
+                    force_stderr=True,
+                )
+                _emit_summary(
+                    drain_status="holding_with_stragglers", attempt=attempt,
+                    remaining=remaining, record=record,
+                )
+                sys.exit(1)
             _echo("[drain] holding — not enough drift to roll yet (--min-behind)")
             _emit_summary(
                 drain_status="holding", attempt=attempt, remaining=remaining, record=record

{code_coordinator-0.5.540 → code_coordinator-0.5.541}/tests/test_cli_release_propagate.py

@@ -3262,6 +3262,102 @@ def test_run_drain_does_not_report_convergence_when_the_breaker_abandons_hosts(
     assert slept, "must have kept polling instead of declaring convergence on attempt 1"
 
 
+# ── #3081: a holding attempt must never read as "every cordoned host
+# converged" ──────────────────────────────────────────────────────────────
+#
+# `release_propagate` finishes a holding attempt BEFORE `_apply_cordons` ever
+# runs (see `STATUS_HOLDING`'s own docstring: "a holding run cordons nothing
+# and touches no host") — so `record.cordons` on a holding attempt is empty
+# by construction, not because every host a PRIOR attempt in the same
+# `--drain` session cordoned actually rolled. The live report: dell64 was
+# named `still behind` on attempt 1 (verified, cordoned), the target then
+# drifted mid-drain (a new release published between polls) so attempt 2's
+# fleet-aggregate `--min-behind` delta fell below threshold and came back
+# `holding` — and `_run_drain` printed the false `[drain] dell64: reached
+# the target` and exited 0 with dell64 still on the old version and still
+# cordoned.
+
+
+def test_run_drain_holding_after_cordoning_reports_stragglers_not_convergence(
+    monkeypatch, capsys,
+):
+    """Reproduces the exact #3081 report: attempt 1 cordons dell64 and rolls
+    three other hosts; attempt 2 comes back `holding` (the target moved from
+    0.5.359 to 0.5.360 between polls, so the fleet-aggregate delta read as
+    "only 1 behind"). dell64 must still be reported as outstanding — never
+    "reached the target" — and the run must exit non-zero naming it rather
+    than exiting 0 with it left cordoned."""
+    attempts = {"n": 0}
+
+    def _fake_attempt(**kwargs):
+        attempts["n"] += 1
+        if attempts["n"] == 1:
+            record = rp.PropagationRecord(
+                started_at=0.0, target_version="0.5.359", status=rp.STATUS_VERIFIED,
+                cordons={
+                    "cordoned": ["dell64"],
+                    "uncordoned": ["dellserver", "precision", "elitebook"],
+                    "stuck_in_cooldown": [], "collateral_spared": [], "unknown": [],
+                },
+            )
+        else:
+            # The target drifted to 0.5.360 between polls and the
+            # fleet-aggregate delta fell below threshold — a holding
+            # attempt, which never reaches `_apply_cordons` at all.
+            record = rp.PropagationRecord(
+                started_at=1.0, target_version="0.5.360", status=rp.STATUS_HOLDING,
+                releases_behind=1, min_releases_behind=5,
+            )
+        exc = SystemExit(0)
+        exc.record = record
+        raise exc
+
+    monkeypatch.setattr(release_cmd.release_propagate, "callback", _fake_attempt)
+    monkeypatch.setattr(release_cmd, "_sleep", lambda s: None)
+
+    with pytest.raises(SystemExit) as exc_info:
+        release_cmd._run_drain(
+            deadline_seconds=60.0, poll_seconds=1.0, do_cordon=True, as_json=False,
+        )
+    out = capsys.readouterr()
+    assert exc_info.value.code == 1, (out.out, out.err)
+    assert "dell64: reached the target" not in out.out, (
+        "dell64 never rolled — a holding attempt must not report it converged"
+    )
+    assert "dell64" in out.err
+    assert "left cordoned" in out.err
+
+
+def test_run_drain_holding_on_the_very_first_attempt_still_exits_clean(
+    monkeypatch, capsys,
+):
+    """The other half of the fix: a `--drain` session whose FIRST attempt
+    already comes back `holding` — nothing has been cordoned yet this
+    session — must still exit 0. Carrying `last_remaining` forward through a
+    holding attempt must not manufacture stragglers out of nothing."""
+
+    def _fake_attempt(**kwargs):
+        record = rp.PropagationRecord(
+            started_at=0.0, target_version="0.5.360", status=rp.STATUS_HOLDING,
+            releases_behind=1, min_releases_behind=5,
+        )
+        exc = SystemExit(0)
+        exc.record = record
+        raise exc
+
+    monkeypatch.setattr(release_cmd.release_propagate, "callback", _fake_attempt)
+    slept: list[float] = []
+    monkeypatch.setattr(release_cmd, "_sleep", lambda s: slept.append(s))
+
+    with pytest.raises(SystemExit) as exc_info:
+        release_cmd._run_drain(
+            deadline_seconds=60.0, poll_seconds=1.0, do_cordon=True, as_json=False,
+        )
+    out = capsys.readouterr()
+    assert exc_info.value.code == 0, (out.out, out.err)
+    assert not slept
+
+
 # ── #3047 review: `--drain --json` must be one parseable document ────────