code-coordinator 0.5.91__tar.gz → 0.5.93__tar.gz

{code_coordinator-0.5.91 → code_coordinator-0.5.93}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.91
+Version: 0.5.93
 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.91 → code_coordinator-0.5.93}/code_coordinator.egg-info/SOURCES.txt

@@ -676,6 +676,7 @@ tests/test_reconcile_merges.py
 tests/test_reconcile_usage_limit_done.py
 tests/test_refine_chat.py
 tests/test_release_cordon_2101.py
+tests/test_release_cordon_daemon_leads_2176.py
 tests/test_release_cordon_deadlock_2240.py
 tests/test_release_propagate.py
 tests/test_release_unified_1242.py

{code_coordinator-0.5.91 → code_coordinator-0.5.93}/code_coordinator.egg-info/scm_file_list.json

@@ -706,6 +706,7 @@
     "tests/test_reconcile_usage_limit_done.py",
     "tests/test_refine_chat.py",
     "tests/test_release_cordon_2101.py",
+    "tests/test_release_cordon_daemon_leads_2176.py",
     "tests/test_release_cordon_deadlock_2240.py",
     "tests/test_release_propagate.py",
     "tests/test_release_unified_1242.py",

{code_coordinator-0.5.91 → code_coordinator-0.5.93}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.91",
+  "tag": "0.5.93",
   "distance": 0,
-  "node": "g39a4e989b2e78a6c7a1571c5f488f9fa1f70ca4f",
+  "node": "g827590698265fe1d05e3d77e84c364f63d767405",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-15"

{code_coordinator-0.5.91 → code_coordinator-0.5.93}/coord/commands/plan_followup.py

