code-coordinator 0.5.64__tar.gz → 0.5.65__tar.gz

{code_coordinator-0.5.64 → code_coordinator-0.5.65}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.64",
+  "tag": "0.5.65",
   "distance": 0,
-  "node": "gfd34f94b90b737b1d9df054d5147d16c070c4748",
+  "node": "g58dde32efe3e0c9e230599f9c2fa0eeb9f41671a",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.64 → code_coordinator-0.5.65}/coord/commands/drive_queue.py

@@ -50,6 +50,7 @@ from coord.drive_queue import (
     QUEUE_ALERT_STAGE,
     RESUME_PROBE_TIMEOUT_SECONDS,
     STATE_BLOCKED,
+    STATE_FAILED,
     STATE_PARKED,
     STATE_RUNNING,
     STATE_WAITING,
@@ -59,8 +60,10 @@ from coord.drive_queue import (
     QueueError,
     TickPlan,
     build_board_view,
+    diagnose_blocked_after,
     entries_from_rows,
     entry_key,
+    find_cycle,
     fired_holds,
     parse_after_spec,
     parse_key,
@@ -300,6 +303,50 @@ def validate_config_repo(config_path: Path, repo: str) -> None:
 
 # ── list ─────────────────────────────────────────────────────────────────────
 
+# `blocked`/`failed` are the two states #2183's re-diagnosis applies to: both
+# are in `TERMINAL_QUEUE_STATES` (the tick will never look at this row's
+# `after=` graph again), so both are exactly where a stale `after=` reading
+# can survive indefinitely. `done` is also terminal but carries no live
+# "why is this stuck" question — nothing to re-diagnose.
+_DIAGNOSABLE_STATES = (STATE_BLOCKED, STATE_FAILED)
+
+# How much of a (possibly multi-line, possibly paragraph-length) `last_reason`
+# fits on the summary row itself, next to `attempts=`/`deferrals=`, without
+# wrapping a normal terminal. The FULL text always still prints on the `last:`
+# continuation line right below — this is only the on-row teaser.
+_ROW_CAUSE_MAX_CHARS = 88
+
+_BLOCKED_REMEDY = (
+    "remedy: {state} is terminal — the queue will not re-check this row "
+    "on its own; `coord drive-queue remove` + `add` only helps once the "
+    "cause above is actually fixed, not merely because a pre-req merged"
+)
+
+
+def _row_cause(reason: str) -> str:
+    """The first line of *reason*, clipped to fit the summary row (#2183)."""
+    first_line = reason.strip().splitlines()[0] if reason.strip() else ""
+    if len(first_line) > _ROW_CAUSE_MAX_CHARS:
+        return first_line[: _ROW_CAUSE_MAX_CHARS - 1].rstrip() + "…"
+    return first_line
+
+
+def _board_for_list_diagnosis() -> BoardView | None:
+    """The board, for `list`'s #2183 re-diagnosis — ``None`` when unreachable.
+
+    Unlike `tick`, `list` is a read-only inspection command an operator runs
+    often and expects to be fast and always available, so an unreachable
+    board must never make it fail or hang the way `tick`'s fail-closed abort
+    does. ``None`` here means "skip the re-diagnosis" — every row falls back
+    to exactly today's rendering (the `after=` list unfiltered, no cause on
+    the row itself), never a crash or a misleading empty board's worth of
+    "everything is unsatisfied".
+    """
+    try:
+        return _fetch_board_view()
+    except Exception:  # noqa: BLE001 — see docstring: this must never fail `list`
+        return None
+
 
 @drive_queue_group.command("list")
 @click.option("--repo", "repo", default=None, help="Restrict to one repo (default: every repo).")
@@ -317,12 +364,61 @@ def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) ->
         click.echo("(drive queue is empty)")
         return
     now = time.time()
-    for entry in entries_from_rows(rows):
-        bits = [f"{entry.position:>2}  {entry.key:<28} {entry.state}"]
+    entries = entries_from_rows(rows)
+
+    # #2183: a `blocked`/`failed` row's `after=` graph needs to be re-checked
+    # against the FULL queue (cross-repo pre-reqs), not just whatever `--repo`
+    # filtered down to — otherwise a `--repo` view would misdiagnose an
+    # out-of-repo pre-req as "unknown to the queue" purely from the filter,
+    # not from anything actually true.
+    all_entries = entries if repo is None else entries_from_rows(list_drive_queue())
+    # A row with no `after=` at all has nothing for #2183's re-diagnosis to
+    # do — criterion "entries with no after= are unaffected" — so both the
+    # board fetch and the per-row diagnosis below are gated on `entry.after`
+    # being non-empty, not just on the state being terminal.
+    needs_diagnosis = any(
+        e.state in _DIAGNOSABLE_STATES and e.after for e in entries
+    )
+    board = _board_for_list_diagnosis() if needs_diagnosis else None
+    states = {e.key: e.state for e in all_entries}
+    cycle_keys: dict[str, str] = {}
+    cycle = find_cycle({e.key: list(e.after) for e in all_entries})
+    if cycle is not None:
+        message = "dependency cycle: " + " -> ".join(cycle)
+        for key in cycle:
+            cycle_keys[key] = message
+
+    for entry in entries:
+        diagnosed = (
+            board is not None and entry.state in _DIAGNOSABLE_STATES and bool(entry.after)
+        )
+        unsatisfied = entry.after
+        dependency_reason = ""
+        if diagnosed:
+            diagnosis = diagnose_blocked_after(entry, board, states, cycle_keys)
+            unsatisfied = diagnosis.unsatisfied
+            dependency_reason = diagnosis.dependency_reason
+
+        # A diagnosed row whose block is NOT (or no longer) caused by its
+        # `after=` graph gets its own cause on the state token itself — #2183
+        # point 2: the terminal reason leads, not a dependency list that may
+        # have nothing to do with it. A row that IS dependency-caused (or
+        # wasn't diagnosed at all) keeps the plain state token unchanged.
+        state_label = entry.state
+        if diagnosed and not dependency_reason and entry.last_reason:
+            state_label = f"{entry.state}: {_row_cause(entry.last_reason)}"
+
+        bits = [f"{entry.position:>2}  {entry.key:<28} {state_label}"]
         if entry.machine:
             bits.append(f"machine={entry.machine}")
-        if entry.after:
-            bits.append(f"after={','.join(entry.after)}")
+        # Suppress `after=` entirely on a diagnosed row that is NOT
+        # dependency-caused: every named pre-req is either satisfied or was
+        # never the reason this row is stuck, so showing it invites exactly
+        # the misreading #2183 exists to stop. Otherwise (not diagnosed, or
+        # genuinely dependency-caused) show whatever is still unsatisfied.
+        show_after = () if (diagnosed and not dependency_reason) else unsatisfied
+        if show_after:
+            bits.append(f"after={','.join(show_after)}")
         if entry.attempts:
             bits.append(f"attempts={entry.attempts}")
         if entry.deferrals:
@@ -334,6 +430,11 @@ def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) ->
         click.echo("  ".join(bits))
         if entry.last_reason:
             click.echo(f"      last{_reason_age_suffix(entry, now)}: {entry.last_reason}")
