code-coordinator 0.5.527__tar.gz → 0.5.528__tar.gz

{code_coordinator-0.5.527 → code_coordinator-0.5.528}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.527
+Version: 0.5.528
 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.528/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.528",
+  "distance": 0,
+  "node": "g5d8c44f81e315b4c270cd5e0de714532c0ec9395",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-28"
+}

{code_coordinator-0.5.527 → code_coordinator-0.5.528}/coord/drive_queue.py

@@ -6462,6 +6462,29 @@ def plan_tick(
     # carries fresh, right below.
     effective_last_reason: dict[str, str] = {e.key: e.last_reason for e in ordered}
 
+    def _refresh_only(reason: str, current: str) -> dict[str, Any]:
+        """``{}`` unless *reason* is non-empty and differs from *current*.
+
+        #3461: a `counted=False` deferral must never bump `deferrals` or feed
+        the queue-level alert (see `Deferral`'s own docstring on that flag) —
+        but the descriptive TEXT still has to keep up with reality when the
+        walk re-derives it for an entry that isn't actually competing for a
+        slot this tick (the queue is at capacity, or this entry sits behind
+        an already-chosen launch in the report-only tail). Writing ONLY on a
+        real change means `reason_at` — stamped by
+        `coord.state._update_drive_queue_entry_local` whenever `last_reason`
+        is present in the same update, #2133 — only moves when the text
+        actually does, so the `(Nm ago)` age it powers keeps meaning "how
+        long this has been true" rather than "how long since some tick
+        happened to re-walk this row". An empty *reason* (the fully-eligible,
+        nothing-to-report shape `_Verdict(True)` returns) writes nothing —
+        overwriting a real reason with blank text would be a regression, not
+        a refresh.
+        """
+        if not reason or reason == current:
+            return {}
+        return {"last_reason": reason}
+
     reconciles: list[Reconcile] = []
     blocked: list[Blocked] = []
     deferrals: list[Deferral] = []
@@ -7102,11 +7125,41 @@ def plan_tick(
         )
 
     if capacity - occupied <= 0:
+        # #3461: at capacity is the NORMAL steady state of a deep queue, so
+        # this early return can fire for many ticks in a row. Before this, it
+        # produced no deferral at all, which meant a `waiting` entry's
+        # `last_reason` — e.g. "waiting on X (queued, blocked, ...)" — never
+        # got a chance to notice X had since flipped back to `waiting`, or
+        # landed. `_resolve_prereqs` is cheap (no I/O, just the cached board
+        # + this tick's `states`), so it still runs for every `waiting` entry
+        # here; only the TEXT is refreshed (`_refresh_only` below is a no-op
+        # unless it actually changed) and only via `counted=False` — no
+        # attempt is spent, `deferrals` does not move, and the queue-level
+        # alert (computed only in the launch walk below) is untouched, same
+        # as every other early return in this function.
+        for entry in ordered:
+            if states.get(entry.key) != STATE_WAITING:
+                continue
+            verdict = _resolve_prereqs(
+                entry,
+                board,
+                states,
+                cycle_keys,
+                held_gates,
+                live_prereq_terminal,
+                effective_last_reason,
+            )
+            updates = _refresh_only(verdict.reason, entry.last_reason)
+            if not updates:
+                continue
+            deferrals.append(
+                Deferral(entry.key, verdict.reason, counted=False, updates=updates)
+            )
         return TickPlan(
             **plan_base,
             reconciles=tuple(reconciles),
             blocked=tuple(blocked),
-            deferrals=(),
+            deferrals=tuple(deferrals),
             alert=None,
             launch=None,
         )
@@ -7237,17 +7290,35 @@ def plan_tick(
     for entry in waiting:
         if launch is not None:
             # Report-only pass over the tail of the queue.  The launch above
-            # already won this tick, so nothing here is mutated (see
-            # Deferral.counted) — this exists so `--dry-run` explains the rest
-            # of the queue instead of going silent after the first line.
+            # already won this tick, so `counted` stays `False` and neither
+            # `deferrals` nor the queue-level alert moves for anything found
+            # here — that part is unchanged. #3461: the descriptive TEXT is
+            # no longer left frozen just because this entry never got to
+            # compete for a slot — `_refresh_only` (defined near the top of
+            # this function) still folds a changed reading into `updates` so
+            # `--dry-run` AND a real tick both keep `last_reason` current for
+            # every entry the walk reaches, not only the one that launched.
             cooldown = _cooldown_reason(entry)
             if cooldown:
-                deferrals.append(Deferral(entry.key, cooldown, counted=False))
+                deferrals.append(
+                    Deferral(
+                        entry.key,
+                        cooldown,
+                        counted=False,
+                        updates=_refresh_only(cooldown, entry.last_reason),
+                    )
+                )
                 continue
             backoff = _backoff_reason(entry)
             if backoff:
                 deferrals.append(
-                    Deferral(entry.key, backoff, counted=False, backing_off=True)
+                    Deferral(
+                        entry.key,
+                        backoff,
+                        counted=False,
+                        backing_off=True,
+                        updates=_refresh_only(backoff, entry.last_reason),
+                    )
                 )
                 continue
             verdict = _resolve_prereqs(
@@ -7261,20 +7332,35 @@ def plan_tick(
             )
             if not verdict.satisfied:
                 deferrals.append(
-                    Deferral(entry.key, verdict.reason, counted=False)
+                    Deferral(
+                        entry.key,
+                        verdict.reason,
+                        counted=False,
+                        updates=_refresh_only(verdict.reason, entry.last_reason),
+                    )
                 )
                 continue
             cordoned = _cordon_reason(entry)
             if cordoned:
                 deferrals.append(
-                    Deferral(entry.key, cordoned, counted=False, cordoned=True)
+                    Deferral(
+                        entry.key,
+                        cordoned,
+                        counted=False,
+                        cordoned=True,
+                        updates=_refresh_only(cordoned, entry.last_reason),
+                    )
                 )
                 continue
             repo_limit = _repo_limit_reason(entry)
             if repo_limit:
                 deferrals.append(
                     Deferral(
-                        entry.key, repo_limit, counted=False, repo_limited=True
+                        entry.key,
+                        repo_limit,
+                        counted=False,
+                        repo_limited=True,
+                        updates=_refresh_only(repo_limit, entry.last_reason),
                     )
                 )
             continue

{code_coordinator-0.5.527 → code_coordinator-0.5.528}/tests/test_drive_queue.py

@@ -1309,7 +1309,14 @@ def test_only_one_entry_launches_per_tick():
     entries = [entry(1650, position=0), entry(1654, position=1)]
     plan = plan_tick(entries, board(), capacity=5)
     assert plan.launch is not None and plan.launch.issue == 1650
-    assert len(plan.writes()) == 0  # nothing else touched
+    # #3461: the OTHER row is never launched, retried, or escalated — but its
+    # `last_reason` (previously "", never set) does refresh, so the report
+    # cell it feeds does not stay blank/stale for as long as this entry sits
+    # behind its own repo's in-flight slot.
+    assert len(plan.writes()) == 1
+    key, updates = plan.writes()[0]
+    assert key == entry_key(REPO, 1654)
+    assert updates == {"last_reason": plan.deferrals[0].reason}
 
 
 def test_entries_after_the_launch_are_reported_but_never_counted():
@@ -1321,8 +1328,14 @@ def test_entries_after_the_launch_are_reported_but_never_counted():
     assert plan.launch is not None and plan.launch.issue == 1650
     assert [d.key for d in plan.deferrals] == [entry_key(REPO, 1654)]
     assert plan.deferrals[0].counted is False
-    assert plan.deferrals[0].updates == {}
-    assert plan.writes() == []  # a launch tick mutates only the launched row
+    # #3461: `counted` staying `False` means no attempt is spent and no
+    # `deferrals` bump — but the TEXT still refreshes (from "" to the fresh
+    # "waiting on ..." reading), so `writes()` is no longer empty even though
+    # this tick launched exactly one row.
+    assert plan.deferrals[0].updates == {"last_reason": plan.deferrals[0].reason}
+    assert plan.writes() == [
+        (entry_key(REPO, 1654), {"last_reason": plan.deferrals[0].reason})
+    ]
     text = "\n".join(render_plan(plan))
     assert f"defer {entry_key(REPO, 1654)}" in text
     assert entry_key(REPO, 1650) in text
@@ -1542,9 +1555,25 @@ def test_the_launch_takes_its_own_repos_slot_in_the_report_only_tail():
     assert plan.launch is not None and plan.launch.issue == 302
     assert [d.key for d in plan.deferrals] == ["quadraui#303"]
     assert plan.deferrals[0].counted is False  # never competed for the slot
-    assert plan.deferrals[0].updates == {}
-    assert plan.writes() == []
     assert "at its limit (1/1)" in plan.deferrals[0].reason
+    # #3461: the TEXT still refreshes even though nothing here counts as a
+    # deferral — this entry's stored `last_reason` was "" (never set), so
+    # the first tick that reaches it writes the fresh reading...
+    assert plan.deferrals[0].updates == {"last_reason": plan.deferrals[0].reason}
+    assert plan.writes() == [("quadraui#303", {"last_reason": plan.deferrals[0].reason})]
+    # ...but a SECOND tick against a row that already carries that exact
+    # text writes nothing — no churn once the reading stops changing.
+    stable_entries = [
+        other(302, "quadraui", position=0),
+        other(303, "quadraui", position=1, last_reason=plan.deferrals[0].reason),
+    ]
+    plan2 = plan_tick(
+        stable_entries,
+        cross_repo_board(open_=("quadraui#302", "quadraui#303")),
+        capacity=3,
+    )
+    assert plan2.deferrals[0].updates == {}
+    assert plan2.writes() == []
 
 
 def test_an_unsatisfiable_prereq_still_blocks_inside_a_full_repo():
@@ -1589,6 +1618,128 @@ def test_a_plan_without_a_per_repo_ceiling_renders_the_original_line():
     assert "per-repo" not in "\n".join(render_plan(plan))
 
 
+# ── plan_tick: #3461 — a waiting entry's `last_reason` must not freeze ──────
+
+
+def test_stale_last_reason_refreshes_while_the_queue_sits_at_capacity():
+    """The steady state of a deep queue is AT CAPACITY, not mid-walk — before
+    #3461 that early return produced no deferral at all, so a dependent's
+    `last_reason` could quote a pre-req's LONG-GONE `blocked` state for as
+    long as the queue stayed full."""
+    dep_key = entry_key(REPO, 1650)
+    stale_reason = (
+        f"waiting on {dep_key} (queued, blocked, but its own gate reading is "
+        "an unconfirmed probe failure, not a confirmed-still-shut gate — "
+        "retrying, not blocked permanently, #3368)"
+    )
+    entries = [
+        # Occupies the queue's only slot — recently launched, so #1794's
+        # startup grace keeps it counted even with no live session yet.
+        entry(1600, position=0, state=STATE_RUNNING, launched_at=NOW - 41.0),
+        # X: was `blocked` (the stale text above quotes it), has SINCE been
+        # removed and re-added as `waiting` — exactly the #3461 incident.
+        entry(1650, position=1, state=STATE_WAITING),
+        entry(
+            1654,
+            position=2,
+            after=(dep_key,),
+            last_reason=stale_reason,
+            deferrals=3,
+        ),
+    ]
+    plan = plan_tick(entries, board(open_=(1650, 1654)), capacity=1, now=NOW)
+    assert plan.launch is None
+    assert plan.occupied == plan.capacity == 1  # the whole point: AT capacity
+    dep_update = next(d for d in plan.deferrals if d.key == entry_key(REPO, 1654))
+    assert dep_update.counted is False  # never competed for a slot
+    assert dep_update.reason == f"waiting on {dep_key} (queued, waiting)"
+    assert dep_update.reason != stale_reason
+    assert dep_update.updates == {"last_reason": dep_update.reason}
+    # A text refresh is not a counted deferral: the persisted `deferrals`
+    # counter must not move.
+    assert "deferrals" not in dep_update.updates
+    # `writes()` also carries #1794's own "still starting" reconcile note for
+    # the running entry — unrelated to this fix — so check D's write by key
+    # rather than asserting the whole list.
+    assert dict(plan.writes())[entry_key(REPO, 1654)] == {
+        "last_reason": dep_update.reason
+    }
+
+
+def test_stale_last_reason_refreshes_in_the_report_only_tail():
+    """Same staleness, different cause: D is walked AFTER this tick's own
+    launch already won, so the pre-#3461 report-only pass discarded its
+    freshly re-derived reason instead of persisting it."""
+    dep_key = entry_key(REPO, 1650)
+    stale_reason = (
+        f"waiting on {dep_key} (queued, blocked, but its own gate reading is "
+        "an unconfirmed probe failure, not a confirmed-still-shut gate — "
+        "retrying, not blocked permanently, #3368)"
+    )
+    entries = [
+        # X: fully eligible, wins this tick's one launch.
+        entry(1650, position=0),
+        entry(
+            1654,
+            position=1,
+            after=(dep_key,),
+            last_reason=stale_reason,
+            deferrals=3,
+        ),
+    ]
+    plan = plan_tick(entries, board(open_=(1650, 1654)), capacity=1)
+    assert plan.launch is not None and plan.launch.issue == 1650
+    dep_update = next(d for d in plan.deferrals if d.key == entry_key(REPO, 1654))
+    assert dep_update.counted is False
+    assert dep_update.reason == f"waiting on {dep_key} (queued, waiting)"
+    assert dep_update.reason != stale_reason
+    assert dep_update.updates == {"last_reason": dep_update.reason}
+    assert "deferrals" not in dep_update.updates
+
+
+def test_an_unchanged_reason_writes_nothing_even_when_reported():
+    """No churn: once a `waiting` entry's stored `last_reason` already
+    matches what this tick would derive, refreshing it again is a no-op —
+    at capacity and in the report-only tail alike."""
+    dep_key = entry_key(REPO, 1650)
+    current_reason = f"waiting on {dep_key} (queued, waiting)"
+
+    at_capacity_entries = [
+        entry(1600, position=0, state=STATE_RUNNING, launched_at=NOW - 41.0),
+        entry(1650, position=1, state=STATE_WAITING),
+        entry(
+            1654,
+            position=2,
+            after=(dep_key,),
+            last_reason=current_reason,
+            deferrals=3,
+        ),
+    ]
+    at_capacity_plan = plan_tick(
+        at_capacity_entries, board(open_=(1650, 1654)), capacity=1, now=NOW
+    )
+    # #1794's own "still starting" reconcile note for the running entry is
+    # unrelated to this fix and writes every tick regardless — what matters
+    # here is that D's OWN row (whose text hasn't changed) gets no write.
+    assert entry_key(REPO, 1654) not in dict(at_capacity_plan.writes())
+
+    report_only_entries = [
+        entry(1650, position=0),
+        entry(
+            1654,
+            position=1,
+            after=(dep_key,),
+            last_reason=current_reason,
+            deferrals=3,
+        ),
+    ]
+    report_only_plan = plan_tick(
+        report_only_entries, board(open_=(1650, 1654)), capacity=1
+    )
+    assert report_only_plan.launch is not None
+    assert report_only_plan.writes() == []
+
+
 # ── plan_tick: reconciliation ────────────────────────────────────────────────
 
 

code_coordinator-0.5.527/code_coordinator.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.5.527",
-  "distance": 0,
-  "node": "g60df5470d276cf021d283bc8ebbd6cab60aee904",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-27"
-}