code-coordinator 0.5.95__tar.gz → 0.5.96__tar.gz

{code_coordinator-0.5.95 → code_coordinator-0.5.96}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.95",
+  "tag": "0.5.96",
   "distance": 0,
-  "node": "g100d9f74dd79bd61b86812c4dd3930e4cc7079ce",
+  "node": "g312293364325c98de0888c4de55e3f5f168662dd",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-15"

{code_coordinator-0.5.95 → code_coordinator-0.5.96}/coord/commands/release.py

@@ -371,6 +371,66 @@ def _interactive_session_busy(config) -> list:
     return busy
 
 
+def _paused_machine_busy(config) -> list:
+    """Operator pause / quiet-hours state as host-pinned `Busy` signals (#2174).
+
+    `release_propagate.assess_quiescence`'s ``extra_busy`` docstring has
+    named "a machine paused by an operator" as a seam producer since
+    #1835, but until now nothing fed it one: `coord pause <machine>` said
+    "leave this box alone" and `coord release propagate` read the machine
+    as quiescent anyway, restarting `coord-agent` (and, on the daemon
+    host, `coord-serve`) on it regardless.
+
+    `coord.machine_pause.follow_on_paused_set()` is explicit `coord pause`
+    UNION any quiet-hours window currently covering the machine — both
+    genuine "an operator or an operator-set policy said stay off this
+    box" facts — MINUS #2101 release cordons. Cordons are deliberately
+    excluded: a cordon is THIS command's own drain mechanism, set to make
+    a behind host quiescent, not a sign that it already is one; feeding a
+    cordon back in here as "busy" would make it defer the very roll it
+    exists to unblock.
+
+    Thin-client aware for free: `follow_on_paused_set` routes through the
+    daemon's `/pause` endpoint when a board service is configured (#1563),
+    so this reads the one copy of pause state that actually governs
+    dispatch — same as every other pause-aware call site in the fleet.
+    """
+    from coord.machine_pause import (  # noqa: PLC0415
+        describe_pause_state,
+        effective_quiet_hours,
+        follow_on_paused_set,
+    )
+    from coord import release_propagate as rp  # noqa: PLC0415
+
+    machines = list(getattr(config, "machines", ()) or ())
+    if not machines:
+        return []
+    paused = follow_on_paused_set(machines)
+    if not paused:
+        return []
+    quiet_hours = effective_quiet_hours(machines)
+    busy = []
+    for machine in machines:
+        if machine.name not in paused:
+            continue
+        state = describe_pause_state(machine, paused, quiet_hours=quiet_hours)
+        if state is None:
+            continue  # defensive: membership in `paused` implies a reason
+        detail = (
+            f"quiet hours {state.detail}" if state.kind == "quiet"
+            else "explicit `coord pause`"
+        )
+        busy.append(
+            rp.Busy(
+                kind="machine paused",
+                subject=machine.name,
+                detail=detail,
+                host=machine.name,
+            )
+        )
+    return busy
+
+
 def _daemon_machine_name(
     config, override: str | None, machine_health: dict | None = None
 ) -> str | None:
@@ -638,6 +698,10 @@ def release_propagate(  # noqa: PLR0912, PLR0915 — a pipeline; the decisions a
     # probe `coord sessions --remote` uses, so a live session defers a roll
     # exactly like a live headless assignment does.
     extra_busy.extend(_interactive_session_busy(config))
+    # #2174: nor can it see `coord pause`/quiet-hours state — feed the same
+    # seam from the daemon-aware pause store, so an operator-paused machine
+    # defers exactly like a live assignment does instead of reading idle.
+    extra_busy.extend(_paused_machine_busy(config))
     quiescence = rp.assess_quiescence(
         queue_entries=board.get("drive_queue") or [],
         assignments=board.get("assignments") or [],
@@ -2163,14 +2227,19 @@ def _drain(
     #2228: ``extra_busy_fetch`` re-probes live interactive sessions on
     every poll (not just once) — a session that ends mid-drain should let
     the daemon host clear within THIS wait, not only on the next `coord
-    release propagate` tick. Deliberately keyed off the explicit *config*
-    param, never an implicit ``_load_config(config_path)`` fallback: this
-    function is called with ``config_path=None`` from unit tests that
-    inject their own clock/board — silently resolving a real
-    ``coordinator.yml`` (and then SSH-probing whatever machines it names)
+    release propagate` tick. #2174: the same default also re-reads
+    `coord pause`/quiet-hours state on every poll, for the same reason —
+    an operator pausing the daemon host mid-drain must stop the drain from
+    ever reporting "clear", and an operator lifting a pause mid-drain
+    should let it clear within THIS wait rather than the next tick.
+    Deliberately keyed off the explicit *config* param, never an implicit
+    ``_load_config(config_path)`` fallback: this function is called with
+    ``config_path=None`` from unit tests that inject their own clock/board
+    — silently resolving a real ``coordinator.yml`` (and then SSH-probing
+    whatever machines it names, or reading this host's own pause store)
     the moment ``config`` is omitted would make this loop non-hermetic by
-    default. No *config* simply means "no interactive-session signal this
-    call" — the caller opts in by passing one, as the real
+    default. No *config* simply means "no interactive-session or pause
+    signal this call" — the caller opts in by passing one, as the real
     ``coord release nightly-window`` call site does.
     """
     import time as _time  # noqa: PLC0415
@@ -2184,7 +2253,12 @@ def _drain(
     fetch_fn = board_fetch or _fetch_board
     if extra_busy_fetch is None:
         if config is not None:
-            extra_busy_fetch = lambda: _interactive_session_busy(config)  # noqa: E731
+            # #2174: paused/quiet-hours state, same as the top-level
+            # `propagate` call site — a paused daemon host must keep the
+            # drain from ever reading "clear" just because tmux is quiet.
+            extra_busy_fetch = lambda: (  # noqa: E731
+                _interactive_session_busy(config) + _paused_machine_busy(config)
+            )
         else:
             extra_busy_fetch = lambda: []  # noqa: E731
 

{code_coordinator-0.5.95 → code_coordinator-0.5.96}/coord/release_propagate.py

@@ -785,7 +785,29 @@ def assess_quiescence(
     #2228: the interactive-session half is wired from
     ``coord.commands.release._interactive_session_busy``, fed by the same
     fleet-wide tmux sweep ``coord sessions --remote`` renders — until then
-    this half of the seam existed but nothing ever fed it.
+    this half of the seam existed but nothing ever fed it. #2174: the
+    operator-pause half is wired from
+    ``coord.commands.release._paused_machine_busy`` — a machine under an
+    explicit ``coord pause`` or an active quiet-hours window (but NOT a
+    #2101 release cordon: that is this module's own drain mechanism, not a
+    sign a host is already quiescent, and feeding it back in here would
+    make a cordon defer the very roll it exists to unblock) becomes a
+    host-pinned :class:`Busy`. Tmux liveness genuinely has no fleet-wide
+    read (it is a LOCAL fact, #1870, and propagation may run from any
+    host) — pause state does, because it is daemon-aware
+    (``coord.machine_pause``) the same way the board is, so both callers
+    can read it cheaply with no new probe.
+
+    Because a :class:`Busy` carries a host, #2067's per-host quiescence
+    does the obvious thing for a paused NON-daemon host: it defers only
+    that host, and the rest of the fleet still rolls. A paused DAEMON host
+    is different on purpose — the daemon-leads invariant (see the module
+    docstring's LANE ORDER) already defers the WHOLE run whenever the
+    daemon host is itself busy and behind, and a pause is just one more
+    way for the daemon host to be busy. So ``coord pause <daemon-host>``
+    halting all propagation, not just that host's own lane, is read as the
+    correct interpretation of "leave this box alone" applied to the one
+    host every other host's roll depends on — not an emergent accident.
 
     #2110: a ``running`` queue row is not, on its own, proof of anything —
     the reconciler that would have moved it to ``done`` lives inside

{code_coordinator-0.5.95 → code_coordinator-0.5.96}/tests/test_cli_release_propagate.py

@@ -26,9 +26,11 @@ import json
 import pytest
 from click.testing import CliRunner
 
+from coord import machine_pause as mp
 from coord import release_propagate as rp
 from coord.cli import main
 from coord.commands import release as release_cmd
+from coord.config import load as load_config
 from coord.drive_queue import HOLD_FIRED, STATE_RUNNING
 
 # Captured at import time, before any fixture has a chance to monkeypatch
@@ -40,6 +42,42 @@ from coord.drive_queue import HOLD_FIRED, STATE_RUNNING
 _REAL_INTERACTIVE_SESSION_BUSY = release_cmd._interactive_session_busy
 
 
+@pytest.fixture(autouse=True)
+def _own_pause_store(tmp_path, monkeypatch):
+    """Give every test in this module its own pause store (#2174).
+
+    `coord release propagate` both READS the pause store (#2174's
+    `_paused_machine_busy`) and WRITES it (#2101's cordons), and several
+    tests below seed it with `mp.local_pause()` / `mp.local_set_cordon()`.
+    That store is per-`$HOME`, not per-test — so without this, one test's
+    pause leaks into every test that runs after it in the same session.
+
+    `conftest._no_real_pause_store` does not cover this: it redirects only
+    when the resolved path lands under the REAL home, on the assumption
+    that a redirected `$HOME` was redirected BY THE TEST, per test. That
+    assumption is false under `scripts/run_tests_in_populated_home.sh`
+    (#2170), where `$HOME` is one throwaway thin-client directory shared by
+    the WHOLE run: the guard stands down and the store becomes session
+    state. That is exactly how this module went green on `ubuntu-latest`
+    and red on the `populated-home` job — a phantom `machine paused:
+    server` in tests that never paused anything, deferring rolls that
+    should have proceeded.
+
+    Redirecting `$HOME` (rather than patching `_state_path`) is what every
+    other pause-touching module here already does — `test_machine_pause`,
+    `test_quiet_hours`, `test_release_cordon_2101`,
+    `test_release_cordon_deadlock_2240` — and it also pins the thin-client
+    decision: a tmp `$HOME` has no `client.toml`, so this module resolves
+    board-service the same way in both CI jobs instead of inheriting
+    whichever shape the ambient home happens to have.
+    """
+    home = tmp_path / "home"
+    (home / ".coord").mkdir(parents=True)
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setenv("USERPROFILE", str(home))
+    return home
+
+
 @pytest.fixture()
 def state_dir(tmp_path, monkeypatch):
     """Point the propagation journal at a tmp dir, never the real ~/.coord."""
@@ -608,6 +646,129 @@ def test_a_failing_session_probe_does_not_defer_the_fleet(
     assert _records(state_dir)[0]["status"] == rp.STATUS_VERIFIED
 
 
+# ──────────────────────────────────────────────────────────────────────────
+# #2174: `coord pause <machine>` says "leave this box alone" — the board has
+# no `paused` column on any row, so it has to reach `assess_quiescence`
+# through the same `extra_busy` seam as a live interactive session.
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def test_a_paused_non_daemon_host_defers_alone_while_the_daemon_rolls(
+    valid_config_path, state_dir, no_network, monkeypatch
+):
+    """`laptop` is paused; `server` (the daemon) is not. `server` must roll
+    and verify while `laptop`'s lane is recorded as a per-host deferral
+    naming the pause, not attempted — the same shape as a live headless
+    assignment (#2067) or a live interactive session (#2228). This is the
+    exact regression #2174 reports: before the fix, a paused machine read as
+    idle and `coord release propagate` rolled it anyway."""
+    mp.local_pause("laptop")
+    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 any(host == "server" for _lane, host in calls)
+    assert not any(host == "laptop" for _lane, host in calls)
+
+    record = _records(state_dir)[0]
+    assert record["status"] == rp.STATUS_VERIFIED
+    laptop_lane = next(l for l in record["lanes"] if l["host"] == "laptop")
+    assert laptop_lane["lane"] == "-"
+    assert laptop_lane["ok"] is None
+    assert "deferred" in laptop_lane["detail"]
+    assert "machine paused" in laptop_lane["detail"]
+    assert "laptop" in laptop_lane["detail"]
+
+
+def test_a_paused_host_is_visible_in_a_dry_run_plan(
+    valid_config_path, state_dir, no_network, monkeypatch
+):
+    """Acceptance: `coord release propagate --dry-run` against a board
+    where one machine is paused reports that machine as busy and excludes
+    it from the rollable set, while other hosts remain rollable."""
+    mp.local_pause("laptop")
+    _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", "--dry-run"],
+    )
+    assert result.exit_code == 0, result.output
+    would_roll_lines = "\n".join(
+        l for l in result.output.splitlines() if "would roll" in l
+    )
+    assert "server" in would_roll_lines
+    assert "laptop" not in would_roll_lines
+    assert "machine paused" in result.output
+    assert "explicit `coord pause`" in result.output
+
+
+def test_a_paused_daemon_host_defers_the_whole_run(
+    valid_config_path, state_dir, no_network, monkeypatch
+):
+    """#2174 item 2: pausing the DAEMON host defers the whole run, not just
+    that host's own lane — the daemon-leads invariant already defers
+    everything when the daemon is busy and behind, and a pause is one more
+    way for it to be busy. The recorded reason must name the pause, not a
+    generic 'busy' string."""
+    mp.local_pause("server")
+    monkeypatch.setattr(
+        release_cmd, "_roll_python",
+        lambda *a, **k: pytest.fail("a paused daemon must roll nothing, anywhere"),
+    )
+    _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
+    record = _records(state_dir)[0]
+    assert record["status"] == rp.STATUS_DEFERRED
+    assert record["lanes"] == []
+    assert "machine paused" in record["quiescence"]["reason"]
+    assert "server" in record["quiescence"]["reason"]
+
+
+def test_an_unpaused_fleet_is_unaffected_by_the_pause_seam(
+    valid_config_path, state_dir, no_network, monkeypatch
+):
+    """Acceptance: an unpaused fleet gets no new busy signal from #2174 —
+    `quiescent` and the roll outcome are unchanged from before the fix."""
+    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 {host for _lane, host in calls} == {"laptop", "server"}
+    record = _records(state_dir)[0]
+    assert record["status"] == rp.STATUS_VERIFIED
+    assert record["quiescence"]["quiescent"] is True
+
+
+def test_a_release_cordon_alone_is_not_read_as_an_operator_pause(valid_config_path):
+    """A #2101 release cordon is this command's OWN drain mechanism, not a
+    sign a host is already quiescent — feeding it back in through
+    `_paused_machine_busy` would make a cordon defer the very roll it exists
+    to unblock. Cordoning `laptop` (with no explicit `coord pause` and no
+    quiet-hours window) must not, on its own, produce a `machine paused`
+    busy signal."""
+    mp.local_set_cordon("laptop", target_version="0.4.110")
+    config = load_config(str(valid_config_path))
+    assert release_cmd._paused_machine_busy(config) == []
+
+
 # ── the roll, the final gate, and the rollback on red ────────────────────
 
 

{code_coordinator-0.5.95 → code_coordinator-0.5.96}/tests/test_cli_release_window.py

@@ -36,6 +36,28 @@ from coord.cli import main
 from coord.commands import release as release_cmd
 
 
+@pytest.fixture(autouse=True)
+def _own_pause_store(tmp_path, monkeypatch):
+    """Give every test in this module its own pause store (#2174).
+
+    `test_drain_is_blocked_by_a_paused_daemon_host` calls
+    `mp.local_pause("server")`, and that store is per-`$HOME`, not
+    per-test. `conftest._no_real_pause_store` redirects only when the
+    resolved path lands under the REAL home, so under
+    `scripts/run_tests_in_populated_home.sh` (#2170) — where `$HOME` is one
+    throwaway directory shared by the whole run — the pause survives this
+    test and every later one reads a machine it never paused. See
+    `tests/test_cli_release_propagate.py::_own_pause_store` for the full
+    write-up; this is the same hazard in the sibling module that shares the
+    seam.
+    """
+    home = tmp_path / "home"
+    (home / ".coord").mkdir(parents=True)
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setenv("USERPROFILE", str(home))
+    return home
+
+
 @pytest.fixture()
 def state_dir(tmp_path, monkeypatch):
     """Point the window journal at a tmp dir, never the real ~/.coord."""
@@ -597,6 +619,36 @@ def test_drain_treats_an_unreadable_board_as_fleet_wide_busy():
     assert "board unreadable" in outcome.detail
 
 
+def test_drain_is_blocked_by_a_paused_daemon_host(valid_config_path, monkeypatch):
+    """#2174: `_drain`'s default `extra_busy_fetch` — the one the real
+    `coord release nightly-window` call site uses (it passes `config=`) —
+    must also see `coord pause`/quiet-hours state, not just tmux. A paused
+    daemon host must never read as 'drained' just because the board and
+    tmux are both quiet; before the fix nothing here ever consulted the
+    pause store at all."""
+    from coord import machine_pause as mp
+    from coord.config import load as load_config
+
+    config = load_config(str(valid_config_path))
+    monkeypatch.setattr(release_cmd, "_interactive_session_busy", lambda config: [])
+    mp.local_pause("server")
+
+    outcome = release_cmd._drain(
+        daemon_host="server",
+        config_path=None,
+        config=config,
+        deadline=10.0,
+        poll_interval=5.0,
+        reconcile=lambda: None,
+        board_fetch=lambda: ({}, None),
+        now=(lambda ts=[0.0]: (ts.__setitem__(0, ts[0] + 5.0), ts[0])[1]),
+        sleep=lambda s: None,
+    )
+    assert outcome.drained is False
+    assert "machine paused" in outcome.detail
+    assert "server" in outcome.detail
+
+
 # ── #2187: a VERIFIED, exit-0 propagate must never be reported as
 #    `propagate-failed` — the whole bug this issue is about ─────────────────
 #