code-coordinator 0.5.324__tar.gz → 0.5.325__tar.gz

{code_coordinator-0.5.324 → code_coordinator-0.5.325}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.324",
+  "tag": "0.5.325",
   "distance": 0,
-  "node": "gfe0ce4aff039fa4d2a916eda693e9adb5553d439",
+  "node": "ge5cc30ddda55f8f402bf6ce19c05a479a58ec944",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-31"

{code_coordinator-0.5.324 → code_coordinator-0.5.325}/coord/ci_fix.py

@@ -50,6 +50,18 @@ _log = logging.getLogger(__name__)
 # same exhausted budget the way an unbounded conflict-fix retry would.
 MAX_CI_FIX_DISPATCHES = 2
 
+# #3011: a ci-fix leg that finishes with the branch HEAD unchanged (see
+# `dispatch_was_noop`) is refunded and does NOT count toward
+# MAX_CI_FIX_DISPATCHES above — but that refund must itself be bounded, or
+# two workers that keep (correctly) declining could cycle forever without
+# ever reaching a verdict. Same magnitude as MAX_CI_FIX_DISPATCHES for the
+# same "a couple of genuine signals is enough" reasoning: once this many
+# CONSECUTIVE legs come back having pushed nothing, that itself is the
+# verdict — the failure is not attributable to this branch — and
+# `coord.commands.merge._dispatch_ci_fixes` escalates to HUMAN_REQUIRED
+# with a reason that says so, distinct from the generic retry-cap message.
+MAX_CI_FIX_NOOP_STREAK = 2
+
 # Prefix on the dispatched fix worker's issue_title — mirrors
 # `conflict_fix.SEMANTIC_FIX_TITLE_PREFIX`'s visibility purpose: the TUI
 # Pipeline row and the fix briefing itself both make it obvious WHY this
@@ -123,6 +135,47 @@ def _has_active_fix(board: Board, entry: QueuedMerge) -> bool:
     return False
 
 