+        if diagnosed:
+            # #2183 point 4: `blocked`/`failed` is terminal — say so where the
+            # operator is already reading the row, not just in an unrelated
+            # operator's hand-written `--hold-after` note.
+            click.echo(f"      {_BLOCKED_REMEDY.format(state=entry.state)}")
         for line in _hold_lines(entry):
             click.echo(line)
 

{code_coordinator-0.5.64 → code_coordinator-0.5.65}/coord/drive_queue.py

@@ -1182,6 +1182,63 @@ def _resolve_prereqs(
     return _Verdict(True)
 
 
+@dataclass(frozen=True)
+class BlockedAfterDiagnosis:
+    """How #2183's rendering should treat a terminal row's `after=` graph.
+
+    ``unsatisfied`` is *entry*'s declared ``after=`` list with every
+    now-landed pre-req dropped. ``dependency_reason`` is the CURRENT
+    ``_resolve_prereqs`` verdict against that same graph — ``''`` when the
+    graph is not (or no longer) why the entry is stuck.
+    """
+
+    unsatisfied: tuple[str, ...] = ()
+    dependency_reason: str = ""
+
+
+def diagnose_blocked_after(
+    entry: QueueEntry,
+    board: BoardView,
+    states: Mapping[str, str],
+    cycle_keys: Mapping[str, str],
+) -> BlockedAfterDiagnosis:
+    """Re-check a `blocked`/`failed` row's `after=` graph against the CURRENT
+    board, fresh on every render (#2183).
+
+    ``entry.after`` is what ``add`` declared, frozen at enqueue time — and a
+    `blocked`/`failed` entry's own state never re-evaluates it again
+    (:data:`TERMINAL_QUEUE_STATES` is exactly "the tick will not look at this
+    row again"). By the time an operator reads the row, a pre-req that has
+    since merged is stale information still rendered as if current — the
+    quadraui#542 incident this closes: the row's `after=` named a pre-req
+    that had merged an hour earlier, reading as "blocked on a dependency
+    that is already satisfied" when the real cause was an unrelated red
+    slice PR.
+
+    Two things are recomputed, never read off the entry's own frozen
+    ``last_reason``:
+
+    * which of ``entry.after`` are still NOT landed — the merged ones drop
+      out entirely; a satisfied ``after=`` entry displayed on a terminal row
+      is not a dependency, it is a caption for a fact that no longer holds;
+    * whether the CURRENT pre-req graph is even a plausible cause —
+      delegated to :func:`_resolve_prereqs`, the exact function a live tick
+      uses to decide this, so a render can never disagree with what the tick
+      itself would conclude. An empty ``dependency_reason`` means the
+      answer is no: every named pre-req is now satisfied (or the entry
+      declared none), so whatever originally blocked this row — a red build,
+      an exhausted retry budget, a refused pre-dispatch guard — was NOT its
+      ``after=`` list, and the row's own ``last_reason`` is the real story.
+    """
+    unsatisfied = tuple(dep for dep in entry.after if not board.facts(dep).landed)
+    if not entry.after:
+        return BlockedAfterDiagnosis(unsatisfied)
+    verdict = _resolve_prereqs(entry, board, states, cycle_keys, held_gates={})
+    return BlockedAfterDiagnosis(
+        unsatisfied, "" if verdict.satisfied else verdict.reason
+    )
+
+
 # ── reconciliation ───────────────────────────────────────────────────────────
 
 

{code_coordinator-0.5.64 → code_coordinator-0.5.65}/tests/test_cli_drive_queue.py

@@ -353,6 +353,118 @@ def test_list_omits_age_for_a_reason_with_no_capture_time(cli, coord_db):
     )
 
 
