code-coordinator 0.5.164__tar.gz → 0.5.165__tar.gz

{code_coordinator-0.5.164 → code_coordinator-0.5.165}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.164",
+  "tag": "0.5.165",
   "distance": 0,
-  "node": "gacacc73c143b2a972a04f33649be185678913aa4",
+  "node": "g5bd13e9adba9bf24c0bf6aedd8cb4bd19bb41bb1",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.164 → code_coordinator-0.5.165}/coord/drive_queue.py

@@ -97,6 +97,7 @@ from coord.merge_queue import (
     is_ci_infra_reason,
     is_ci_pending_reason,
     is_ci_unreadable_reason,
+    is_stale_smoke_reason,
 )
 from coord.models import is_policy_refusal_reason
 
@@ -1810,6 +1811,57 @@ def _dispatch_produced_nothing(entry: QueueEntry, facts: IssueFacts) -> bool:
     return facts.last_dispatched_at < entry.launched_at
 
 
+def _is_merge_gate_block_reason(reason: str | None) -> bool:
+    """#2424: does *reason* already name a merge-gate block — a death whose
+    real cause is a LATER stage (merge), not a dispatch-layer failure?
+
+    `_dispatch_produced_nothing`'s own comparison (``facts.last_dispatched_at
+    < entry.launched_at``) goes stale specifically for a relaunch whose only
+    job is retrying the Merge stage: by design, that relaunch dispatches no
+    new assignment (there is nothing left to dispatch — Work/Test/Review
+    already completed), so the comparison reads exactly like a genuine
+    dispatch failure even though three real assignments did real work. This
+    is the textual escape hatch for that case: when *reason* itself already
+    names a merge-gate block, the generic "#2273 no assignment was ever
+    created" note must not be layered on top of it — see
+    claude-coordinator#2405 (stale smoke verdict) and coord-web#2 (red CI),
+    both live escalations where the dispatch-note actively misdirected an
+    operator toward `drive-queue remove && add` (a wasted Work/Test/Review
+    cycle) instead of the real one-line fix (`coord merge --revalidate`, or
+    fixing the failing CI check).
+
+    Four shapes, all written by `coord/drive.py`'s own merge-stage decision
+    functions — none of them a "no assignment created" signal:
+
+    * `_die`'s exhausted-merge-attempts wording ("merge attempted N times
+      without landing") — `coord assign` succeeded and Work/Test/Review all
+      completed; the LOOP inside a single drive session that kept retrying
+      `coord merge --only` simply ran out of its own attempt budget
+      (#1505/#2078).
+    * `is_stale_smoke_reason` — the #1479 staleness race: the merge base
+      moved out from under a still-valid smoke verdict.
+    * "checks failed" — `coord.merge_queue`'s own `checks_failed` prose
+      (``f"checks failed: {summary}"``): red CI on a PR that was dispatched,
+      built, and reviewed fine.
+    * `_escalate_merge`'s own gate-divergence/terminal-status wording
+      ("smoke_required —" / "review_required —" / "merge_status=...") — the
+      #1505/#1526 immediate-escalation path, which already recorded its own
+      accurate `coord escalate record` before this drive exited.
+    """
+    if not reason:
+        return False
+    lowered = reason.lower()
+    if "merge attempted" in lowered:
+        return True
+    if is_stale_smoke_reason(reason):
+        return True
+    if "checks failed" in lowered:
+        return True
+    if "smoke_required —" in lowered or "review_required —" in lowered:
+        return True
+    return "merge_status=" in lowered
+
+
 def _is_empty_branch_death_reason(reason: str | None) -> bool:
     """#2363: does *reason* name the "claimed success, wrote nothing"
     signature — an acceptance-author or plain work session that exited
@@ -1858,6 +1910,7 @@ def _retry_backoff_reason(
     now: float | None,
     attempts: int,
     retry_backoff_at: float | None,
+    own_reason: str | None = None,
 ) -> str:
     """#2273's launch-side guard: ``''`` unless *entry* is still inside its
     post-death backoff window.