+def dispatch_was_noop(entry: QueuedMerge) -> bool:
+    """True when the LAST ci-fix dispatch for *entry* completed with the
+    branch HEAD unchanged — the worker correctly concluded the CI failure
+    wasn't its to fix and pushed no commit, rather than genuinely attempting
+    a fix. Compares the live, per-tick-refreshed ``entry.branch_head_sha``
+    (see ``coord.merge_queue.process``'s freshness-anchor refresh, which
+    runs before a ``checks_failed`` event is ever emitted) against
+    ``entry.ci_fix_head_sha``, the sha :func:`dispatch_ci_fix` snapshotted
+    at the moment of that dispatch.
+
+    Both empty (no ci-fix ever dispatched for this streak, or a probe
+    failure left the current SHA unknown) reads as ``False`` — fails
+    closed, same as every other SHA-staleness check in this codebase
+    (#821): "we can't tell" must never be treated as "we can tell it
+    didn't move".
+    """
+    return (
+        bool(entry.ci_fix_head_sha)
+        and bool(entry.branch_head_sha)
+        and entry.ci_fix_head_sha == entry.branch_head_sha
+    )
+
+
+def refund_noop_ci_fix(entry: QueuedMerge) -> None:
+    """Undo the attempt :func:`dispatch_ci_fix` speculatively spent for a
+    leg that turned out to be a no-op (:func:`dispatch_was_noop` is
+    ``True``), and track the no-op streak separately so it cannot cycle
+    forever without ever reaching a verdict — see
+    :data:`MAX_CI_FIX_NOOP_STREAK`.
+
+    Called by ``coord.commands.merge._dispatch_ci_fixes`` BEFORE it decides
+    whether to dispatch again for this entry's event; the caller is
+    responsible for checking ``entry.ci_fix_noop_streak`` against the cap
+    afterwards and escalating/persisting as needed, same division of
+    responsibility as :func:`dispatch_ci_fix` itself.
+    """
+    entry.ci_fix_dispatches = max(0, entry.ci_fix_dispatches - 1)
+    entry.ci_fix_noop_streak += 1
+    entry.ci_fix_head_sha = ""
+
+
 def dispatch_ci_fix(
     entry: QueuedMerge,
     board: Board,
@@ -146,6 +199,14 @@ def dispatch_ci_fix(
     only a successful dispatch spends the budget, mirroring how
     ``ci_infra_reruns``/``ci_flaky_reruns`` are only bumped when their
     respective remedy actually fired.
+
+    #3011: a successful dispatch also snapshots ``entry.branch_head_sha``
+    into ``entry.ci_fix_head_sha`` so a later tick can tell whether this
+    leg actually moved the branch — see ``dispatch_was_noop``/
+    ``refund_noop_ci_fix``. Callers are expected to check
+    ``dispatch_was_noop(entry)`` and route through ``refund_noop_ci_fix``
+    BEFORE calling this function again for the same entry, so a worker
+    that pushed nothing doesn't silently spend a second real attempt.
     """
     if entry.ci_fix_dispatches >= MAX_CI_FIX_DISPATCHES:
         return None
@@ -181,6 +242,29 @@ def dispatch_ci_fix(
     # purpose as conflict_fix's SEMANTIC_FIX_TITLE_PREFIX.
     fix.issue_title = f"{CI_FIX_TITLE_PREFIX} {work.issue_title}"
 
+    # #3011: if a PRIOR dispatch's snapshot is still on the entry and the
+    # branch has since moved past it, that prior leg was a genuine attempt
+    # (not a no-op) — clear any no-op streak it may have left behind so it
+    # doesn't linger into this fresh attempt. (When the branch has NOT
+    # moved, the caller — `coord.commands.merge._dispatch_ci_fixes` — is
+    # expected to have already routed through `dispatch_was_noop`/
+    # `refund_noop_ci_fix` instead of reaching here; this is a harmless
+    # no-op in that case too, since `entry.ci_fix_noop_streak` would already
+    # be 0 for a caller that follows the intended sequencing.)
+    if (
+        entry.ci_fix_head_sha
+        and entry.branch_head_sha
+        and entry.ci_fix_head_sha != entry.branch_head_sha
+    ):
+        entry.ci_fix_noop_streak = 0
+
+    # Snapshot the current branch HEAD so a later tick can tell whether
+    # THIS dispatch's leg actually moved the branch (see
+    # `dispatch_was_noop`). `branch_head_sha` may itself be None (a probe
+    # failure) — falls back to "" so an unknown SHA never spuriously reads
+    # as "no ci-fix dispatch pending" on the next comparison.
+    entry.ci_fix_head_sha = entry.branch_head_sha or ""
+
     entry.ci_fix_dispatches += 1
 
     from coord.audit import record_audit  # noqa: PLC0415

{code_coordinator-0.5.324 → code_coordinator-0.5.325}/coord/commands/merge.py

@@ -569,13 +569,43 @@ def _dispatch_ci_fixes(events, config, *, dry_run: bool) -> None:
     is never reprocessed by a later ``process()`` call (it only acts on
     ``PENDING`` entries) so whichever caller sees the event first must also
     be the one to act on it.
+
+    #3011: before dispatching again, checks whether the entry's LAST ci-fix
+    leg was a no-op — the branch HEAD is unchanged from
+    ``entry.ci_fix_head_sha``, the snapshot ``dispatch_ci_fix`` took when it
+    dispatched that leg. A no-op means a fresh worker looked at this
+    failure and pushed no commit — evidence the failure isn't attributable
+    to this branch, not evidence a fix attempt failed — so it is refunded
+    (``coord.ci_fix.refund_noop_ci_fix``) rather than counted toward
+    ``MAX_CI_FIX_DISPATCHES``. Consecutive no-ops are bounded separately by
+    ``MAX_CI_FIX_NOOP_STREAK``, escalating to ``HUMAN_REQUIRED`` with a
+    distinct reason once THAT cap is hit — the goal being that a human is
+    called in because a worker genuinely tried and failed, or because the
+    failure is provably not this branch's, never because two correct
+    declines were miscounted as two failed attempts.
+
+    Before trusting ``dispatch_was_noop`` at all, first checks ``coord.
+    ci_fix._has_active_fix`` — the SHA comparison alone cannot distinguish
+    "the fix worker finished and declined to push" from "the fix worker is
+    still running and just hasn't pushed yet" (a dispatched leg stays
+    PENDING for its whole lifetime, so the very next tick after dispatch
+    would otherwise read as a noop). While a fix is still active, the entry
+    is left untouched — no refund, no streak bump, no new dispatch — for
+    the next tick to re-check.
     """
     ci_events = [ev for ev in events if ev.kind == "checks_failed"]
     if not ci_events or dry_run:
         return
 
     from coord.audit import record_audit  # noqa: PLC0415
-    from coord.ci_fix import MAX_CI_FIX_DISPATCHES, dispatch_ci_fix  # noqa: PLC0415
+    from coord.ci_fix import (  # noqa: PLC0415
+        MAX_CI_FIX_DISPATCHES,
+        MAX_CI_FIX_NOOP_STREAK,
+        _has_active_fix,
+        dispatch_ci_fix,
+        dispatch_was_noop,
+        refund_noop_ci_fix,
+    )
     from coord.merge_queue import HUMAN_REQUIRED  # noqa: PLC0415
     from coord.state import load_board, save_board  # noqa: PLC0415
 
@@ -585,6 +615,83 @@ def _dispatch_ci_fixes(events, config, *, dry_run: bool) -> None:
     dispatched_any = False
     for ev in ci_events:
         entry = ev.entry
+        # #3011 follow-up: `dispatch_was_noop` only compares the SHA
+        # snapshotted at dispatch time against the current branch head — it
+        # cannot tell "the fix worker finished and declined to push" apart
+        # from "the fix worker is still running and just hasn't pushed yet".
+        # A dispatched leg stays PENDING for its whole lifetime (`process()`
+        # never mutates entry.state for this path), so on the very next tick
+        # after dispatch the SHA still matches and `dispatch_was_noop` would
+        # read `True` for a leg that hasn't even had a chance to push.
+        # `_has_active_fix` is the same in-flight guard `dispatch_ci_fix`
+        # itself checks before dispatching — treat "still running" as "still
+        # pending" here too: skip the noop/refund accounting entirely and
+        # leave the entry untouched for the next tick, exactly like the
+        # generic "already in flight" decline below.
+        if _has_active_fix(fix_board, entry):
+            click.echo(
+                f"  {entry.repo_name} #{entry.issue_number}: "
+                "ci-fix already in flight — will re-check next run"
+            )
+            continue
+        if dispatch_was_noop(entry):
+            refund_noop_ci_fix(entry)
+            dispatched_any = True
+            if entry.ci_fix_noop_streak >= MAX_CI_FIX_NOOP_STREAK:
+                entry.state = HUMAN_REQUIRED
+                click.echo(
+                    f"  {entry.repo_name} #{entry.issue_number}: "
+                    f"{entry.ci_fix_noop_streak} consecutive ci-fix workers "
+                    "pushed no commit — not attributable to this branch, "
+                    "manual resolution required"
+                )
+                record_audit(
+                    tier="operational",
+                    category="merge",
+                    event_type="ci_fix_not_attributable",
+                    actor="daemon",
+                    summary=(
+                        f"ci-fix not attributable to branch: "
+                        f"{entry.repo_name}#{entry.issue_number} — "
+                        f"{entry.ci_fix_noop_streak} consecutive fix "
+                        "workers pushed no commit; manual resolution "
+                        "required"
+                    ),
+                    repo=entry.repo_name,
+                    issue=entry.issue_number,
+                    assignment_id=entry.assignment_id,
+                    details={
+                        "reason": "ci_fix_noop_streak",
+                        "ci_fix_noop_streak": entry.ci_fix_noop_streak,
+                        "error": entry.error,
+                    },
+                )
+            else:
+                click.echo(
+                    f"  {entry.repo_name} #{entry.issue_number}: "
+                    "ci-fix leg pushed no commit — refunding attempt "
+                    f"({entry.ci_fix_dispatches}/{MAX_CI_FIX_DISPATCHES} "
+                    "real attempts spent), will retry next run"
+                )
+                record_audit(
+                    tier="operational",
+                    category="merge",
+                    event_type="ci_fix_noop_refunded",
+                    actor="daemon",
+                    summary=(
+                        f"ci-fix leg was a no-op (branch head unchanged): "
+                        f"{entry.repo_name}#{entry.issue_number} — attempt "
+                        "refunded, not counted toward the retry cap"
+                    ),
+                    repo=entry.repo_name,
+                    issue=entry.issue_number,
+                    assignment_id=entry.assignment_id,
+                    details={
+                        "ci_fix_dispatches": entry.ci_fix_dispatches,
+                        "ci_fix_noop_streak": entry.ci_fix_noop_streak,
+                    },
+                )
+            continue
         fix = dispatch_ci_fix(entry, fix_board, config, checks_summary=ev.message)
         if fix is not None:
             click.echo(

{code_coordinator-0.5.324 → code_coordinator-0.5.325}/coord/db.py

@@ -594,7 +594,10 @@ def retry_on_locked(
 #
 # #2987: bumped 6 -> 7 for the two `portal_sync_state.relayed_answer_
 # watermark_*` columns appended to `_migrate_add_columns` below.
-_DB_SCHEMA_VERSION = 7
+#
+# #3011: bumped 7 -> 8 for the two `merge_queue.ci_fix_head_sha`/
+# `ci_fix_noop_streak` columns appended to `_migrate_add_columns` below.
+_DB_SCHEMA_VERSION = 8
 
 
 def _read_schema_version(conn: sqlite3.Connection) -> int:
@@ -797,7 +800,9 @@ _SCHEMA_SQL = """
             ci_flaky_reruns INTEGER NOT NULL DEFAULT 0,
             ci_flaky_pending TEXT NOT NULL DEFAULT '',
             ci_unreadable_reruns INTEGER NOT NULL DEFAULT 0,
-            ci_fix_dispatches INTEGER NOT NULL DEFAULT 0
+            ci_fix_dispatches INTEGER NOT NULL DEFAULT 0,
+            ci_fix_head_sha TEXT NOT NULL DEFAULT '',
+            ci_fix_noop_streak INTEGER NOT NULL DEFAULT 0
         );
 
         CREATE TABLE IF NOT EXISTS plans (
@@ -1719,6 +1724,23 @@ _MIGRATE_ADD_COLUMNS: list[str] = [
     # predating this migration, same as the column's own default for a
     # freshly-enqueued entry.
     "ALTER TABLE merge_queue ADD COLUMN ci_fix_dispatches INTEGER NOT NULL DEFAULT 0",
+    # #3011: durable snapshot of `QueuedMerge.branch_head_sha` taken at the
+    # moment `coord.ci_fix.dispatch_ci_fix` last dispatched a fix worker —
+    # unlike `branch_head_sha` itself (recomputed from GitHub every tick,
+    # never persisted), this survives to the NEXT tick so
+    # `coord.ci_fix.dispatch_was_noop` can tell whether that leg actually
+    # moved the branch. '' for every row predating this migration and for
+    # an entry with no ci-fix dispatch currently unaccounted-for.
+    "ALTER TABLE merge_queue ADD COLUMN ci_fix_head_sha TEXT NOT NULL DEFAULT ''",
+    # #3011: count of CONSECUTIVE ci-fix legs that completed with the branch
+    # HEAD unchanged (a worker correctly declined and pushed no commit) —
+    # kept separate from `ci_fix_dispatches` so a no-op leg can be refunded
+    # (doesn't count toward `MAX_CI_FIX_DISPATCHES`) while still bounding
+    # how many times that can happen before escalating to HUMAN_REQUIRED
+    # with a distinct "not attributable to this branch" reason — see
+    # `coord.ci_fix.MAX_CI_FIX_NOOP_STREAK`. 0 for every row predating this
+    # migration and for an entry that has never had a no-op ci-fix leg.
+    "ALTER TABLE merge_queue ADD COLUMN ci_fix_noop_streak INTEGER NOT NULL DEFAULT 0",
     # #2509 review fix: the verdict consumer's own read position into
     # `portal_events` — see the CREATE TABLE comment above for why it
     # cannot reuse the shared `handled_at` column. NULL (read as

{code_coordinator-0.5.324 → code_coordinator-0.5.325}/coord/merge_queue.py

@@ -3354,6 +3354,34 @@ class QueuedMerge:
     # stopped the loop; resetting it on an unrelated green tick would just
     # reopen a budget a still-broken PR could re-exhaust forever.
     ci_fix_dispatches: int = 0
+    # #3011: `branch_head_sha` (see the field above) captured at the moment
+    # `coord.ci_fix.dispatch_ci_fix` last dispatched a fix worker for this
+    # entry's confirmed-failure streak. Durable — unlike `branch_head_sha`
+    # itself, which is transient/recomputed every tick — so a later tick
+    # can compare "what was the branch at when we dispatched" against "what
+    # is the branch NOW" and tell a genuine attempt apart from a worker
+    # that pushed no commit. '' means no ci-fix dispatch is currently
+    # unaccounted-for: either none has ever been dispatched for this
+    # streak, or the last one was already resolved (a real attempt spent,
+    # or a no-op refunded — see `coord.ci_fix.dispatch_was_noop`/
+    # `refund_noop_ci_fix`). 0/'' for every row predating this column.
+    ci_fix_head_sha: str = ""
+    # #3011: count of CONSECUTIVE ci-fix legs that completed with the
+    # branch HEAD unchanged from `ci_fix_head_sha` — i.e. a fresh worker
+    # looked at this confirmed failure and correctly concluded it wasn't
+    # theirs to fix, pushing no commit. Kept separate from
+    # `ci_fix_dispatches`: a no-op leg is refunded there (does NOT count
+    # toward `coord.ci_fix.MAX_CI_FIX_DISPATCHES`) precisely so two correct
+    # declines don't masquerade as two failed genuine attempts. This
+    # counter is what actually bounds the no-op case — capped at
+    # `coord.ci_fix.MAX_CI_FIX_NOOP_STREAK`, at which point
+    # `coord.commands.merge._dispatch_ci_fixes` escalates to
+    # `HUMAN_REQUIRED` with a "not attributable to this branch" reason
+    # instead of the generic retry-cap one. Reset to 0 the moment a
+    # dispatch's OWN outcome shows the branch actually moved (a real
+    # attempt, not a no-op) — see `dispatch_ci_fix`. 0 for every row
+    # predating this column.
+    ci_fix_noop_streak: int = 0
 
 
 class GhOps(Protocol):
@@ -3712,6 +3740,10 @@ def load_queue() -> list[QueuedMerge]:
             # decodes to 0 — no CI-fix dispatches spent yet, same as a fresh
             # entry.
             ci_fix_dispatches=row["ci_fix_dispatches"] or 0,
+            # #3011: same NULL-to-''/0 decoding as the columns above, for
+            # rows predating these migrations.
+            ci_fix_head_sha=row["ci_fix_head_sha"] or "",
+            ci_fix_noop_streak=row["ci_fix_noop_streak"] or 0,
         )
         for row in rows
     ]
@@ -3733,8 +3765,9 @@ def save_queue(items: list[QueuedMerge]) -> None:
                         pr_number, pr_url, size, last_attempt, error, enqueued_at,
                         assignment_type, required_gates, ci_infra_reruns,
                         ci_stale_reruns, ci_flaky_reruns, ci_flaky_pending,
-                        ci_unreadable_reruns, ci_fix_dispatches
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                        ci_unreadable_reruns, ci_fix_dispatches,
+                        ci_fix_head_sha, ci_fix_noop_streak
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                     (
                         item.assignment_id, item.repo_name, item.repo_github,
                         item.branch, item.target_branch, item.issue_number,
@@ -3744,6 +3777,7 @@ def save_queue(items: list[QueuedMerge]) -> None:
                         item.ci_infra_reruns, item.ci_stale_reruns,
                         item.ci_flaky_reruns, item.ci_flaky_pending,
                         item.ci_unreadable_reruns, item.ci_fix_dispatches,
+                        item.ci_fix_head_sha, item.ci_fix_noop_streak,
                     ),
                 )