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

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

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

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

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

{code_coordinator-0.5.526 → code_coordinator-0.5.527}/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.527}/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.527}/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.527}/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),

{code_coordinator-0.5.526 → code_coordinator-0.5.527}/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.527}/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.527}/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:

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

@@ -956,6 +956,52 @@ def test_total_fix_round_budget_is_work_plus_fix_rounds():
     assert total_fix_round_budget(default_e, None) == DEFAULT_TICK_MAX_FIX_ROUNDS + 1
 
 
+# ── #3463: a re-added row's budget is measured from ITS OWN baseline ────────
+#
+# `IssueFacts.work_leg_count` is a LIFETIME, cross-row count — every
+# predecessor row this (repo, issue) has ever had contributes to it. Before
+# #3463, `remaining_fix_rounds` compared that raw lifetime figure against
+# `max_fix_rounds`, so a fresh row re-added (`coord drive-queue remove` +
+# `add`) after its issue had already burned through 5 lifetime legs read
+# back almost no budget at all — exactly the opposite of what the #3454
+# ceiling message promises ("remove + add ... is the only way to give it
+# another attempt"). `entry.legs_at_enqueue` is the lifetime count AS OF the
+# row's own `enqueue_drive_queue` call — see `coord.state.
+# _enqueue_drive_queue_local` for where it is stamped — so a row's own spend
+# is `work_leg_count - legs_at_enqueue`, never the raw lifetime total.
+
+
+def test_remaining_fix_rounds_gives_a_re_added_row_its_full_budget():
+    """quadraui#1081's exact shape: `--max-fix-rounds 5`, re-added when the
+    issue already has 5 lifetime work legs. Current main (pre-#3463) reads
+    this back as `1` (`5 - 4` against `effective_max_fix_rounds`) — this
+    pins the fix: a freshly re-added row (no legs of its OWN yet) gets its
+    full `max_fix_rounds` back, not a near-exhausted one inherited from
+    every predecessor row's history."""
+    e = entry(1081, max_fix_rounds=5, legs_at_enqueue=5)
+    facts = IssueFacts(known=True, work_leg_count=5)
+    assert remaining_fix_rounds(e, facts, None) == 5
+
+
+def test_remaining_fix_rounds_still_shrinks_across_relaunches_of_the_re_added_row():
+    """The #2972 no-fresh-budget-on-relaunch guarantee is unchanged for the
+    re-added row ITSELF: two more legs run against it (still no new `add`,
+    so `legs_at_enqueue` does not move) shrinks its remaining budget by the
+    one fix round actually spent, same as any other row."""
+    e = entry(1081, max_fix_rounds=5, legs_at_enqueue=5)
+    facts = IssueFacts(known=True, work_leg_count=7)
+    assert remaining_fix_rounds(e, facts, None) == 4
+
+
+def test_remaining_fix_rounds_legs_at_enqueue_default_matches_pre_3463_behaviour():
+    """A row predating the `legs_at_enqueue` column (or one that has never
+    been re-added) reads `legs_at_enqueue == 0` — reproducing the pre-#3463
+    `work_leg_count - 1` formula exactly, byte for byte."""
+    e = entry(1650, max_fix_rounds=2)
+    assert e.legs_at_enqueue == 0
+    assert remaining_fix_rounds(e, IssueFacts(known=True, work_leg_count=2), None) == 1
+
+
 def test_build_board_view_folds_leg_counts_into_work_leg_count():
     """Only WORK_LIKE types count as a work leg — a `review`/`smoke` leg on
     the SAME issue must never inflate the fix-round budget's own count."""

{code_coordinator-0.5.526 → code_coordinator-0.5.527}/tests/test_state.py

@@ -4398,6 +4398,67 @@ class TestDriveQueueLocalWritesRetryLockContention:
             _enqueue_drive_queue_local("api", 9, position=1)
 
 
+class TestEnqueueDriveQueueStampsLegsAtEnqueue:
+    """#3463: `enqueue_drive_queue` must stamp the row's OWN baseline —
+    the all-time WORK_LIKE leg count as of THIS `add` call — not leave it at
+    `0` forever (which would make a re-added row read its predecessors'
+    entire lifetime spend as its own, the exact quadraui#1081 misreport)."""
+
+    @staticmethod
+    def _seed_work_legs(coord_db, *, repo="api", issue=9, count=1, kind="work") -> None:
+        for i in range(count):
+            coord_db.execute(
+                "INSERT INTO assignments (assignment_id, machine_name, repo_name, "
+                "issue_number, issue_title, type) VALUES (?, 'm1', ?, ?, 't', ?)",
+                (f"aid-{repo}-{issue}-{kind}-{i}", repo, issue, kind),
+            )
+        coord_db.commit()
+
+    def test_fresh_row_with_no_history_stamps_zero(self, coord_db) -> None:
+        from coord.state import _enqueue_drive_queue_local, _get_drive_queue_entry_local
+
+        _enqueue_drive_queue_local("api", 9)
+        assert _get_drive_queue_entry_local("api", 9)["legs_at_enqueue"] == 0
+
+    def test_re_added_row_stamps_the_current_lifetime_count(self, coord_db) -> None:
+        """The quadraui#1081 shape: 5 lifetime work legs already exist for
+        this issue (from a predecessor row's history) before the row is
+        (re-)declared — the new row's baseline must be 5, not 0."""
+        from coord.state import _enqueue_drive_queue_local, _get_drive_queue_entry_local
+
+        self._seed_work_legs(coord_db, count=5)
+        _enqueue_drive_queue_local("api", 9)
+        assert _get_drive_queue_entry_local("api", 9)["legs_at_enqueue"] == 5
+
+    def test_updating_an_already_queued_row_re_stamps_the_baseline(
+        self, coord_db
+    ) -> None:
+        """A second `enqueue_drive_queue` call against an already-queued row
+        (the UPDATE branch, not INSERT) re-stamps `legs_at_enqueue` to
+        whatever the lifetime count is NOW — an operator's explicit `add`
+        always measures from "right now", never a stale baseline."""
+        from coord.state import _enqueue_drive_queue_local, _get_drive_queue_entry_local
+
+        _enqueue_drive_queue_local("api", 9)
+        assert _get_drive_queue_entry_local("api", 9)["legs_at_enqueue"] == 0
+
+        self._seed_work_legs(coord_db, count=3)
+        _enqueue_drive_queue_local("api", 9, machine="m2")
+        assert _get_drive_queue_entry_local("api", 9)["legs_at_enqueue"] == 3
+
+    def test_only_work_like_types_count_toward_the_baseline(self, coord_db) -> None:
+        """A `review`/`smoke` leg on the same issue must never inflate the
+        baseline — same WORK_LIKE-only scoping `IssueFacts.work_leg_count`
+        uses."""
+        from coord.state import _enqueue_drive_queue_local, _get_drive_queue_entry_local
+
+        self._seed_work_legs(coord_db, count=2, kind="work")
+        self._seed_work_legs(coord_db, count=4, kind="review")
+        self._seed_work_legs(coord_db, count=1, kind="smoke")
+        _enqueue_drive_queue_local("api", 9)
+        assert _get_drive_queue_entry_local("api", 9)["legs_at_enqueue"] == 2
+
+
 class TestMilestoneLocalLockContention:
     """Same shape, for `_assign_issue_milestone_local` /
     `_unassign_issue_milestone_local`."""