@@ -655,16 +655,7 @@ def _fix_from_review(
     """
     from coord import auto_loop
     from coord.board_service import write_board
-    from coord.state import COORD_DIR
-
-    if guidance:
-        click.echo(
-            "warning: --guidance is ignored for a review id — the reviewer's "
-            "findings ARE the fix briefing. To brief a fix in your own words "
-            f"use `coord assign <machine> <repo> <issue> --fix-of "
-            f"{review.assignment_id} --interactive --briefing ...`.",
-            err=True,
-        )
+    from coord.state import COORD_DIR, add_issue_context_entry
 
     work = None
     if review.review_of_assignment_id:
@@ -678,6 +669,28 @@ def _fix_from_review(
         )
         sys.exit(1)
 
+    # #2092: --guidance used to be silently discarded here — a warning was
+    # printed immediately above a success line the operator often doesn't
+    # read past the tail of, so a maintainer decision could be lost with no
+    # visible trace. Route it through the #603 pinned per-issue context store
+    # instead of dropping it OR bolting a second implementation of fix-
+    # briefing assembly onto this CLI door: `_dispatch_fix_for_review`
+    # already prepends `issue_context_block(...)` to the TOP of every fix
+    # briefing it builds, ABOVE the reviewer's findings, so a pinned entry
+    # written here lands exactly where the operator's guidance belongs — and
+    # (unlike a one-shot parameter) it also survives into every later
+    # briefing for this issue, not just this one dispatch.
+    if guidance:
+        add_issue_context_entry(
+            work.repo_name, work.issue_number, guidance,
+            pinned=True, source="coord fix --guidance",
+        )
+        click.echo(
+            f"guidance pinned to issue #{work.issue_number} context (#603) — "
+            "it will be prepended above the reviewer's findings in the fix "
+            "briefing.",
+        )
+
     # #555: an INTERACTIVE work completion must never be silently followed by a
     # headless fix.  The human at the tmux pane owns that branch and may still
     # be mid-edit; a `claude -p` worker pushing over them is the incident that

{code_coordinator-0.5.91 → code_coordinator-0.5.93}/coord/commands/release.py

@@ -694,11 +694,25 @@ def release_propagate(  # noqa: PLR0912, PLR0915 — a pipeline; the decisions a
     )
     current = rp.hosts_already_current(_lane_versions_by_host(before), record.target_version)
 
+    # #2176: resolved here, ahead of cordoning, so the cordon plan can honour
+    # the same daemon-leads invariant the roll itself is bound by (see below).
+    # Purely a derivation from data already in hand (`machine_health`) — this
+    # does not move the "unorderable fleet" REFUSAL, which stays below the
+    # deferral branch on purpose (see its own comment).
+    daemon_name = _daemon_machine_name(config, daemon_host_override, machine_health)
+
     # ── 3b. cordon the hosts that are behind, so they DRAIN (#2101) ──────
     #
     # Before the deferral return below, on purpose: cordoning is the thing
     # that turns "no window" into "a window in a few minutes". A run that
     # defers without cordoning has changed nothing about why it deferred.
+    #
+    # #2176: a non-daemon host with no busy signal of its own is exempted
+    # while the daemon host is itself busy and behind — see `plan_cordons`'s
+    # `daemon_host` handling. It cannot roll ahead of a busy daemon host
+    # regardless of its own drain state (the daemon-leads invariant below),
+    # so cordoning it protects nothing and just spends fleet capacity for an
+    # unbounded wait.
     record.cordons = _apply_cordons(
         hosts=hosts,
         report=before,
@@ -712,6 +726,7 @@ def release_propagate(  # noqa: PLR0912, PLR0915 — a pipeline; the decisions a
         state_dir=state_dir,
         max_deferrals=cordon_max_deferrals,
         release_cooldown=cordon_cooldown,
+        daemon_host=daemon_name,
     )
 
     if fully_busy and not force:
@@ -722,12 +737,12 @@ def release_propagate(  # noqa: PLR0912, PLR0915 — a pipeline; the decisions a
         # meets a fleet that is actually draining.
         _finish(rp.STATUS_DEFERRED, 0)
 
-    # #2101: resolved AFTER the deferral above, deliberately. This refusal is
-    # about the ORDER a roll happens in; a run that is going to roll nothing
-    # has no order to get wrong, and turning "the fleet is busy" into a
-    # `failed` record (exit 1, systemd marks the unit failed) would teach an
-    # operator to ignore the one signal that matters.
-    daemon_name = _daemon_machine_name(config, daemon_host_override, machine_health)
+    # #2101: this refusal is checked AFTER the deferral above, deliberately.
+    # This refusal is about the ORDER a roll happens in; a run that is going
+    # to roll nothing has no order to get wrong, and turning "the fleet is
+    # busy" into a `failed` record (exit 1, systemd marks the unit failed)
+    # would teach an operator to ignore the one signal that matters.
+    # (`daemon_name` itself was resolved earlier, before cordoning — #2176.)
     if daemon_name is None and len(hosts) > 1:
         # #2052 fault 2: this used to warn and roll in coordinator.yml order.
         # It then briefly put the daemon host BEHIND both its callers during a
@@ -1082,6 +1097,7 @@ def _apply_cordons(  # noqa: PLR0912 — one linear apply-the-plan pass
     state_dir: Path | None = None,
     max_deferrals: int | None = None,
     release_cooldown: float | None = None,
+    daemon_host: str | None = None,
 ) -> dict:
     """Plan and apply this run's cordons. Returns the journal fragment.
 
@@ -1090,6 +1106,13 @@ def _apply_cordons(  # noqa: PLR0912 — one linear apply-the-plan pass
     Failing the whole propagation because the cordon could not be renewed
     would make #2101's fix strictly worse than not having it.
 
+    *daemon_host* (#2176) lets :func:`~coord.release_cordon.plan_cordons`
+    exempt a non-daemon host with no busy signal of its own from cordoning
+    while the daemon host is itself busy and behind — see that function's
+    docstring for the reasoning. ``None`` (an unorderable fleet) disables
+    the exemption and falls back to cordoning every behind host, same as
+    before #2176.
+
     #2240: *state_dir* is where the propagation journal lives, and the journal
     is where "how many runs in a row has this cordon now deferred?" is stored
     — the process holding the answer in memory is restarted by the roll it is
@@ -1162,10 +1185,13 @@ def _apply_cordons(  # noqa: PLR0912 — one linear apply-the-plan pass
             if release_cooldown is None
             else release_cooldown
         ),
+        daemon_host=daemon_host,
     )
     for line in plan.render():
         click.echo(line)
     outcome.cooling_seconds = plan.cooling_seconds
+    outcome.collateral_spared = list(plan.collateral_spared)
+    outcome.blocked_behind = plan.blocked_behind
     if plan.released is not None:
         outcome.released = plan.released.to_dict()
         # stderr as well as stdout: on the timer host this line IS the

{code_coordinator-0.5.91 → code_coordinator-0.5.93}/coord/release_cordon.py

@@ -142,6 +142,35 @@ and #2082 is the cost of tolerating that. The threshold is a knob
 (``coord release propagate --cordon-after N``) precisely so a future cadence
 change does not need a code change. Trap F.
 
+CORDON-EVERY-BEHIND-HOST DOES NOT COVER A HOST THAT CANNOT ROLL EITHER WAY
+----------------------------------------------------------------------------
+Observed 2026-08-13 00:18 UTC: one busy signal, on dellserver, and the fleet
+cordoned all three machines anyway. elitebook and precision reported
+``online • idle`` throughout and stayed cordoned — launch-blocked — for
+34+ minutes, unable to accept the very review dispatch #2240 needed.
+
+The cordon-every-behind-host rule above is correct for a host whose OWN
+draining is what a run is waiting on: skip it and it never drains, and a run
+that defers without cordoning defers again in 20 minutes for the same
+reason. It does not cover a host that has no busy signal against it AND is
+blocked from rolling by the daemon-leads invariant (see
+:mod:`coord.release_propagate`'s LANE ORDER section) rather than by its own
+work — nothing may roll ahead of a busy daemon host, so such a host cannot
+roll regardless of how drained it gets. Cordoning it protects nothing: its
+drained state cannot be consumed until the daemon host rolls first, which
+may be unbounded (any drive on the daemon host reproduces this, not just a
+wedged one).
+
+:func:`plan_cordons`'s *daemon_host* parameter is the fix: while the daemon
+host is itself busy and behind, only it (and any host with its own busy
+signal) is cordoned. Everyone else stays uncordoned and dispatchable —
+released immediately if a previous run already cordoned them — until the
+daemon host becomes rollable, at which point ordinary drain-everyone-behind
+resumes. :attr:`CordonPlan.collateral_spared` /
+:attr:`CordonPlan.blocked_behind` name exactly who was spared and why, so
+the next puzzle like this one is one line of output, not a 40-minute read of
+`/board`.
+
 PURITY
 ------
 Nothing here reads the clock, the filesystem, the network or the DB — same
@@ -618,6 +647,17 @@ class CordonPlan:
     #: recorded rather than silent, because "no cordons planned" and "cordons
     #: suppressed on purpose" are the same output otherwise.
     cooling_seconds: float = 0.0
+    #: #2176: behind hosts this run deliberately did NOT cordon (and, if
+    #: already cordoned, released) because they have no busy signal of their
+    #: own and cannot roll ahead of `blocked_behind` anyway. Reported
+    #: separately from `uncordon` (which is "proven current") so the journal
+    #: and CLI output can name them as collateral rather than as a drain that
+    #: completed.
+    collateral_spared: tuple[str, ...] = ()
+    #: #2176: the daemon host these hosts are spared on account of — set
+    #: exactly when `collateral_spared` is non-empty. The single fact that
+    #: would have turned a 40-minute puzzle into one line of output.
+    blocked_behind: str | None = None
 
     @property
     def empty(self) -> bool:
@@ -627,6 +667,7 @@ class CordonPlan:
             or self.escalations
             or self.expired
             or self.released
+            or self.collateral_spared
         )
 
     def to_dict(self) -> dict:
@@ -638,6 +679,8 @@ class CordonPlan:
             "unknown": list(self.unknown),
             "released": self.released.to_dict() if self.released else None,
             "cooling_seconds": self.cooling_seconds,
+            "collateral_spared": list(self.collateral_spared),
+            "blocked_behind": self.blocked_behind,
         }
 
     def render(self) -> list[str]:
@@ -645,6 +688,14 @@ class CordonPlan:
         lines: list[str] = []
         for item in self.cordon:
             lines.append(f"  ⊘ cordon {item.machine}: {item.describe()}")
+        if self.collateral_spared:
+            lines.append(
+                "  · "
+                + ", ".join(sorted(self.collateral_spared))
+                + f": left uncordoned — blocked behind daemon host "
+                f"{self.blocked_behind} either way, cordoning would not help "
+                "(#2176)"
+            )
         for name in self.uncordon:
             lines.append(f"  ✓ uncordon {name}: up to date, work may resume")
         for name in self.expired:
@@ -748,12 +799,15 @@ def plan_cordons(
     pressure: DeferralPressure | None = None,
     max_deferrals: int = DEFAULT_MAX_DEFERRALS,
     release_cooldown: float = DEFAULT_RELEASE_COOLDOWN_SECONDS,
+    daemon_host: str | None = None,
 ) -> CordonPlan:
     """Decide this run's cordon writes. Pure.
 
     *existing* is the store as read (expired records included — this function
     is what notices they lapsed). *busy_reasons* maps a host to why it is not
-    yet drained, purely so an escalation can say what is holding it.
+    yet drained, purely so an escalation can say what is holding it — and
+    (#2176) so this function can tell a genuinely busy host from an idle one
+    when deciding who is collateral.
 
     ``enabled=False`` (``coord release propagate --no-cordon``) plans no new
     cordons but STILL clears the ones this owner already set: turning the
@@ -772,6 +826,21 @@ def plan_cordons(
     Proven-current hosts are uncordoned in every one of these branches: that
     is never the wrong move, and skipping it during a cooldown would leave a
     rolled host cordoned for the length of the cooldown.
+
+    *daemon_host* (#2176) is the machine `coord release propagate` will roll
+    first (see `coord.release_propagate`'s LANE ORDER section) — the
+    daemon-leads invariant means no OTHER host's python lane may roll ahead
+    of it while it is itself busy and behind. A behind host with no busy
+    signal of its own is therefore collateral, not protected, by a cordon
+    while that holds: it cannot roll either way, so draining it buys nothing
+    and just spends fleet capacity for a wait that is unbounded from its own
+    perspective (#2067 made quiescence per-host; this closes the cordon's
+    matching gap). Such a host is left uncordoned — and released immediately
+    if a previous run already cordoned it — until the daemon host is
+    rollable (quiescent, or already on the target), at which point ordinary
+    drain-everyone-behind resumes exactly as before #2176. A host that is
+    itself busy is cordoned regardless: its own drain is still the thing
+    being waited on, whatever the daemon host is doing.
     """
     records = _as_records(existing)
     live = {name: c for name, c in records.items() if c.active(now)}
@@ -782,11 +851,30 @@ def plan_cordons(
     if not enabled:
         return CordonPlan(uncordon=tuple(sorted(live)), expired=expired)
 
-    # Uncordon: PROVEN current, and nothing else. A host whose version could
-    # not be read keeps whatever cordon it has until that cordon EXPIRES —
-    # clearing on "we couldn't read the version" would open the fleet up
-    # mid-roll on the strength of one failed HTTP call.
-    to_uncordon = tuple(sorted(name for name in live if name in drift.current))
+    # ── #2176: who is collateral to a busy, behind daemon host ────────────
+    daemon_blocked = bool(
+        daemon_host
+        and (busy_reasons or {}).get(daemon_host)
+        and daemon_host not in drift.current
+    )
+    collateral = frozenset(
+        host
+        for host in drift.behind
+        if daemon_blocked and host != daemon_host and not (busy_reasons or {}).get(host)
+    )
+    blocked_behind = daemon_host if collateral else None
+
+    # Uncordon: PROVEN current, plus (#2176) any collateral host a previous
+    # run already cordoned — "spared" means dispatchable now, not "merely not
+    # renewed". A host whose version could not be read otherwise keeps
+    # whatever cordon it has until that cordon EXPIRES — clearing on "we
+    # couldn't read the version" would open the fleet up mid-roll on the
+    # strength of one failed HTTP call.
+    to_uncordon = tuple(
+        sorted(
+            {name for name in live if name in drift.current} | (collateral & set(live))
+        )
+    )
 
     # ── #2240: the deadlock bound ────────────────────────────────────────
     pressure = pressure or DeferralPressure()
@@ -797,6 +885,8 @@ def plan_cordons(
             expired=expired,
             cooling_seconds=cooling,
             unknown=tuple(sorted(drift.undecided & set(live))),
+            collateral_spared=tuple(sorted(collateral)),
+            blocked_behind=blocked_behind,
         )
     if max_deferrals > 0 and pressure.consecutive >= max_deferrals:
         return CordonPlan(
@@ -809,11 +899,13 @@ def plan_cordons(
                 cooldown_seconds=release_cooldown,
                 target_version=target_version,
             ),
+            collateral_spared=tuple(sorted(collateral)),
+            blocked_behind=blocked_behind,
         )
 
     to_cordon: list[Cordon] = []
     escalations: list[DrainEscalation] = []
-    for host in sorted(drift.behind):
+    for host in sorted(drift.behind - collateral):
         previous = live.get(host)
         created = previous.created_at if previous and previous.created_at else now
         to_cordon.append(
@@ -844,6 +936,8 @@ def plan_cordons(
         escalations=tuple(escalations),
         expired=expired,
         unknown=tuple(sorted(drift.undecided & set(live))),
+        collateral_spared=tuple(sorted(collateral)),
+        blocked_behind=blocked_behind,
     )
 
 
@@ -883,6 +977,13 @@ class CordonOutcome:
     #: out of the newest record instead of every caller of
     #: :func:`describe_deferral_pressure` assuming the default.
     max_deferrals: int = DEFAULT_MAX_DEFERRALS
+    #: #2176: behind hosts this run spared (or actively released) because
+    #: they have no busy signal of their own and cannot roll ahead of a busy,
+    #: behind daemon host anyway. Mirrors `CordonPlan.collateral_spared`.
+    collateral_spared: list[str] = field(default_factory=list)
+    #: #2176: the daemon host `collateral_spared` was spared on account of.
+    #: Mirrors `CordonPlan.blocked_behind`.
+    blocked_behind: str | None = None
 
     def to_dict(self) -> dict:
         return {
@@ -896,4 +997,6 @@ class CordonOutcome:
             "cooling_seconds": self.cooling_seconds,
             "pressure": dict(self.pressure),
             "max_deferrals": self.max_deferrals,
+            "collateral_spared": list(self.collateral_spared),
+            "blocked_behind": self.blocked_behind,
         }

{code_coordinator-0.5.91 → code_coordinator-0.5.93}/coord/release_propagate.py

@@ -1247,6 +1247,14 @@ def render_record(record: PropagationRecord | Mapping[str, Any]) -> list[str]:
         )
     if cordons.get("uncordoned"):
         lines.append("    uncordoned: " + ", ".join(cordons["uncordoned"]))
+    # #2176: name the collateral hosts AND the single host they're collateral
+    # to — the fact that would have turned a 40-minute puzzle into one line.
+    if cordons.get("collateral_spared"):
+        lines.append(
+            "    spared (blocked behind daemon host "
+            f"{cordons.get('blocked_behind')} anyway): "
+            + ", ".join(cordons["collateral_spared"])
+        )
     if cordons.get("expired"):
         lines.append(
             "    cordons that lapsed on their own: " + ", ".join(cordons["expired"])

{code_coordinator-0.5.91 → code_coordinator-0.5.93}/tests/test_cli_fix_headless_review.py

@@ -363,22 +363,38 @@ class TestGuardsSurviveTheCliDoor:
         assert "no structured review findings" in result.output
         http.post.assert_not_called()
 
-    def test_guidance_on_a_review_id_warns(
+    def test_guidance_on_a_review_id_is_pinned_above_the_findings(
         self, config_file: Path, coord_dir: Path
     ) -> None:
-        """The reviewer's findings are the briefing — say so rather than
-        silently dropping the operator's text."""
-        _seed(_work(), _review())
+        """#2092: the reviewer's findings are the briefing, but the operator's
+        guidance is the only source of maintainer decisions the reviewer
+        cannot have — it must reach the worker, not vanish behind a warning.
+        Routed through the #603 pinned per-issue context store, it lands
+        ABOVE the reviewer's findings in the fix briefing."""
+        _seed(_work(), _review(), body="## Blocking\n- 1. GET /outbox is undocumented\n")
         http = _http_mock()
 
         with patch("coord.auto_loop.httpx", http), \
              patch("coord.auto_loop.record_dispatched_assignment"), \
              patch("coord.github_ops.post_issue_comment"):
-            result = _run(config_file, "review-xyz", "--guidance", "try harder")
+            result = _run(
+                config_file, "review-xyz",
+                "--guidance", "MAINTAINER DECISION: keep GET /outbox.",
+            )
 
         assert result.exit_code == 0, result.output
-        assert "--guidance is ignored" in result.output
-        assert "try harder" not in http.post.call_args.kwargs["json"]["briefing"]
+        assert "pinned to issue #42 context" in result.output
+
+        briefing = http.post.call_args.kwargs["json"]["briefing"]
+        assert "MAINTAINER DECISION: keep GET /outbox." in briefing
+        assert briefing.index("MAINTAINER DECISION") < briefing.index(
+            "GET /outbox is undocumented"
+        )
+
+        # It also outlives this one dispatch — it's a durable per-issue entry.
+        from coord.state import issue_context_block
+
+        assert "MAINTAINER DECISION: keep GET /outbox." in issue_context_block("api", 42)
 
 
 # ── Part 3: red CI as the third trigger ──────────────────────────────────────