code-coordinator 0.5.156__tar.gz → 0.5.161__tar.gz

{code_coordinator-0.5.156 → code_coordinator-0.5.161}/PKG-INFO

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

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

@@ -803,8 +803,10 @@ tests/acceptance/ms-51/mocks/home-active.html
 tests/acceptance/ms-65/board_tabs_2282.rs
 tests/acceptance/ms-65/board_tabs_close_2283.rs
 tests/acceptance/ms-65/contract.md
+tests/acceptance/ms-65/detail_substate_2285.rs
 tests/acceptance/ms-65/manifest.yml
 tests/acceptance/ms-65/pipeline_tabs_2284.rs
+tests/acceptance/ms-65/tabs_discoverability_2287.rs
 tests/acceptance/ms-65/mocks/board-baseline-no-tabs.screen
 tests/acceptance/ms-65/mocks/board-pinned-3-tabs.screen
 tests/acceptance/ms-65/mocks/board-preview-tab.screen

{code_coordinator-0.5.156 → code_coordinator-0.5.161}/code_coordinator.egg-info/scm_file_list.json

@@ -443,6 +443,7 @@
     "tests/acceptance/ms-65/board_tabs_2282.rs",
     "tests/acceptance/ms-65/board_tabs_close_2283.rs",
     "tests/acceptance/ms-65/contract.md",
+    "tests/acceptance/ms-65/detail_substate_2285.rs",
     "tests/acceptance/ms-65/manifest.yml",
     "tests/acceptance/ms-65/mocks/board-baseline-no-tabs.screen",
     "tests/acceptance/ms-65/mocks/board-pinned-3-tabs.screen",
@@ -453,6 +454,7 @@
     "tests/acceptance/ms-65/mocks/board-tabs-overflow.screen",
     "tests/acceptance/ms-65/mocks/pipeline-tabs-independent.screen",
     "tests/acceptance/ms-65/pipeline_tabs_2284.rs",
+    "tests/acceptance/ms-65/tabs_discoverability_2287.rs",
     "tests/acceptance/ms-example/mocks/home-active.html",
     "tests/conftest.py",
     "tests/fixtures/board-pipeline-basic.json",

{code_coordinator-0.5.156 → code_coordinator-0.5.161}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.156",
+  "tag": "0.5.161",
   "distance": 0,
-  "node": "g3cb93fa341dc733f826d22601d0c538118cd8dc9",
+  "node": "g2c9d3ac54cc47979d8229c26e8852ac4852dc577",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.156 → code_coordinator-0.5.161}/coord/drive.py

@@ -396,6 +396,22 @@ class DriveCounters:
     # overwhelming majority of drives — non-oracle ones — never allocate it,
     # and `--dry-run`'s counter snapshot stays unchanged for them.
     acceptance: "DriveCounters | None" = None
+    # #2416: bounded retry for an ADVISORY work row whose branch carries zero
+    # commits — `_decide_advisory`'s dead-end signature. Before this, that
+    # branch went straight to `_die()` on every observation, so the only
+    # thing that could ever supersede the terminal row was a human running
+    # `coord retry <aid>` by hand (`coord diagnose --stage work --reset` is
+    # NOT the escape hatch here — it never sets `needs_reset` for this
+    # shape). `drive-queue`'s own automatic retry does not take that path
+    # either: it just relaunches a brand new `coord drive` process, which
+    # re-observes the SAME terminal row and dies again in seconds, burning a
+    # queue attempt+backoff cycle for nothing (coord-portal#119, drive-queue
+    # entry 432). Bounded the same way `work_retries` is (`opts.
+    # max_work_retries`) so a genuinely unactionable row (the issue's real
+    # resolution is a sibling task, not another attempt) still reaches a
+    # terminal `_die()` — never an unbounded loop — once the budget is
+    # spent.
+    advisory_retries: int = 0
 
     def slice_budget(self) -> "DriveCounters":
         """This run's slice-landing budget, created on first use (#2079)."""
