code-coordinator 0.5.131__tar.gz → 0.5.132__tar.gz

{code_coordinator-0.5.131 → code_coordinator-0.5.132}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.131",
+  "tag": "0.5.132",
   "distance": 0,
-  "node": "g1b229fc47c746e85d1d360ebe7d49d415f544a8c",
+  "node": "g77edefa9b01b23c5ab4770f72c62d1469f11346e",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-17"

{code_coordinator-0.5.131 → code_coordinator-0.5.132}/coord/drive_queue.py

@@ -309,6 +309,26 @@ RESUME_PROBE_TIMEOUT_SECONDS = 5.0
 # an unsatisfiable pre-req.
 DEFAULT_MAX_ATTEMPTS = 2
 
+# #2363: the WIDER ceiling for one specific drive-death signature — an
+# acceptance-author or plain work session that exited DONE/ADVISORY claiming
+# success while its branch carried zero commits (see
+# `_is_empty_branch_death_reason`). Every recorded instance of this shape in
+# `~/.coord/queue-block-log.jsonl` self-healed 0% of the time inside
+# `DEFAULT_MAX_ATTEMPTS` (2) — `claude-coordinator#2283`, `#2348`;
+# `coord-portal#74` (×2); `space-invaders#1`, `#3` — every one needed a
+# by-hand `operator_removed` after exactly 2 attempts, and the by-hand
+# recovery is `coord acceptance author <repo> <tracking> --issue <n>` (or a
+# bare `coord drive`) — the exact command the queue already tried and could
+# just try again itself. Unlike a CI signal (`is_ci_infra_reason` et al in
+# `coord.merge_queue`), there is no free, passive re-check here — the only
+# way to learn whether a retry would succeed is to actually spend one — so
+# the fix is a WIDER attempt budget for this signature alone, not a global
+# increase: every other death reason keeps `DEFAULT_MAX_ATTEMPTS` unchanged.
+# Still finite: once THIS budget is also exhausted, the entry blocks with
+# the same diagnosis-and-recovery instructions it has today (#1526/#2273
+# discipline — no silent infinite retry).
+EMPTY_BRANCH_MAX_ATTEMPTS = 6
+
 # ── retry spacing (#2273) ────────────────────────────────────────────────────
 #
 # 2026-08-15: quadraui#508 and coord-portal#83 each spent their ENTIRE
@@ -1679,6 +1699,48 @@ def _dispatch_produced_nothing(entry: QueueEntry, facts: IssueFacts) -> bool:
     return facts.last_dispatched_at < entry.launched_at
 
 