+# ── #2183: a blocked row's `after=` must not misreport its cause ────────────
+#
+# quadraui#542, 2026-08-13: a `blocked` row led with `after=<merged pre-req>`,
+# reading as "blocked on a dependency that already merged" (stale, self-
+# resolving) when the real, unrelated cause — a red slice PR — sat on a `last:`
+# line beneath it. The sibling row (the quadraui#492 shape) was genuinely
+# blocked BY its pre-req and rendered identically, so nothing on either row
+# distinguished the two very different remedies.
+
+
+def _row_for(output: str, key: str) -> str:
+    """The `list` summary line for *key* (not its `last:`/`remedy:` lines)."""
+    match = re.search(rf"^\s*\d+\s+{re.escape(key)}\s+.*$", output, re.MULTILINE)
+    assert match, f"no row for {key} in:\n{output}"
+    return match.group(0)
+
+
+def test_blocked_row_drops_a_merged_prereq_and_leads_with_its_own_cause(
+    cli, seed
+):
+    """The exact #2183 regression: `after=` named a merged pre-req while the
+    real block was an unrelated drive failure. Must fail before the fix."""
+    seed(
+        issues={1650: "closed", 1654: "open"},
+        assignments=[{"issue_number": 1650, "status": "merged"}],
+    )
+    cli("add", REPO, "1654", "--after", "1650")
+    own_reason = (
+        f"drive exited for {REPO}#1654 (exit_code=1): the JIT acceptance "
+        "slice could not be landed — no work can be dispatched until it "
+        "merges: merge attempted 3 times without landing"
+    )
+    state._update_drive_queue_entry_local(
+        REPO, 1654, state="blocked", last_reason=own_reason, attempts=2
+    )
+
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+    row = _row_for(result.output, f"{REPO}#1654")
+
+    # Rule 1: the merged pre-req is gone from the row entirely — showing it
+    # is the exact misinformation #2183 reports.
+    assert "after=" not in row, row
+    assert f"{REPO}#1650" not in row, row
+
+    # Rule 2: the row itself leads with the REAL (own) cause, not a bare
+    # "blocked" that sends the reader hunting for the reason.
+    assert "blocked:" in row, row
+    assert "JIT acceptance slice" in row, row
+
+    # The full reason is still available on its own line, unabridged.
+    assert own_reason in result.output
+
+    # Rule 4: blocked's terminality is stated on the row's own output, not
+    # buried in an unrelated entry's hand-written note.
+    assert "is terminal" in result.output
+    assert "remove" in result.output and "add" in result.output
+
+
+def test_blocked_row_purely_by_an_unsatisfiable_prereq_is_unchanged(cli, seed):
+    """The #492 control case: genuinely blocked BY an unsatisfiable pre-req
+    must keep showing that pre-req and its "will never satisfy" reason —
+    and must NOT get the own-cause treatment #542's row gets."""
+    seed(
+        issues={1650: "closed", 1654: "open"},
+        assignments=[{"issue_number": 1650, "status": "merged"}],
+    )
+    # 1654 (the #542 shape): blocked for its own, unrelated reason.
+    cli("add", REPO, "1654", "--after", "1650")
+    state._update_drive_queue_entry_local(
+        REPO, 1654, state="blocked", last_reason="drive exited: unrelated own failure"
+    )
+    # 1660 (the #492 shape): declares BOTH the merged pre-req and the
+    # now-blocked 1654 as pre-reqs — its only real blocker is 1654.
+    cli("add", REPO, "1660", "--after", "1650,1654")
+    dep_reason = f"pre-req {REPO}#1654 is queued but blocked — it will never satisfy"
+    state._update_drive_queue_entry_local(
+        REPO, 1660, state="blocked", last_reason=dep_reason
+    )
+
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+    row = _row_for(result.output, f"{REPO}#1660")
+
+    # The merged pre-req (1650) still drops out (rule 1 applies everywhere)…
+    assert f"{REPO}#1650" not in row, row
+    # …but the genuinely-unsatisfiable one (1654) still renders, unchanged.
+    assert f"after={REPO}#1654" in row, row
+    # This row is dependency-caused: no own-cause colon on the state token.
+    assert "blocked:" not in row, row
+    assert f"      last" in result.output
+    assert dep_reason in result.output
+
+
+def test_list_with_no_after_is_unaffected_by_the_2183_diagnosis(cli):
+    """A `blocked` entry that never declared any `after=` at all keeps
+    rendering exactly as it always has — no board dependency, no remedy
+    line, no own-cause relabeling."""
+    cli("add", REPO, "1650")
+    state._update_drive_queue_entry_local(
+        REPO, 1650, state="blocked", last_reason="exhausted retries"
+    )
+
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+    row = _row_for(result.output, f"{REPO}#1650")
+    assert row.strip().endswith("blocked"), row
+    assert "after=" not in row
+    assert "remedy:" not in result.output
+    assert "exhausted retries" in result.output
+
+
 # ── remove / move ────────────────────────────────────────────────────────────