code-coordinator 0.5.153__tar.gz → 0.5.154__tar.gz

{code_coordinator-0.5.153 → code_coordinator-0.5.154}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.153",
+  "tag": "0.5.154",
   "distance": 0,
-  "node": "g2968c6a10a7c3b15da201f4fd9049f641c23b3ee",
+  "node": "g318d3f718e0a8945e4363a00807cd76278153173",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.153 → code_coordinator-0.5.154}/coord/commands/release.py

@@ -1070,10 +1070,22 @@ def release_propagate(  # noqa: PLR0912, PLR0915 — a pipeline; the decisions a
     gate = rp.scope_verification(record.verification, lanes=record.lanes)
     record.gate = gate.to_dict()
     for finding in gate.advisory:
+        host = finding.get("host")
+        # #2403: elitebook sat on 0.5.146 (expected 0.5.148) for the length
+        # of a cordon's full lifetime with this line as the ONLY signal an
+        # operator got — "fix by hand" with no hand to follow. When the
+        # finding names a host, name the two commands that actually clear
+        # it, so nobody has to derive them from scratch under time pressure.
+        remedy = (
+            f" — run `coord agent update --machine {host}` then "
+            f"`coord release cordon --clear {host}`"
+            if host
+            else ""
+        )
         click.echo(
-            f"  ~ advisory [{finding.get('severity')}] {finding.get('host')} "
+            f"  ~ advisory [{finding.get('severity')}] {host} "
             f"{finding.get('lane')}: {finding.get('summary')} "
-            "— outside propagation's reach, fix by hand",
+            f"— outside propagation's reach, fix by hand{remedy}",
             err=True,
         )
     if gate.unrollable:

{code_coordinator-0.5.153 → code_coordinator-0.5.154}/tests/test_cli_release_propagate.py

@@ -847,6 +847,57 @@ def test_a_green_roll_is_verified_and_journalled(valid_config_path, state_dir,
     assert record["verification"]["severity"] == "ok"
 
 
+def test_a_waiting_between_legs_entry_rolls_its_host_normally(
+    valid_config_path, state_dir, no_network, monkeypatch
+):
+    """#2403, end to end: `laptop`'s only queue entry is `waiting` — deferred
+    by an unrelated repo-capacity cap (#1972), exactly `claude-coordinator
+    #2005`'s live shape on 2026-08-18 — with a terminal assignment recording
+    `laptop` as its last worker. #2240's "last known host" fallback exists
+    for a `running` between-legs row; it must not reach a `waiting` one. A
+    genuinely idle `laptop` has to roll and verify like any other free host,
+    not sit deferred and cordoned on the strength of a queue row that never
+    launched anything."""
+    monkeypatch.setattr(
+        release_cmd, "_fetch_board",
+        lambda: (
+            {
+                "drive_queue": [
+                    {"repo_name": "api", "issue_number": 2005,
+                     "state": "waiting", "deferrals": 3, "attempts": 2},
+                ],
+                "assignments": [
+                    {"repo_name": "api", "issue_number": 2005,
+                     "machine_name": "laptop", "status": "COMPLETED",
+                     "dispatched_at": 100.0},
+                ],
+            },
+            None,
+        ),
+    )
+    calls = _stub_lanes(monkeypatch)
+    _stub_verify(monkeypatch, versions={"laptop": ["0.4.110"], "server": ["0.4.110"]},
+                 daemon="server")
+    result = CliRunner().invoke(
+        main,
+        ["release", "propagate", "--config", str(valid_config_path),
+         "--target", "0.4.111"],
+    )
+    assert result.exit_code == 0, result.output
+    assert rp.STATUS_DEFERRED not in result.output
+    assert any(host == "laptop" for _lane, host in calls), (
+        "a waiting queue row must never defer the host it names as its "
+        "last known worker"
+    )
+    record = _records(state_dir)[0]
+    assert record["status"] == rp.STATUS_VERIFIED
+    assert not any(
+        l["host"] == "laptop" and l["lane"] == "-" for l in record["lanes"]
+    )
+    # Nothing is left cordoned behind a row that was never actually running.
+    assert mp.cordoned_names() == set()
+
+
 def test_a_red_verification_rolls_every_updated_host_back(valid_config_path, state_dir,
                                                           no_network, monkeypatch):
     """#1835: 'a red post-deploy verification must roll back, not just
@@ -1221,6 +1272,47 @@ def test_2026_08_09_a_good_roll_is_not_reverted_by_lanes_it_cannot_roll(
     assert "advisory" in result.output
 
 
+def test_the_outside_reach_message_names_the_manual_remedy(
+    valid_config_path, state_dir, no_network, monkeypatch
+):
+    """#2403: elitebook sat behind for the length of a cordon's lifetime with
+    only `"outside propagation's reach, fix by hand"` as its signal — no
+    remedy, just an instruction to invent one under time pressure. A
+    finding that names a host must name the two commands that actually fix
+    it: `coord agent update --machine <host>` and `coord release cordon
+    --clear <host>`."""
+    from coord import release_verify as rv
+
+    # `laptop` has a live assignment, so its python lane is deferred (never
+    # attempted) this run — exactly why its own version-mismatch finding
+    # lands as advisory rather than blocking (#2052's `attempted_scope`).
+    monkeypatch.setattr(
+        release_cmd, "_fetch_board",
+        lambda: ({"assignments": [{"machine_name": "laptop", "issue_number": 9,
+                                   "status": "RUNNING"}]}, None),
+    )
+    _stub_lanes(monkeypatch)
+    _stub_verify(
+        monkeypatch,
+        versions={"laptop": ["0.4.110"], "server": ["0.4.110"]},
+        daemon="server",
+        findings=[
+            rv.Finding(severity="crit", host="laptop",
+                       lane="~/.coord-venv (laptop)",
+                       summary="on 0.4.104, expected 0.4.111"),
+        ],
+    )
+    result = CliRunner().invoke(
+        main,
+        ["release", "propagate", "--config", str(valid_config_path),
+         "--target", "0.4.111"],
+    )
+    assert result.exit_code == 0, result.output
+    assert "outside propagation's reach, fix by hand" in result.output
+    assert "coord agent update --machine laptop" in result.output
+    assert "coord release cordon --clear laptop" in result.output
+
+
 def test_a_crit_on_a_lane_this_run_rolled_still_reverts(valid_config_path, state_dir,
                                                         no_network, monkeypatch):
     """Scoping the gate is not removing it."""

{code_coordinator-0.5.153 → code_coordinator-0.5.154}/tests/test_release_propagate.py

@@ -332,6 +332,39 @@ def test_an_unpinned_entry_between_legs_is_unattributable_not_launch_host():
     assert q.rollable_hosts(["dellserver", "elitebook"]) == []
 
 
+def test_a_waiting_entry_between_legs_is_not_attributed_to_its_last_known_host():
+    """#2403, live 2026-08-18 ~23:17 UTC: elitebook was genuinely idle
+    (`active: []` on both `/status` and `/health`), and `coord drive-queue
+    list` showed `claude-coordinator#2005` in state `waiting` — deferred by
+    an unrelated per-repo concurrency cap, not running anywhere. `coord
+    release propagate` nonetheless deferred and cordoned elitebook, reading
+    the log line #2240's fix writes for a genuinely *between-legs* `running`
+    row: "attributed to its last known host".
+
+    #2240's fallback (`_last_assignment_hosts`) exists to narrow an
+    unattributable RUNNING row from fleet-wide to one host — it is not
+    licence to treat a WAITING row as though it were running just because it
+    once had an assignment. Only `state == STATE_RUNNING` may reach that
+    fallback at all; a `waiting` row — however recently it ran, however many
+    times it has been deferred — has no live assignment and no in-flight
+    process anywhere, and must roll its host normally."""
+    entry = {"repo_name": "claude-coordinator", "issue_number": 2005,
+             "state": STATE_WAITING, "deferrals": 3, "attempts": 2}
+    q = rp.assess_quiescence(
+        queue_entries=[entry],
+        # The exact shape `_last_assignment_hosts` reads: a terminal
+        # assignment naming elitebook as the entry's last worker.
+        assignments=[{"repo_name": "claude-coordinator", "issue_number": 2005,
+                      "machine_name": "elitebook", "status": "COMPLETED",
+                      "dispatched_at": 100.0}],
+    )
+    assert q.busy == ()
+    assert q.quiescent
+    assert q.rollable_hosts(["dellserver", "elitebook", "precision"]) == [
+        "dellserver", "elitebook", "precision",
+    ]
+
+
 def test_a_live_assignment_is_attributed_to_its_machine():
     q = rp.assess_quiescence(
         assignments=[{"machine_name": "dellserver", "issue_number": 42,