+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
+    DONE/ADVISORY while its branch carried zero commits?
+
+    Text-matched against the drive's own `drive_exited` reason, the same
+    convention `is_ci_infra_reason`/`is_ci_flaky_reason`/
+    `is_ci_unreadable_reason` in `coord.merge_queue` use to classify a CI
+    status string — not marker-based like `is_permanent_block_reason`,
+    because neither `_die` call site this recognizes embeds a dedicated
+    marker; today nothing reads their reason text for anything but display.
+
+    Two independent shapes, both required to include "no commits" so a
+    death that merely MENTIONS one of the other words in passing does not
+    false-positive:
+
+    * the acceptance-author JIT-slice death (`coord/drive.py:850-865`
+      ADVISORY, `:887-918` DONE) — "acceptance author ... exited
+      (ADVISORY|DONE) ... no commits".
+    * the plain work-row death (`coord/drive.py`'s `_decide_advisory`) —
+      "work ... exited ADVISORY ... no commits ... nothing was pushed".
+
+    Deliberately does NOT match the sibling "work ... finished with no
+    branch — nothing was pushed" reason (`coord/drive.py`'s `_decide`, the
+    'done'-status-with-no-branch arm): that shape never reaches
+    `branch_has_commits` at all, is not one of the two shapes the issue's
+    acceptance criteria name, and has no recorded evidence of its own in
+    `queue-block-log.jsonl` — folding it in unasked would be exactly the
+    un-scoped widening #2230's own docstring warns a naive rule invites.
+    """
+    if not reason:
+        return False
+    lowered = reason.lower()
+    if "no commits" not in lowered:
+        return False
+    if "acceptance author" in lowered and (
+        "exited advisory" in lowered or "exited done" in lowered
+    ):
+        return True
+    return "exited advisory" in lowered and "nothing was pushed" in lowered
+
+
 def _retry_backoff_reason(
     entry: QueueEntry,
     facts: IssueFacts,
@@ -1840,6 +1902,15 @@ def _reconcile_running(
     absent, refused or not — only ever changes the WORDING below; whether the
     entry gets another attempt is otherwise unaffected by #1845/#1844 (still
     ``retry`` until ``max_attempts``, still ``exhausted`` → ``blocked`` after).
+    The ONE exception is #2363: when ``own_reason`` matches
+    :func:`_is_empty_branch_death_reason` — an acceptance-author or work
+    session that exited DONE/ADVISORY claiming success with a zero-commit
+    branch — the ceiling widens to :data:`EMPTY_BRANCH_MAX_ATTEMPTS` instead
+    of the passed-in ``max_attempts``, because that signature's own recorded
+    history (see the constant's comment) shows a 0% self-heal rate inside
+    the default budget. Still finite, still ``exhausted`` → ``blocked`` with
+    the same diagnosis-and-recovery instructions once ITS wider ceiling is
+    also hit.
     """
     facts = board.facts(entry.key)
 
@@ -2128,18 +2199,39 @@ def _reconcile_running(
         else ""
     )
 
+    # #2363: the "claimed success, wrote nothing" signature gets a WIDER
+    # ceiling than every other death reason — see `EMPTY_BRANCH_MAX_ATTEMPTS`
+    # and `_is_empty_branch_death_reason`. `max()` against the passed-in
+    # `max_attempts` rather than an outright override so a caller-supplied
+    # `--max-attempts` larger than the #2363 default is never narrowed.
+    # Additive only: any other reason (including `dispatch_only` above) still
+    # uses the plain `max_attempts` ceiling, unchanged.
+    empty_branch = _is_empty_branch_death_reason(own_reason)
+    effective_max_attempts = (
+        max(max_attempts, EMPTY_BRANCH_MAX_ATTEMPTS) if empty_branch else max_attempts
+    )
+    empty_branch_note = (
+        f" — empty-branch DONE/ADVISORY exit (#2363): widened retry budget, "
+        f"{effective_max_attempts} attempts before blocking instead of the "
+        f"usual {max_attempts}"
+        if empty_branch
+        else ""
+    )
+
     attempts = entry.attempts + 1
-    if attempts < max_attempts:
+    if attempts < effective_max_attempts:
         if own_reason:
             reason = (
-                f"{own_reason} (attempt {attempts}/{max_attempts}) — "
-                f"requeued at position {entry.position}{dispatch_note}"
+                f"{own_reason} (attempt {attempts}/{effective_max_attempts}) — "
+                f"requeued at position {entry.position}"
+                f"{dispatch_note}{empty_branch_note}"
             )
         else:
             reason = (
                 f"drive session died without landing the work"
-                f"{launched} (attempt {attempts}/{max_attempts}) — requeued at "
-                f"position {entry.position}{dispatch_note}"
+                f"{launched} (attempt {attempts}/{effective_max_attempts}) — "
+                f"requeued at position {entry.position}"
+                f"{dispatch_note}{empty_branch_note}"
             )
         return (
             Reconcile(
@@ -2168,14 +2260,14 @@ def _reconcile_running(
 
     if own_reason:
         reason = (
-            f"{own_reason} ({attempts}/{max_attempts} attempts) — giving up"
-            f"{dispatch_note}"
+            f"{own_reason} ({attempts}/{effective_max_attempts} attempts) — "
+            f"giving up{dispatch_note}{empty_branch_note}"
         )
     else:
         reason = (
             f"drive session died without landing the work"
-            f"{launched} {attempts}/{max_attempts} times — giving up"
-            f"{dispatch_note}"
+            f"{launched} {attempts}/{effective_max_attempts} times — giving up"
+            f"{dispatch_note}{empty_branch_note}"
         )
     return (
         Reconcile(entry.key, "exhausted", reason, occupies=False),

{code_coordinator-0.5.131 → code_coordinator-0.5.132}/tests/test_drive_queue.py

@@ -20,6 +20,7 @@ import pytest
 from coord.drive_queue import (
     DEFAULT_MAX_ATTEMPTS,
     DRIVE_STARTUP_GRACE_SECONDS,
+    EMPTY_BRANCH_MAX_ATTEMPTS,
     HOLD_ARMED,
     HOLD_FIRED,
     HOLD_RELEASED,
@@ -1636,6 +1637,136 @@ def test_no_exit_reason_falls_back_to_the_synthesised_death_wording():
     )
 
 
+# ═══════════════════════════════════════════════════════════════════════════
+# #2363: the "claimed success, wrote nothing" signature — an acceptance-author
+# or plain work session that exited DONE/ADVISORY claiming success while its
+# branch carried zero commits (`coord/drive.py:850-865`, `:887-918`, and
+# `_decide_advisory`) — gets a WIDER attempt budget than
+# `DEFAULT_MAX_ATTEMPTS` before blocking. Every recorded instance of this
+# shape in `~/.coord/queue-block-log.jsonl` self-healed 0% of the time inside
+# the default ceiling (the issue's own evidence table); this is additive —
+# every OTHER death reason keeps today's flat ceiling unchanged.
+# ═══════════════════════════════════════════════════════════════════════════
+
+ACCEPTANCE_ADVISORY_EMPTY_BRANCH_REASON = (
+    "acceptance author api#42 exited ADVISORY with no commits on its branch "
+    "— nothing was authored, so there is no slice to land.\n"
+    "   inspect: coord log api#42 --machine dellserver\n"
+    "   Continue by hand, or re-run coord drive with --no-acceptance to "
+    "skip JIT authoring."
+)
+ACCEPTANCE_DONE_EMPTY_BRANCH_REASON = (
+    "acceptance author api#42 exited DONE, but its branch 'work/api-1650' "
+    "carries no commits — nothing was authored, so there is no slice to "
+    "land, and DONE is terminal: it will never change on its own.\n"
+    "   inspect: coord log api#42 --machine dellserver\n"
+    "   Re-author by hand: coord acceptance author claude-coordinator "
+    "1600 --issue 1650\n"
+    "   or re-run coord drive with --no-acceptance to skip JIT authoring."
+)
+WORK_ADVISORY_EMPTY_BRANCH_REASON = (
+    "work api#42 exited ADVISORY with no commits on its branch —\n"
+    "   nothing was pushed, so there is nothing to test, review, or merge.\n"
+    "   inspect: coord log api#42 --machine dellserver"
+)
+
+
+@pytest.mark.parametrize(
+    "own_reason",
+    [
+        ACCEPTANCE_ADVISORY_EMPTY_BRANCH_REASON,
+        ACCEPTANCE_DONE_EMPTY_BRANCH_REASON,
+        WORK_ADVISORY_EMPTY_BRANCH_REASON,
+    ],
+)
+def test_empty_branch_death_survives_past_the_default_attempt_ceiling(own_reason):
+    """#2363 acceptance: a `DEFAULT_MAX_ATTEMPTS`-th death of this shape must
+    NOT yet be blocked — the whole point is a wider budget than the flat
+    ceiling every other death reason gets."""
+    entries = [
+        entry(1650, state=STATE_RUNNING, attempts=DEFAULT_MAX_ATTEMPTS - 1)
+    ]
+    plan = plan_tick(
+        entries, board(), capacity=1,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    reconcile = plan.reconciles[0]
+    assert reconcile.outcome == "retry"
+    assert plan.blocked == ()
+    assert reconcile.updates["state"] == STATE_WAITING
+    assert reconcile.updates["attempts"] == DEFAULT_MAX_ATTEMPTS
+    assert f"{DEFAULT_MAX_ATTEMPTS}/{EMPTY_BRANCH_MAX_ATTEMPTS}" in reconcile.reason
+    assert "#2363" in reconcile.reason
+    assert own_reason in reconcile.reason
+
+
+def test_empty_branch_death_still_blocks_once_its_own_wider_budget_is_exhausted():
+    """No silent infinite retry: once `EMPTY_BRANCH_MAX_ATTEMPTS` is itself
+    hit, the entry blocks with the same diagnosis-and-recovery text the
+    drive itself wrote (`own_reason`, verbatim — the `coord log`/`coord
+    acceptance author` instructions an operator would otherwise have to
+    reconstruct by hand)."""
+    entries = [
+        entry(
+            1650,
+            state=STATE_RUNNING,
+            attempts=EMPTY_BRANCH_MAX_ATTEMPTS - 1,
+        )
+    ]
+    plan = plan_tick(
+        entries, board(), capacity=1,
+        exit_reasons={entry_key(REPO, 1650): ACCEPTANCE_DONE_EMPTY_BRANCH_REASON},
+    )
+    reconcile = plan.reconciles[0]
+    assert reconcile.outcome == "exhausted"
+    assert plan.blocked[0].updates["state"] == STATE_BLOCKED
+    assert plan.blocked[0].updates["attempts"] == EMPTY_BRANCH_MAX_ATTEMPTS
+    assert ACCEPTANCE_DONE_EMPTY_BRANCH_REASON in plan.blocked[0].reason
+    assert "coord acceptance author claude-coordinator 1600" in plan.blocked[0].reason
+
+
+def test_a_non_empty_branch_death_keeps_the_default_attempt_ceiling():
+    """Additive, not a global increase: an ordinary drive death (a genuine
+    code-defect exit) must still block at the plain `DEFAULT_MAX_ATTEMPTS`,
+    unaffected by #2363."""
+    entries = [
+        entry(1650, state=STATE_RUNNING, attempts=DEFAULT_MAX_ATTEMPTS - 1)
+    ]
+    own_reason = "drive exited for api#1650 (exit_code=1): a genuine test failure"
+    plan = plan_tick(
+        entries, board(), capacity=1,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    reconcile = plan.reconciles[0]
+    assert reconcile.outcome == "exhausted"
+    assert plan.blocked[0].updates["attempts"] == DEFAULT_MAX_ATTEMPTS
+    assert "#2363" not in plan.blocked[0].reason
+
+
+def test_finished_with_no_branch_reason_is_not_classified_as_empty_branch_death():
+    """The `_decide` 'done'-status-with-no-branch shape (`work ... finished
+    with no branch — nothing was pushed (0-commit advisory)`) is a THIRD,
+    narrower reading `coord/drive.py` can produce — it is not one of the two
+    shapes #2363's acceptance criteria name, has no evidence of its own in
+    `queue-block-log.jsonl`, and must keep the default ceiling rather than
+    being silently folded into the wider one."""
+    entries = [
+        entry(1650, state=STATE_RUNNING, attempts=DEFAULT_MAX_ATTEMPTS - 1)
+    ]
+    own_reason = (
+        "work api#1650 finished with no branch — nothing was pushed "
+        "(0-commit advisory).\n"
+        "   inspect: coord log api#1650 --machine dellserver"
+    )
+    plan = plan_tick(
+        entries, board(), capacity=1,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    reconcile = plan.reconciles[0]
+    assert reconcile.outcome == "exhausted"
+    assert plan.blocked[0].updates["attempts"] == DEFAULT_MAX_ATTEMPTS
+
+
 # ═══════════════════════════════════════════════════════════════════════════
 # #1891: `parked` — a CI verdict that has not arrived must not consume merge
 # budget. Same "no session, no active work, nothing landed" evidence as