@@ -1603,8 +1619,15 @@ def decide(
     if state.work_status == "done":
         pass
     elif state.work_status == "advisory":
-        advisory = _decide_advisory(state, opts, machine, verifier)
-        if advisory.is_exit:
+        advisory = _decide_advisory(state, opts, counters, machine, verifier)
+        # #2416: `_decide_advisory` now returns a RUN action (a bounded
+        # `coord retry` dispatch) for the zero-commit case, not only an EXIT
+        # — `is_exit` alone would let a RUN action fall through to the
+        # Test/Review/Merge logic below as though the row were validated
+        # work. Only its "proceeding under --accept-advisory" branch returns
+        # WAIT (with warnings to fold in); every other branch (EXIT or RUN)
+        # is this poll's whole answer.
+        if advisory.kind != WAIT:
             return advisory
         warnings = advisory.warnings
     elif state.work_status == "refused_policy":
@@ -1825,6 +1848,7 @@ def _dispatch_work_stage(
 def _decide_advisory(
     state: IssueState,
     opts: DriveOptions,
+    counters: DriveCounters,
     machine: str,
     verifier: MergeVerifier,
 ) -> Action:
@@ -1835,13 +1859,47 @@ def _decide_advisory(
     ``tui/target/debug/coord-tui``, which a Python diff never produces, so
     #1323's stash-miss check downgrades a perfectly good DONE.  Ask git which
     case this actually is rather than trusting the status.
+
+    #2416: a GENUINE zero-commit advisory (no branch, or a branch verified to
+    carry no commits) used to be an immediate, unconditional `_die()` — the
+    ONE thing that can actually change this row, `coord retry <aid>`'s
+    zero-commit-advisory path (#1606: `ahead == 0` → reassign a fresh
+    worker), was never invoked automatically. That made every automatic
+    retry — `drive-queue`'s own included — a no-op: a brand new `coord
+    drive` process just re-observes the identical terminal row and dies
+    again in seconds, spending a queue attempt+backoff cycle for nothing.
+    Mirrors the `work_status == "failed"` branch above: a bounded number of
+    `coord retry` dispatches (`opts.max_work_retries`, via `counters.
+    advisory_retries`) before finally giving up, so a row whose correct
+    resolution really is "dispatch something else" still reaches a terminal
+    `_die()` naming `coord retry` for a human — never an unbounded loop.
     """
     if not state.work_branch or not verifier.branch_has_commits(state):
-        return _die(
-            f"work {state.work_aid} exited ADVISORY with no commits on its branch —\n"
-            "   nothing was pushed, so there is nothing to test, review, or merge.\n"
-            f"   inspect: coord log {state.work_aid} --machine "
-            f"{state.work_machine or machine}"
+        budget = opts.max_work_retries
+        if counters.advisory_retries >= budget:
+            return _die(
+                f"work {state.work_aid} exited ADVISORY with no commits on its "
+                f"branch {counters.advisory_retries} time(s) in a row (budget "
+                f"{budget}, #2416) — nothing was pushed, so there is nothing to "
+                "test, review, or merge, and retrying has not produced a "
+                "different outcome.\n"
+                f"   inspect: coord log {state.work_aid} --machine "
+                f"{state.work_machine or machine}\n"
+                f"   this needs an operator decision: `coord retry "
+                f"{state.work_aid}` by hand once the underlying blocker is "
+                "understood, or dispatch an independent follow-up issue if "
+                "another attempt at this one is not the right fix."
+            )
+        counters.advisory_retries += 1
+        return Action(
+            kind=RUN,
+            label=(
+                f"WORK: {state.work_aid} exited ADVISORY with no commits → "
+                f"coord retry {state.work_aid} (attempt "
+                f"{counters.advisory_retries}/{budget}, #2416)"
+            ),
+            command=("retry", state.work_aid),
+            error_message=f"coord retry failed for {state.work_aid}",
         )
     if not opts.accept_advisory:
         return _die(

{code_coordinator-0.5.156 → code_coordinator-0.5.161}/coord/drive_queue.py

@@ -1920,6 +1920,51 @@ def _retry_backoff_reason(
     )
 
 
+def _augment_backoff_reason(previous_reason: str, backoff_text: str) -> str:
+    """#2411: fold the real death cause into the mechanical backoff text.
+
+    Before this, `plan_tick`'s waiting walk persisted `_retry_backoff_reason`'s
+    return value as the entry's WHOLE `last_reason` on every tick it spent
+    backing off — the purely mechanical "next attempt permitted in Ns"
+    sentence, deliberately recomputed fresh each tick (see that function's
+    docstring). That overwrote the rich `own_reason` (plus the #2273
+    dispatch note and #2363 empty-branch note) `_reconcile_running`'s
+    `retry` branch had just recorded at the moment of death — visible for
+    exactly one tick, then gone. An operator reading `coord drive-queue
+    list` — or anything else that reads `last_reason`, like `coord
+    drive-queue diagnose` — saw only the spacing text and had no live way to
+    tell WHY the entry kept dying, only that it would try again later.
+
+    Fix: keep the FIRST LINE of whatever reason is already on record — the
+    real cause, written once at death — and put the fresh backoff sentence
+    on a second line under it. `last_reason` was already documented as
+    "possibly multi-line" (see `_ROW_CAUSE_MAX_CHARS`'s comment in
+    `coord.commands.drive_queue`) precisely so a summary render can show
+    line one on the row and the full text on the `last:` continuation line
+    — this reuses that convention rather than inventing a new field or
+    column.
+
+    Using only the first line (not the full previous text) keeps this
+    idempotent across ticks: called again next tick against ITS OWN
+    two-line output, the first line is still the original cause, never
+    last tick's backoff sentence, so the stored text never grows past two
+    lines no matter how many ticks the entry spends backing off.
+
+    Falls back to *backoff_text* alone when there is nothing to keep — a
+    row with no prior `last_reason` (a fresh entry, or one hand-built in a
+    test) — which is exactly today's pre-#2411 text for that case.
+    """
+    stripped = previous_reason.strip()
+    if not stripped:
+        return backoff_text
+    base = stripped.splitlines()[0]
+    # 3-space continuation indent — the same convention `coord/drive.py`'s
+    # own multi-line exit reasons already use for their "inspect: coord log
+    # ..." follow-up lines, so a combined reason reads as one paragraph
+    # rather than a mismatched second line flush against the left margin.
+    return f"{base}\n   {backoff_text}"
+
+
 def _reconcile_running(
     entry: QueueEntry,
     board: BoardView,
@@ -3054,6 +3099,15 @@ def plan_tick(
     # this falls back to (the post-review #2273 "moving target" fix).
     effective_attempts: dict[str, int] = {e.key: e.attempts for e in ordered}
     retry_backoff_at_map: dict[str, float] = {}
+    # #2411: same "prefer this tick's fresh write" rule, this time for the
+    # real death cause `_backoff_reason` below folds into its combined
+    # `last_reason` — see `_augment_backoff_reason`. Without this, an entry
+    # that dies and hits the backoff check in the SAME tick (step 1 above,
+    # then step 4 below) would combine against its STALE pre-tick
+    # `entry.last_reason` — one tick behind the death this walk just
+    # recorded — instead of the `own_reason`-based text `reconcile.reason`
+    # carries fresh, right below.
+    effective_last_reason: dict[str, str] = {e.key: e.last_reason for e in ordered}
 
     reconciles: list[Reconcile] = []
     blocked: list[Blocked] = []
@@ -3112,6 +3166,14 @@ def plan_tick(
             # for a backoff check reached later in this SAME tick, not the
             # entry's stale pre-tick `retry_backoff_at`.
             retry_backoff_at_map[entry.key] = now
+        if reconcile.outcome == "retry":
+            # #2411: `reconcile.reason` IS `reconcile.updates["last_reason"]`
+            # (the retry branch of `_reconcile_running` builds both from the
+            # same local `reason`) — the real death cause, `own_reason` plus
+            # its #2273 dispatch-note/#2363 empty-branch-note. Recorded here
+            # so a backoff check reached later in THIS tick combines against
+            # it instead of the pre-tick `entry.last_reason`.
+            effective_last_reason[entry.key] = reconcile.reason
         if block is not None:
             blocked.append(block)
             states[entry.key] = STATE_BLOCKED
@@ -3535,14 +3597,25 @@ def plan_tick(
         see that function's docstring for why neither can be read straight
         off `candidate`, and why the fallback is `candidate.retry_backoff_at`
         rather than `candidate.reason_at`.
+
+        #2411: the mechanical spacing text that comes back is never returned
+        bare — :func:`_augment_backoff_reason` folds in the real death cause
+        (resolved the same "prefer this tick's fresh write" way, off
+        `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.
         """
-        return _retry_backoff_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),
         )
+        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
     # reading above, plus this tick's own launch once one is chosen.  Kept