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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.526
+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.526 → 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.526
+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.526 → code_coordinator-0.5.528}/coord/board_schema.py

@@ -313,6 +313,13 @@ class BoardDriveQueueEntry:
     apply_verdict: str
     apply_verdict_reason: str
     apply_verdict_at: float | None = None
+    # #3463: the all-time WORK_LIKE leg count this row saw when
+    # `enqueue_drive_queue` last (re-)declared it — see
+    # `coord.drive_queue.QueueEntry.legs_at_enqueue` for what it feeds.
+    # Default 0 — both for a row predating this column and for a thin client
+    # talking to a daemon that predates it — reproduces the pre-#3463
+    # `work_leg_count - 1` fix-round formula exactly.
+    legs_at_enqueue: int = 0
 
 
 # ── #3428 (#3408 item 3): concurrency ceilings + provenance + occupancy ──────

{code_coordinator-0.5.526 → code_coordinator-0.5.528}/coord/commands/drive_queue.py

@@ -106,7 +106,6 @@ from coord.drive_queue import (
     resolve_max_parallel,
     resolve_max_parallel_per_repo,
     resolve_repo_ceilings,
-    total_fix_round_budget,
     unreachable_wait_alert,
     validate_apply_gate,
     validate_enqueue,
@@ -1637,20 +1636,35 @@ def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) ->
             bits.append(f"attempts={entry.attempts}")
         if entry.deferrals:
             bits.append(f"deferrals={entry.deferrals}")
-        # #2972: the fix-round ceiling's OWN count — total work legs (work +
-        # every fix round) this entry has run across every relaunch, against
-        # the budget `_reconcile_running` actually enforces. Only shown once
-        # at least one leg has been dispatched — a `waiting` entry that has
-        # never launched has nothing to report, same as `attempts`/
+        # #2972/#3463: the fix-round ceiling's OWN count, rendered with the
+        # SAME meaning `coord drive`'s own `fix round N/M` lines use
+        # (`coord/drive.py`) — fix rounds SPENT against `max_fix_rounds`, not
+        # "every work-like leg including the initial one" against "budget +
+        # 1". `lifetime_legs` is every WORK_LIKE leg `leg_counts()` has ever
+        # seen for this issue, all-time, across every predecessor row; #3463
+        # narrows that to `row_legs` — legs run since THIS row was last
+        # (re-)declared by `enqueue_drive_queue` (`entry.legs_at_enqueue`),
+        # the SAME baseline `remaining_fix_rounds` subtracts. Only shown once
+        # this row has itself dispatched at least one leg — a `waiting`
+        # entry that has never launched (or a freshly re-added row that
+        # hasn't relaunched yet) has nothing to report, same as `attempts`/
         # `deferrals` above being suppressed at 0.
