code-coordinator 0.5.252__tar.gz → 0.5.254__tar.gz

{code_coordinator-0.5.252 → code_coordinator-0.5.254}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.252",
+  "tag": "0.5.254",
   "distance": 0,
-  "node": "g05161051c601022afb4bd68113723cd72c2514f1",
+  "node": "g83ff84b37c57af71b3aa15734da48e4c5a1f2c5f",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-27"

{code_coordinator-0.5.252 → code_coordinator-0.5.254}/coord/commands/release.py

@@ -1337,16 +1337,17 @@ def _python_lane_versions(
     """``{host: the OLDEST version its python lane reports}`` (#2101).
 
     "Python lane" is whatever :func:`coord.release_propagate.verify_lane_kind`
-    grades as one — the venv itself plus the live `coord-serve` process —
-    rather than a second list that could drift from the one the roll and the
-    gate already use.
+    grades as one — the venv itself plus the live `coord-serve` and
+    `coord-agent` processes — rather than a second list that could drift
+    from the one the roll and the gate already use.
 
     Two deliberate readings:
 
     * the OLDEST readable version wins, because a host is as behind as its
-      most stale python lane. A venv that swapped while `coord-serve` still
-      runs the old generation is #2069's exact defect, and it must read as
-      "behind", not as "done";
+      most stale python lane. A venv that swapped while `coord-serve` (or,
+      on the daemon host, `coord-agent` — #2841) still runs the old
+      generation is #2069's exact defect, and it must read as "behind", not
+      as "done";
     * a host with an unreadable lane and no readable lane BEHIND the target is
       ``None`` — "no data", never "current" (#1834). `None` is what stops the
       host being cordoned on a guess *and* what stops an existing cordon being

{code_coordinator-0.5.252 → code_coordinator-0.5.254}/coord/release_propagate.py

@@ -271,10 +271,21 @@ ALL_LANES: tuple[str, ...] = (LANE_PYTHON, LANE_UNITS, LANE_TUI)
 #: spawns`` (what it would hand subprocesses), and the one #2069's restart
 #: actually targets, so it needs its own exact entry rather than falling out
 #: of the ``" spawns"`` suffix rule below.
+#:
+#: ``coord-agent process`` (:func:`coord.release_verify.lanes_for_host`) is
+#: #2069 for ``coord-agent``: the agent's own frozen-at-start ``__version__``,
+#: as distinct from ``coord-agent spawns`` (a fresh subprocess re-resolving
+#: the venv on every poll, which flips the instant a swap lands whether or
+#: not the agent restarted). On the daemon host the agent can *never*
+#: self-restart (`agent_app.py`'s `_idle_restart_target` refuses there on
+#: purpose), so this is the only lane that still reads a staged-but-
+#: unrestarted swap as behind on that host — see the module docstring's
+#: "REACH MUST GROW TO MEET THE GATE" section.
 _VERIFY_LANE_EXACT: dict[str, str] = {
     "~/.coord-venv": LANE_PYTHON,
     "coord-tui": LANE_TUI,
     "coord-serve process": LANE_PYTHON,
+    "coord-agent process": LANE_PYTHON,
 }
 
 #: Units whose *live process* a python-lane roll actually replaces. ``POST

{code_coordinator-0.5.252 → code_coordinator-0.5.254}/coord/release_verify.py

@@ -245,6 +245,36 @@ def lanes_for_host(host: str, health: dict | None) -> list[Lane]:
             )
         )
 
+    # ── coord-agent process — the agent's OWN running version (#2841) ────
+    # `version` is `coord.__version__`, imported once at process start and
+    # frozen for that process's whole life (`coord/agent_app.py`'s health
+    # handler: `data["version"] = __version__`). That is exactly what #1834
+    # means by "verify the running process, not the venv" — unlike
+    # `coord-agent spawns` above, which resolves a *fresh* `coord --version`
+    # subprocess through the service PATH and therefore reports the new
+    # version the instant a blue/green swap flips `~/.coord-venv`, whether or
+    # not the agent that would spawn it has itself restarted.
+    #
+    # That distinction is cosmetic almost everywhere, because the agent
+    # self-restarts on an idle swap (`_idle_restart_target`) and the two
+    # lanes reconverge within one poll cycle. It stops being cosmetic on the
+    # daemon host: `_idle_restart_target` deliberately returns `None` there
+    # (a self-restarted agent would out-rank the `coord-serve` sitting next
+    # to it — see that function's docstring), so the daemon host's agent is
+    # the one case where nothing but this lane ever reads a staged-but-
+    # unrestarted swap as behind. #2069 gave `coord-serve` a `process` lane
+    # for the identical reason; this is that fix one unit over, for
+    # `coord-agent`.
+    if health is not None and "version" in health:
+        lanes.append(
+            Lane(
+                host=host,
+                lane="coord-agent process",
+                version=health.get("version") or None,
+                process=True,
+            )
+        )
+
     return lanes
 
 

{code_coordinator-0.5.252 → code_coordinator-0.5.254}/tests/test_cli_release_window.py

@@ -126,12 +126,21 @@ def _serve_health(host: str) -> dict:
     }
 
 
-def _stub_verify(monkeypatch, *, daemon_version: str | None, daemon: str = "server"):
+def _stub_verify(monkeypatch, *, daemon_version: str | None, daemon: str = "server",
+                 extra_lanes=()):
     """Replace `coord.release_verify`'s fleet sweep with a canned daemon-host
-    python lane — same seam `tests/test_cli_release_propagate.py` uses."""
+    python lane — same seam `tests/test_cli_release_propagate.py` uses.
+
+    ``extra_lanes`` lets a test add other python-lane rows for the same
+    host (e.g. a `coord-agent process` lane, #2841) without duplicating this
+    whole stub — `_python_lane_versions` takes the OLDEST of everything
+    `verify_lane_kind` grades as `LANE_PYTHON`, so a stale extra lane here is
+    exactly how a test proves that oldest-wins reach.
+    """
     from coord import release_verify as rv
 
-    lanes = [rv.Lane(host=daemon, lane="~/.coord-venv", version=daemon_version)]
+    lanes = [rv.Lane(host=daemon, lane="~/.coord-venv", version=daemon_version),
+             *extra_lanes]
     machine_health = {daemon: _serve_health(daemon)}
     monkeypatch.setattr(rv, "gather",
                         lambda *a, **k: (machine_health, {}, None, daemon))
@@ -273,6 +282,59 @@ def test_a_needed_roll_with_no_marker_pending_sets_one_and_returns_immediately(
     assert record["queue_restarted"] is None
 
 
+def test_a_staged_but_unrestarted_agent_reads_as_behind_not_up_to_date(
+    valid_config_path, state_dir, no_network, escalations, monkeypatch
+):
+    """#2841: the daemon host's `~/.coord-venv` swap can land — matching the
+    target — while its `coord-agent` process is still running the old
+    release, because the agent can NEVER self-restart on the daemon host
+    (`agent_app.py`'s `_idle_restart_target` returns `None` there on
+    purpose; only the ordered `/update` + `/restart-services` path this
+    command's sibling, `coord release propagate`, drives can move it).
+
+    Before the `coord-agent process` lane existed, `~/.coord-venv` was the
+    ONLY python lane this command could see for that host, so a staged-but-
+    unrestarted swap read as fully up to date — the exact false green #2069
+    closed for `coord-serve`. `_python_lane_versions`' oldest-wins rule must
+    now pick up the stale `coord-agent process` reading instead, so this run
+    sets a roll-pending marker rather than reporting `up-to-date`.
+
+    Pins the oldest-wins rule across all three python lanes at once — venv
+    and `coord-serve process` already on the target, `coord-agent process`
+    (this issue) the lone straggler — the shape the acceptance criteria
+    names explicitly."""
+    from coord import release_verify as rv
+
+    _stub_verify(
+        monkeypatch, daemon_version="0.5.31",
+        extra_lanes=[
+            rv.Lane(host="server", lane="coord-serve process", version="0.5.31"),
+            rv.Lane(host="server", lane="coord-agent process", version="0.5.30"),
+        ],
+    )
+    systemctl_calls = _stub_systemctl(monkeypatch)
+    prop_calls = _stub_propagate(monkeypatch, status=rp.STATUS_VERIFIED, exit_code=0)
+
+    result = CliRunner().invoke(
+        main,
+        ["release", "nightly-window", "--config", str(valid_config_path),
+         "--target", "0.5.31", "--daemon-host", "server"],
+    )
+    assert result.exit_code == 0, result.output
+    assert systemctl_calls == []
+    assert prop_calls == []  # marker set, not fired synchronously
+
+    pending = dq_cmd.read_roll_pending()
+    assert pending is not None
+    assert pending.target_version == "0.5.31"
+
+    record = _records(state_dir)[0]
+    # The oldest lane wins — the stale agent process, not the swapped venv.
+    assert record["daemon_version"] == "0.5.30"
+    assert record["status"] == rw.STATUS_ROLL_PENDING
+    assert not escalations
+
+
 def test_a_marker_pending_for_a_different_target_is_replaced(
     valid_config_path, state_dir, no_network, escalations, monkeypatch
 ):

{code_coordinator-0.5.252 → code_coordinator-0.5.254}/tests/test_release_propagate.py

@@ -949,6 +949,16 @@ def test_coord_serve_process_is_in_reach_too():
     assert not rp.lane_is_out_of_reach("coord-serve process")
 
 
+def test_coord_agent_process_is_in_reach_too():
+    """#2841: #2069 for `coord-agent`. `coord-agent process` is the agent's
+    own frozen-at-start version (`lanes_for_host`), a different lane than
+    `coord-agent spawns` (a fresh subprocess that re-resolves the venv on
+    every poll and therefore flips the instant a swap lands, restarted or
+    not). Both must resolve to the python lane."""
+    assert rp.verify_lane_kind("coord-agent process") == rp.LANE_PYTHON
+    assert not rp.lane_is_out_of_reach("coord-agent process")
+
+
 def test_a_sibling_unit_finding_blocks_when_its_host_python_lane_rolled():
     """The asymmetry #2069 introduces: a host whose python lane this run
     actually rolled is now accountable for coord-serve too."""

{code_coordinator-0.5.252 → code_coordinator-0.5.254}/tests/test_release_verify.py

@@ -68,9 +68,18 @@ def _result(check_id: str, *, subject: str | None = None, severity: str = "ok",
     return row
 
 
-def _health(*results: dict) -> dict:
-    """An agent `/health` body, shaped like coord/agent.py's."""
-    return {"version": RELEASED, "health": {"schema": 1, "results": list(results)}}
+def _health(*results: dict, version: str | None = RELEASED) -> dict:
+    """An agent `/health` body, shaped like coord/agent.py's.
+
+    ``version`` defaults to :data:`RELEASED` and feeds `lanes_for_host`'s
+    ``coord-agent process`` lane (#2841) — the agent's own frozen-at-start
+    version, distinct from whatever `agent_venv`/`spawned_coord` rows a test
+    also passes in. A test simulating a genuinely uniform fleet (every lane
+    agreeing on one version, stale or not) must pass a matching ``version``
+    here too, or this lane alone would manufacture skew that was never the
+    point of that test.
+    """
+    return {"version": version, "health": {"schema": 1, "results": list(results)}}
 
 
 def _agent_venv(version: str | None, *, editable: bool = False) -> dict:
@@ -839,9 +848,12 @@ def test_tui_binary_never_becomes_a_version_lane() -> None:
     )
     assert report.ok, rv.render(report)
     assert not any(lane.lane == "coord-tui" for lane in report.lanes)
-    # The only version lane present is agent_venv's — tui_binary contributed
-    # no entry to the skew map at all, not even an agreeing one.
-    assert report.versions == {RELEASED: ["~/.coord-venv (dellserver)"]}
+    # The version lanes present are agent_venv's and the agent's own
+    # self-reported process version (#2841) — tui_binary contributed no
+    # entry to the skew map at all, not even an agreeing one.
+    assert report.versions == {
+        RELEASED: ["coord-agent process (dellserver)", "~/.coord-venv (dellserver)"]
+    }
 
 
 def test_absent_cli_venv_is_not_a_lane() -> None:
@@ -1146,8 +1158,8 @@ def test_a_uniformly_stale_fleet_is_not_reported_clean() -> None:
     skew-only run must say so rather than render a clean bill of health."""
     report = rv.verify(
         machine_health={
-            "dellserver": _health(_agent_venv(STALE)),
-            "elitebook": _health(_agent_venv(STALE)),
+            "dellserver": _health(_agent_venv(STALE), version=STALE),
+            "elitebook": _health(_agent_venv(STALE), version=STALE),
         },
     )
     assert not report.ok, rv.render(report)