@@ -1898,6 +1951,23 @@ def _retry_backoff_reason(
     ``retry_backoff_at is None`` (a pure-logic caller with no clock, or a row
     predating this column — both degrade to the pre-#2273 behaviour exactly,
     the same posture every other clock-gated check in this module takes).
+
+    *own_reason* (#2424 follow-up): the same text the launch-side dispatch
+    note is gated on (see the comment above `dispatch_only` in
+    `_reconcile_running`'s retry/exhausted branches). Passed through so the
+    widened `DISPATCH_FAILURE_MIN_BACKOFF_SECONDS` spacing below answers the
+    identical "was this actually a dispatch failure" question the launch-side
+    note already answers, rather than recomputing it from
+    `_dispatch_produced_nothing` alone — which, like the note before #2424,
+    cannot tell a genuine pre-`coord assign` crash from a merge-only relaunch
+    that dispatches no new assignment by design. Once `own_reason` already
+    names a merge-gate block (`_is_merge_gate_block_reason`), the 300s floor
+    would be pure mispacing: the rationale for widening it ("a transient
+    dispatch failure cannot spend the whole retry budget inside one tick
+    cadence") does not apply once the cause is known to be a merge-gate
+    block, not a dispatch failure. ``None`` (the default) degrades to the
+    pre-#2424-follow-up behaviour exactly, for callers that have not been
+    updated to pass it.
     """
     if now is None or attempts <= 0 or retry_backoff_at is None:
         return ""
@@ -1906,7 +1976,9 @@ def _retry_backoff_reason(
         return ""
     idx = min(attempts - 1, len(RETRY_BACKOFF_SECONDS) - 1)
     backoff = RETRY_BACKOFF_SECONDS[idx]
-    if _dispatch_produced_nothing(entry, facts):
+    if _dispatch_produced_nothing(entry, facts) and not _is_merge_gate_block_reason(
+        own_reason
+    ):
         backoff = max(backoff, DISPATCH_FAILURE_MIN_BACKOFF_SECONDS)
     if age >= backoff:
         return ""
@@ -2347,7 +2419,21 @@ def _reconcile_running(
     # — or the escalation this produces once the budget IS exhausted — sees
     # "no assignment was ever created" instead of a bare exit code that
     # could mean anything.
-    dispatch_only = _dispatch_produced_nothing(entry, facts)
+    #
+    # #2424: EXCEPT when `own_reason` already names a merge-gate block
+    # ("merge attempted N times without landing", a stale smoke verdict, red
+    # CI, ...) — a relaunch whose only job is retrying the Merge stage
+    # dispatches no new assignment BY DESIGN (Work/Test/Review already
+    # completed; there is nothing left to dispatch), so the comparison above
+    # reads exactly like a dispatch failure even though it plainly is not.
+    # The generic note is additive evidence for when nothing more specific is
+    # known; it must never be layered on top of a reason that already
+    # contradicts it — see `_is_merge_gate_block_reason` for the two live
+    # escalations (claude-coordinator#2405, coord-web#2) this false-positive
+    # actually produced.
+    dispatch_only = _dispatch_produced_nothing(
+        entry, facts
+    ) and not _is_merge_gate_block_reason(own_reason)
     dispatch_note = (
         " — no assignment was ever created for this run (#2273): likely an "
         "infrastructure/dispatch-layer failure, not a code defect"
@@ -3604,17 +3690,24 @@ def plan_tick(
         `effective_last_reason`) so both call sites below — the report-only
         dry-run pass and the persisted `last_reason` write — get the combined
         text for free, with no change needed at either site.
+
+        #2424 follow-up: that same `effective_last_reason` resolution is also
+        what `_retry_backoff_reason` needs to answer its own "was this
+        actually a dispatch failure" question — see its `own_reason`
+        parameter's docstring — so it is resolved once, here, and passed to
+        both.
         """
+        previous = effective_last_reason.get(candidate.key, candidate.last_reason)
         backoff = _retry_backoff_reason(
             candidate,
             board.facts(candidate.key),
             now,
             effective_attempts.get(candidate.key, candidate.attempts),
             retry_backoff_at_map.get(candidate.key, candidate.retry_backoff_at),
+            own_reason=previous,
         )
         if not backoff:
             return ""
-        previous = effective_last_reason.get(candidate.key, candidate.last_reason)
         return _augment_backoff_reason(previous, backoff)
 
     # #1972's projection of per-repo occupancy AS THE WALK SEES IT: the board

{code_coordinator-0.5.164 → code_coordinator-0.5.165}/tests/test_drive_queue.py

@@ -1512,6 +1512,40 @@ def test_a_dispatch_failure_that_created_no_assignment_backs_off_longer():
     assert len(backoff) == 1 and backoff[0].backing_off is True
 
 
+def test_a_merge_gate_block_retry_does_not_get_the_widened_backoff():
+    """#2424 follow-up: identical setup to the test above (no board-visible
+    assignment for this launch — by itself indistinguishable from a genuine
+    dispatch failure) EXCEPT the entry's own `last_reason` already names a
+    merge-gate block. `_retry_backoff_reason` must not widen the spacing to
+    `DISPATCH_FAILURE_MIN_BACKOFF_SECONDS` (300s) on top of a reason that
+    already says the real cause is a merge-gate block, not a dispatch
+    failure — the same "one question, one answer" fix `_is_merge_gate_block_
+    reason` already applies to the escalation text, now also applied to the
+    retry-pacing decision that answers the same question independently."""
+    launched_at = NOW - DRIVE_STARTUP_GRACE_SECONDS - 400.0
+    entries = [
+        entry(
+            1650,
+            position=3,
+            state=STATE_WAITING,
+            attempts=1,
+            launched_at=launched_at,
+            # Same 90s elapsed as the widened-backoff test above: clears the
+            # plain RETRY_BACKOFF_SECONDS[0] (60s) but not the widened 300s
+            # floor.
+            retry_backoff_at=NOW - 90.0,
+            last_reason=(
+                "merge attempted 3 times without landing. (attempt 2/5) — "
+                "requeued at position 3"
+            ),
+        )
+    ]
+    facts = IssueFacts(known=True, issue_state="open")  # no assignment at all
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(entries, view, capacity=1, now=NOW)
+    assert plan.launch is not None and plan.launch.issue == 1650
+
+
 def test_a_dispatched_run_that_died_later_gets_the_plain_backoff_only():
     """The counterpart: a launch that DID dispatch (an assignment exists,
     created after `launched_at`) is NOT treated as a pure dispatch failure —
@@ -1555,6 +1589,149 @@ def test_exhausted_reason_names_a_dispatch_only_failure():
     assert "no assignment was ever created for this run" in plan.blocked[0].reason
 
 
+def test_exhausted_merge_gate_block_does_not_get_the_dispatch_note():
+    """#2424: claude-coordinator#2405 / coord-web#2 — a relaunch whose only
+    job is retrying the Merge stage dispatches no NEW assignment by design
+    (Work/Test/Review already completed), so `_dispatch_produced_nothing`'s
+    comparison reads exactly like a genuine dispatch failure. The own exit
+    reason already names the real cause (a merge-gate block); the #2273 note
+    must not be layered on top of it, or an operator reading the escalation
+    is misdirected toward `drive-queue remove && add` (a wasted Work/Test/
+    Review cycle) instead of `coord merge --revalidate`."""
+    entries = [
+        entry(
+            1650,
+            state=STATE_RUNNING,
+            attempts=DEFAULT_MAX_ATTEMPTS - 1,
+            launched_at=NOW - DRIVE_STARTUP_GRACE_SECONDS - 1,
+        )
+    ]
+    own_reason = (
+        "drive exited for claude-coordinator#1650 (exit_code=1): merge "
+        "attempted 3 times without landing.\n"
+        "   Last board state: status='CONFLICT' reason='smoke test verdict "
+        "is stale'"
+    )
+    # No assignment dispatched AFTER `launched_at` — exactly the shape a
+    # merge-only relaunch produces, and exactly what used to trip the #2273
+    # note despite three real assignments already having done real work.
+    facts = IssueFacts(known=True, issue_state="open")
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(
+        entries, view, capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    assert plan.reconciles[0].outcome == "exhausted"
+    reason = plan.blocked[0].reason
+    assert own_reason in reason
+    assert "no assignment was ever created" not in reason
+    assert "infrastructure/dispatch-layer failure" not in reason
+
+
+def test_exhausted_checks_failed_does_not_get_the_dispatch_note():
+    """Same #2424 fix, the red-CI shape (coord-web#2): `own_reason` names a
+    `checks_failed` merge-gate block, not a dispatch failure."""
+    entries = [
+        entry(
+            1650,
+            state=STATE_RUNNING,
+            attempts=DEFAULT_MAX_ATTEMPTS - 1,
+            launched_at=NOW - DRIVE_STARTUP_GRACE_SECONDS - 1,
+        )
+    ]
+    own_reason = (
+        "drive exited for claude-coordinator#1650 (exit_code=1): merge "
+        "attempted 3 times without landing.\n"
+        "   Last board state: status='CONFLICT' reason='checks failed: "
+        "checks'"
+    )
+    facts = IssueFacts(known=True, issue_state="open")
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(
+        entries, view, capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    assert plan.reconciles[0].outcome == "exhausted"
+    reason = plan.blocked[0].reason
+    assert "no assignment was ever created" not in reason
+
+
+def test_exhausted_immediate_escalation_merge_status_does_not_get_the_dispatch_note():
+    """#2424's fourth documented shape: `_escalate_merge`'s #1505
+    immediate-escalation path (`coord/drive.py:2809`), whose `Action.message`
+    is `f"merge escalated: {reason}\\n   gates: {gates_summary}\\n..."`
+    (`coord/drive.py:2836`) and whose `reason` for a terminal/unrecognized
+    merge status is `f"merge_status={status or '(empty)'} — no number of
+    retries..."`. `_drive_exit_summary` then wraps that whole message as
+    `f"drive exited for {ident} (exit_code={exit_code}): {reason}"`
+    (`coord/drive.py:3677`) before it is read back verbatim as `own_reason` —
+    so the real string never STARTS WITH "merge_status=", it merely CONTAINS
+    it (both in the `reason` line and again in `gates_summary`'s own
+    `merge_status=...` pair). A prior `.startswith("merge_status=")` check
+    left this one shape unmatched — dead code against real data — so a drive
+    that hit this exact path still got the false #2273 dispatch-note."""
+    entries = [
+        entry(
+            1650,
+            state=STATE_RUNNING,
+            attempts=DEFAULT_MAX_ATTEMPTS - 1,
+            launched_at=NOW - DRIVE_STARTUP_GRACE_SECONDS - 1,
+        )
+    ]
+    own_reason = (
+        "drive exited for claude-coordinator#1650 (exit_code=1): merge "
+        "escalated: merge_status=CONFLICT — no number of retries changes "
+        "this; escalating on first encounter instead of burning the "
+        "merge-attempt budget (#1505)\n"
+        "   gates: merge_status=CONFLICT | merge_reason=(none) | "
+        "review_verdict=approved | test_state=passed | pr_url=(none)\n"
+        "   proposed: coord merge --plan --repo claude-coordinator   "
+        "# inspect the gates, then decide\n"
+        "   Recorded on the board — see: coord escalate list --repo "
+        "claude-coordinator"
+    )
+    facts = IssueFacts(known=True, issue_state="open")
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(
+        entries, view, capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    assert plan.reconciles[0].outcome == "exhausted"
+    reason = plan.blocked[0].reason
+    assert own_reason in reason
+    assert "no assignment was ever created" not in reason
+    assert "infrastructure/dispatch-layer failure" not in reason
+
+
+def test_a_genuine_dispatch_failure_still_gets_the_note_alongside_own_reason():
+    """Regression guard for #2424's fix: an own_reason that does NOT name a
+    merge-gate block (a genuine pre-`coord assign` crash) must still get the
+    #2273 note — the fix narrows the false-positive, it does not remove the
+    signal entirely."""
+    entries = [
+        entry(
+            1650,
+            state=STATE_RUNNING,
+            attempts=DEFAULT_MAX_ATTEMPTS - 1,
+            launched_at=NOW - DRIVE_STARTUP_GRACE_SECONDS - 1,
+        )
+    ]
+    own_reason = (
+        "drive exited for claude-coordinator#1650 (exit_code=1): unhandled "
+        "exception in dispatch"
+    )
+    facts = IssueFacts(known=True, issue_state="open")
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(
+        entries, view, capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    assert plan.reconciles[0].outcome == "exhausted"
+    reason = plan.blocked[0].reason
+    assert own_reason in reason
+    assert "no assignment was ever created for this run" in reason
+
+
 def test_a_dead_drive_out_of_attempts_blocks_and_escalates():
     entries = [
         entry(1650, state=STATE_RUNNING, attempts=DEFAULT_MAX_ATTEMPTS - 1)