-        work_legs = sum(
+        lifetime_legs = sum(
             count
             for kind, count in all_leg_counts.get(entry.key, {}).items()
             if kind in WORK_LIKE
         )
-        if work_legs:
-            budget = total_fix_round_budget(entry, fix_round_config_default)
-            bits.append(f"fix_rounds={min(work_legs, budget)}/{budget}")
+        row_legs = max(lifetime_legs - entry.legs_at_enqueue, 0)
+        if row_legs:
+            effective_max = effective_max_fix_rounds(entry, fix_round_config_default)
+            fix_rounds_spent = max(row_legs - 1, 0)
+            # #3463: an overrun (the #3454 leak: a row that dispatched past
+            # its own ceiling before the fix landed) must stay VISIBLE as an
+            # overrun, not silently clamp back down to a reassuring `N/N` —
+            # a gate that can never show its own failure state is not a
+            # gate (epic #2096).
+            overrun = "!" if fix_rounds_spent > effective_max else ""
+            bits.append(f"fix_rounds={fix_rounds_spent}/{effective_max}{overrun}")
         if entry.resumes:
             # #2230: how many times the merge-gate sweep has auto-resumed
             # THIS row from `blocked` — the churn signal the issue asks to be

{code_coordinator-0.5.526 → code_coordinator-0.5.528}/coord/db.py

@@ -1058,7 +1058,14 @@ def retry_on_locked(
 # first place" (a quadraui-style merge into a non-default branch) — both
 # read identically as `merged=True, issue_state="open"` otherwise. See
 # `coord.drive_queue.IssueFacts.landed`'s docstring.
-_DB_SCHEMA_VERSION = 19
+#
+# #3463: bumped 19 -> 20 for the new `drive_queue.legs_at_enqueue` column
+# appended to `_MIGRATE_ADD_COLUMNS` below — the all-time WORK_LIKE leg
+# count a row saw at `enqueue_drive_queue` time, so `remaining_fix_rounds`
+# can measure a row's own spend from ITS baseline rather than every
+# predecessor row's lifetime total. See `coord.drive_queue.QueueEntry.
+# legs_at_enqueue`.
+_DB_SCHEMA_VERSION = 20
 
 
 def _read_schema_version(conn: sqlite3.Connection) -> int:
@@ -1592,6 +1599,24 @@ _SCHEMA_SQL = """
             -- point-in-time observation" discipline #2133's reason_at
             -- established for last_reason. NULL until a verdict is recorded.
             apply_verdict_at REAL,
+            -- #3463: the all-time WORK_LIKE leg count (coord.state.
+            -- leg_counts()'s per-issue figure) THIS ROW saw at the moment it
+            -- was declared by `enqueue_drive_queue` — the baseline
+            -- `coord.drive_queue.remaining_fix_rounds` subtracts off before
+            -- comparing against `max_fix_rounds`, so a row's own spend is
+            -- "legs since THIS row was enqueued", not "legs this issue has
+            -- ever had across every predecessor row". Re-stamped on every
+            -- `enqueue_drive_queue` call (insert OR update-in-place), which
+            -- is what makes an explicit `remove` + `add` actually hand out a
+            -- fresh budget as the #3454 ceiling message promises, while
+            -- leaving the #2972 "no fresh budget from a bare relaunch"
+            -- guarantee untouched — a relaunch never calls
+            -- `enqueue_drive_queue` at all, only `update_drive_queue_entry`.
+            -- 0 (NOT NULL) for every row predating this column: subtracting
+            -- 0 reproduces the pre-#3463 `work_leg_count - 1` formula
+            -- exactly, so an existing row's already-computed remaining
+            -- budget does not change under this migration.
+            legs_at_enqueue INTEGER NOT NULL DEFAULT 0,
             UNIQUE(repo_name, issue_number)
         );
 
@@ -2510,6 +2535,13 @@ _MIGRATE_ADD_COLUMNS: list[str] = [
     # auto-close the linked issue at all — both look identical as
     # `merged=True, issue_state="open"` without it.
     "ALTER TABLE issues ADD COLUMN state_reason TEXT NOT NULL DEFAULT ''",
+    # #3463: see the CREATE TABLE comment above — the all-time WORK_LIKE leg
+    # count a row saw at `enqueue_drive_queue` time, so a re-added row's fix
+    # budget is measured from ITS OWN baseline rather than every
+    # predecessor's lifetime spend. 0 for every row predating this
+    # migration, which reproduces the pre-#3463 `work_leg_count - 1` formula
+    # unchanged for that row.
+    "ALTER TABLE drive_queue ADD COLUMN legs_at_enqueue INTEGER NOT NULL DEFAULT 0",
 ]
 
 

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

@@ -1456,6 +1456,19 @@ class QueueEntry:
     # `last_reason`. `None` for a row predating this column or one whose
     # `apply_verdict` is still unset.
     apply_verdict_at: float | None = None
+    # #3463: the all-time WORK_LIKE leg count (the SAME per-issue figure
+    # `IssueFacts.work_leg_count` carries) this row saw at the moment
+    # `enqueue_drive_queue` last declared it — see
+    # `coord.state._enqueue_drive_queue_local` for where it is stamped, on
+    # every `add` (insert OR update-in-place), never carried forward.
+    # `remaining_fix_rounds` subtracts this off `facts.work_leg_count`
+    # before comparing spend against `max_fix_rounds`, so a row's own
+    # budget is measured from ITS OWN baseline — "legs since THIS row was
+    # last (re-)declared" — rather than the lifetime total every
+    # predecessor row for this issue ever spent. `0` for every row
+    # predating this column, which reproduces the pre-#3463
+    # `work_leg_count - 1` formula exactly for that row.
+    legs_at_enqueue: int = 0
 
     @property
     def key(self) -> str:
@@ -1556,6 +1569,7 @@ class QueueEntry:
                 if row.get("apply_verdict_at") is None
                 else float(row.get("apply_verdict_at"))
             ),
+            legs_at_enqueue=int(row.get("legs_at_enqueue") or 0),
         )
 
 
@@ -1617,29 +1631,46 @@ def remaining_fix_rounds(
     resumes rather than restarts.
 
     ``facts.work_leg_count`` is every work-like assignment `build_board_view`
-    has EVER seen for this issue, across every drive session this entry has
-    had — not just the one that just died. Subtracting the one unconditional
-    initial work leg turns that into "fix rounds already spent"; subtracting
-    THAT from :func:`effective_max_fix_rounds`'s plain per-drive allowance
-    (NOT :func:`total_fix_round_budget` — that figure already has the
-    initial work leg folded in, and folding it in a second time here would
-    hand a brand-new entry, with zero legs spent, a budget one round wider
-    than `coord drive`'s own interactive default ever allows) is what makes
-    a second (or third, or fourth) relaunch get a SMALLER budget than the
+    has EVER seen for this issue, across every drive session this entry (and
+    every predecessor row for the same issue) has ever had. #3463: what this
+    row has itself SPENT is that lifetime total minus
+    ``entry.legs_at_enqueue`` — the lifetime count as of the moment THIS row
+    was last (re-)declared by `enqueue_drive_queue` — not the raw lifetime
+    total. Subtracting the one unconditional initial work leg turns that
+    into "fix rounds already spent"; subtracting THAT from
+    :func:`effective_max_fix_rounds`'s plain per-drive allowance (NOT
+    :func:`total_fix_round_budget` — that figure already has the initial
+    work leg folded in, and folding it in a second time here would hand a
+    brand-new entry, with zero legs spent, a budget one round wider than
+    `coord drive`'s own interactive default ever allows) is what makes a
+    second (or third, or fourth) relaunch get a SMALLER budget than the
     first, instead of the same fresh one every time — the exact defect
     quadraui#625 reported: four work legs dispatched against a
     ``pipeline.max_fix_rounds`` of 2 (budget 3), because each relaunch's
     ``coord drive --max-fix-rounds`` was computed from `entry` alone, blind
     to what prior sessions had already spent. A fresh entry (``work_leg_count
-    == 0``) reads back exactly :func:`effective_max_fix_rounds` — unchanged
-    from every pre-#2972 launch.
+    == legs_at_enqueue``) reads back exactly :func:`effective_max_fix_rounds`
+    — unchanged from every pre-#2972 launch, and unchanged by #3463 for a row
+    predating the ``legs_at_enqueue`` column (``0``, reproducing the old
+    ``work_leg_count - 1`` formula exactly).
+
+    #3463: this is also what makes an explicit ``coord drive-queue remove``
+    + ``add`` actually hand out a fresh budget, as the #3454 ceiling message
+    promises — the re-added row's own ``legs_at_enqueue`` is stamped at
+    THAT ``add``, not inherited from a predecessor row. It does NOT change
+    the #2972 guarantee that a bare relaunch (no `add` in between) gets no
+    fresh budget: a relaunch never calls `enqueue_drive_queue` at all, only
+    `update_drive_queue_entry`, so `legs_at_enqueue` never moves between
+    relaunches of the SAME row.
 
     Never negative — an entry that has already met or exceeded
     :func:`total_fix_round_budget` reads ``0`` (no more fix rounds), the
     signal `_reconcile_running` uses to stop relaunching altogether rather
     than pass a session a budget it cannot spend down further.
     """
-    fix_rounds_spent = max(facts.work_leg_count - 1, 0)
+    fix_rounds_spent = max(
+        facts.work_leg_count - entry.legs_at_enqueue - 1, 0
+    )
     return max(effective_max_fix_rounds(entry, config_default) - fix_rounds_spent, 0)
 
 
@@ -5187,9 +5218,14 @@ def _reconcile_running(
         # showed a bare "giving up" read as "nothing more will happen or be
         # spent" while the fleet kept dispatching paid legs against the same
         # branch for hours.
+        # #3463: legs run against THIS row's own baseline, not the raw
+        # lifetime count — see `remaining_fix_rounds`'s docstring. Reporting
+        # the raw `facts.work_leg_count` here would misstate a re-added
+        # row's spend as its predecessors' lifetime total.
+        row_legs = max(facts.work_leg_count - entry.legs_at_enqueue, 0)
         reason = (
             f"fix-round ceiling reached across relaunches (#2972): "
-            f"{facts.work_leg_count} work leg(s) already run against a "
+            f"{row_legs} work leg(s) already run against this row's own "
             f"budget of {budget} (1 work dispatch + "
             f"{effective_max_fix_rounds(entry, fix_round_config_default)} fix "
             f"round(s)) — giving up rather than relaunching with a fresh "
@@ -5197,8 +5233,8 @@ def _reconcile_running(
             f"gate-clear resume, or auto-dispatched stale-rebase conflict-fix "
             f"(from any of this fleet's independent dispatchers) will fire "
             f"for this entry — `coord drive-queue remove {entry.repo} "
-            f"{entry.issue}` + `add` (a fresh row) is the only way to give "
-            f"it another attempt."
+            f"{entry.issue}` + `add` (a fresh row, #3463: with its own fresh "
+            f"budget) is the only way to give it another attempt."
         )
         return (
             Reconcile(entry.key, "exhausted", reason, occupies=False),
@@ -6426,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] = []
@@ -7066,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,
         )
@@ -7201,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(
@@ -7225,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.526 → code_coordinator-0.5.528}/coord/state.py

@@ -8473,7 +8473,7 @@ _DRIVE_QUEUE_COLUMNS = (
     "enqueued_at, hold_after, hold_reason, resume_when, hold_state, "
     "hold_probes, launch_host, hold_scope, resumes, retry_backoff_at, "
     "max_fix_rounds, no_acceptance, plan_destructive, apply_verdict, "
-    "apply_verdict_reason, apply_verdict_at"
+    "apply_verdict_reason, apply_verdict_at, legs_at_enqueue"
 )
 
 # Fields `update_drive_queue_entry` may write. Deliberately excludes the
@@ -8655,6 +8655,42 @@ def enqueue_drive_queue(
     )
 
 
+def _work_leg_count_for_issue_local(conn, repo_name: str, issue_number: int) -> int:
+    """All-time WORK_LIKE assignment count for ONE issue, right now (#3463).
+
+    Same scope as :func:`_leg_counts_local` (both ``assignments`` and
+    ``assignments_archive``, so a long-lived issue's early legs don't drop
+    out of the count as they age past the archive retention window) but
+    narrowed to a single ``(repo_name, issue_number)`` and run on the
+    CALLER's own connection — so ``_enqueue_drive_queue_local`` can stamp
+    ``legs_at_enqueue`` atomically with the very write that declares the
+    row, rather than racing a second connection's transaction.
+
+    A NULL/empty ``type`` counts as ``"work"`` — same convention
+    :func:`coord.drive_queue.compute_leg_counts` uses (``t = assignment_type
+    or "work"``) — which is always in ``WORK_LIKE_TYPES``, so a bare
+    ``type IS NULL`` row is counted, never silently dropped.
+    """
+    placeholders = ",".join("?" for _ in WORK_LIKE_TYPES)
+    total = 0
+    for table in ("assignments", "assignments_archive"):
+        try:
+            row = sql.execute(conn,
+                f"SELECT COUNT(*) AS n FROM {table} WHERE repo_name = ? "  # noqa: S608 — constant
+                f"AND issue_number = ? AND (type IS NULL OR type IN ({placeholders}))",
+                (repo_name, issue_number, *WORK_LIKE_TYPES),
+            ).fetchone()
+        except sql.driver_errors() as exc:  # #2784: was sqlite3.OperationalError only
+            # Mirrors `_leg_counts_local`: `continue` on the SAME connection
+            # so a missing `assignments_archive` (housekeeping never ran)
+            # doesn't poison the transaction the caller's write is still
+            # inside of (#2983).
+            rollback_after_driver_error(conn, exc)
+            continue
+        total += int(row["n"]) if row is not None else 0
+    return total
+
+
 def _enqueue_drive_queue_local(
     repo_name: str,
     issue_number: int,
@@ -8705,6 +8741,21 @@ def _enqueue_drive_queue_local(
             "SELECT id FROM drive_queue WHERE repo_name = ? AND issue_number = ?",
             (repo_name, issue_number),
         ).fetchone()
+        # #3463: the all-time WORK_LIKE leg count for THIS issue, read on
+        # THIS connection right before the write below commits it as the
+        # row's new baseline. Recomputed on every `enqueue_drive_queue` call
+        # — insert AND update-in-place — never carried forward from a prior
+        # `legs_at_enqueue`, so an explicit `add` (whether it lands on a
+        # brand-new row after `remove`, or refreshes an already-queued one)
+        # always measures this row's spend from "legs as of right now",
+        # which is what lets `remaining_fix_rounds` hand out the fresh
+        # budget the #3454 ceiling message promises. A bare relaunch never
+        # reaches this function at all (it goes through
+        # `update_drive_queue_entry` instead), so the #2972 "no fresh
+        # budget from a relaunch" guarantee is untouched.
+        legs_at_enqueue = _work_leg_count_for_issue_local(
+            conn, repo_name, issue_number
+        )
         if existing is not None:
             # Already queued → update the operator-declared fields in place
             # rather than creating a second row for the same issue.  Run
@@ -8720,7 +8771,7 @@ def _enqueue_drive_queue_local(
                 "UPDATE drive_queue SET machine = ?, after_json = ?, hold_after = ?, "
                 "hold_reason = ?, resume_when = ?, hold_state = ?, hold_probes = 0, "
                 "hold_scope = ?, max_fix_rounds = ?, no_acceptance = ?, "
-                "plan_destructive = ? WHERE id = ?",
+                "plan_destructive = ?, legs_at_enqueue = ? WHERE id = ?",
                 (
                     machine,
                     after_json,
@@ -8732,6 +8783,7 @@ def _enqueue_drive_queue_local(
                     max_fix_rounds,
                     no_acceptance_int,
                     plan_destructive_int,
+                    legs_at_enqueue,
                     existing["id"],
                 ),
             )
@@ -8746,8 +8798,8 @@ def _enqueue_drive_queue_local(
             "INSERT INTO drive_queue "
             "(repo_name, issue_number, position, machine, after_json, enqueued_at, "
             " hold_after, hold_reason, resume_when, hold_state, hold_scope, "
-            " max_fix_rounds, no_acceptance, plan_destructive) "
-            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            " max_fix_rounds, no_acceptance, plan_destructive, legs_at_enqueue) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
             (
                 repo_name,
                 issue_number,
@@ -8763,6 +8815,7 @@ def _enqueue_drive_queue_local(
                 max_fix_rounds,
                 no_acceptance_int,
                 plan_destructive_int,
+                legs_at_enqueue,
             ),
             pk_column="id",
         )

{code_coordinator-0.5.526 → code_coordinator-0.5.528}/tests/test_cli_drive_queue.py

@@ -5035,6 +5035,70 @@ def test_leg_counts_non_lock_failure_warns_and_degrades_to_zero_not_silence(
     assert queued(1650)["state"] == "running"
 
 
+# ── #3463: `list`'s `fix_rounds=` renders spend, not "every leg incl. the
+#    initial one against budget+1" — and never clamps an overrun back to a
+#    reassuring `N/N`.
+
+
+def test_list_renders_fix_rounds_as_spent_over_max_not_legs_over_budget_plus_one(
+    cli, seed
+):
+    """`--max-fix-rounds 4` — a row that has run 1 work + 4 fix legs (5 legs
+    total) must render `fix_rounds=4/4` (4 fix rounds spent of 4 allowed),
+    never the pre-#3463 `5/5` (every leg, including the unconditional
+    initial one, against `max_fix_rounds + 1`)."""
+    seed(issues={1650: "open"})
+    assert cli("add", REPO, "1650", "--max-fix-rounds", "4").exit_code == 0
+    # The row's own history accrues AFTER it is declared — `legs_at_enqueue`
+    # was stamped at 0 by the `add` above, so every one of these counts as
+    # this row's own spend.
+    seed(assignments=[
+        {"issue_number": 1650, "type": "work", "status": "done"}
+        for _ in range(5)
+    ])
+
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+    assert "fix_rounds=4/4" in result.output
+    assert "fix_rounds=5/5" not in result.output
+
+
+def test_list_renders_zero_spent_for_a_fresh_row_with_only_its_initial_leg(
+    cli, seed
+):
+    """A fresh `--max-fix-rounds 5` row with only its initial (unconditional)
+    work leg has spent NO fix rounds yet — `fix_rounds=0/5`, never the
+    pre-#3463 `1/6`."""
+    seed(issues={1650: "open"})
+    assert cli("add", REPO, "1650", "--max-fix-rounds", "5").exit_code == 0
+    seed(assignments=[{"issue_number": 1650, "type": "work", "status": "running"}])
+
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+    assert "fix_rounds=0/5" in result.output
+    assert "fix_rounds=1/6" not in result.output
+
+
+def test_list_marks_an_overrun_row_rather_than_clamping_to_n_over_n(cli, seed):
+    """A row that dispatched PAST its own ceiling (the #3454 leak this issue
+    also reports) must stay visibly an overrun — never silently clamp back
+    down to a reassuring `budget/budget`."""
+    seed(issues={1650: "open"})
+    assert cli("add", REPO, "1650", "--max-fix-rounds", "2").exit_code == 0
+    # 1 work + 5 more legs = 6 total, 5 fix rounds spent against a 2-round
+    # allowance — well past the ceiling.
+    seed(assignments=[
+        {"issue_number": 1650, "type": "work", "status": "done"}
+        for _ in range(6)
+    ])
+
+    result = cli("list")
+    assert result.exit_code == 0, result.output
+    assert "fix_rounds=5/2!" in result.output
+    assert "fix_rounds=2/2" not in result.output
+    assert "fix_rounds=3/3" not in result.output
+
+
 def test_a_failed_launch_is_a_consumed_attempt_not_a_running_entry(
     cli, seed, launches
 ):

{code_coordinator-0.5.526 → code_coordinator-0.5.528}/tests/test_db.py

@@ -2468,7 +2468,7 @@ class TestUatStateAndReasonColumns:
 # #3384 bumped this to (19, 97): `issues.state_reason` — GitHub's own witness
 # that an issue was explicitly reopened, distinguishing that from an issue
 # that merged without ever auto-closing.
-_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (19, 97)
+_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (20, 98)
 
 
 class TestMigrateAddColumnsVersionGuard: