code-coordinator 0.5.171__tar.gz → 0.5.173__tar.gz

{code_coordinator-0.5.171 → code_coordinator-0.5.173}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.171",
+  "tag": "0.5.173",
   "distance": 0,
-  "node": "ga2bdfedae4a53fa1092820a1d38f8c7e925a87d7",
+  "node": "g3e3dcca5954ea1c1094878c1f81ed18e515e641f",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.171 → code_coordinator-0.5.173}/coord/client.py

@@ -510,6 +510,36 @@ def fetch_drive_queue_entry(
     return None
 
 
+def post_drive_queue(
+    svc: ServiceConfig,
+    action: str,
+    *,
+    timeout: float = _WRITE_TIMEOUT,
+    **fields,
+) -> dict:
+    """POST /drive-queue {action, ...fields} — the write side of
+    :func:`fetch_drive_queue` (#2429 DQW-2).
+
+    *fields* are forwarded verbatim as sibling keys next to ``action``,
+    e.g. ``post_drive_queue(svc, "move", repo_name="api", issue_number=1,
+    to_position=0)`` or ``post_drive_queue(svc, "update", repo_name="api",
+    issue_number=1, fields={"hold_state": "released"})`` — same body shape
+    ``coord/serve_app.py``'s ``post_drive_queue`` route (``action`` in
+    ``{enqueue, dequeue, update, move}``) already accepts, so a caller just
+    passes through whatever ``coord/dashboard/server.py``'s
+    ``/api/drive-queue/action`` handler decided to send. Returns the
+    decoded per-action response (``{"moved": bool}`` / ``{"deleted": bool}``
+    / ``{"updated": bool}`` / ``{"entry_id": int}``).
+
+    Unlike :func:`fetch_drive_queue` this is NOT fail-soft: it raises
+    ``httpx.HTTPError`` on transport/HTTP failure, the same posture as
+    :func:`post_cordon`/:func:`post_pause`/:func:`post_quiet_hours` — a
+    move/remove/unblock/resume that silently failed to reach the daemon
+    would leave the operator believing the queue changed when it didn't.
+    """
+    return post_record(svc, "/drive-queue", {"action": action, **fields}, timeout=timeout)
+
+
 def fetch_gate_a_approval(
     svc: ServiceConfig,
     repo_name: str,

{code_coordinator-0.5.171 → code_coordinator-0.5.173}/coord/dashboard/server.py

@@ -37,7 +37,13 @@ from coord.events import (
 from coord.board_service import read_board, write_board
 from coord.dao import _JSON_COLUMNS
 from coord.db import _ensure_schema
-from coord.drive_queue import DriveQueueSummary, entries_from_rows, summarize_drive_queue
+from coord.drive_queue import (
+    HOLD_FIRED,
+    STATE_BLOCKED,
+    DriveQueueSummary,
+    entries_from_rows,
+    summarize_drive_queue,
+)
 from coord.models import Assignment
 from coord.network import check_all, fetch_status
 from coord.openapi import (
@@ -441,6 +447,51 @@ def openapi_spec() -> dict:
                 },
             }
         },
+        "/api/drive-queue/action": {
+            "post": {
+                "summary": (
+                    "move/remove/unblock/resume a `coord drive` queue row "
+                    "(#2429 DQW-2)"
+                ),
+                "requestBody": {
+                    "required": True,
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {
+                                    "repo_name": {"type": "string"},
+                                    "issue_number": {"type": "integer"},
+                                    "action": {
+                                        "type": "string",
+                                        "enum": ["move", "remove", "unblock", "resume"],
+                                    },
+                                    "to_position": {
+                                        "type": "integer",
+                                        "description": "Required when action == 'move'.",
+                                    },
+                                },
+                                "required": ["repo_name", "issue_number", "action"],
+                            }
+                        }
+                    },
+                },
+                "responses": {
+                    "200": {
+                        "description": "OK",
+                        "content": {"application/json": {"schema": ok_response}},
+                    },
+                    "400": {
+                        "description": (
+                            "Missing/unknown field, missing to_position for "
+                            "'move', 'unblock' on a non-blocked row, or "
+                            "'resume' on a row whose gate hasn't fired"
+                        )
+                    },
+                    "404": {"description": "drive-queue entry not found"},
+                },
+            }
+        },
         "/api/approve": {
             "post": {
                 "summary": "Dispatch one or more proposals by id",
@@ -706,6 +757,72 @@ def build_app(
             return _fixture.drive_queue()
         return list_drive_queue()
 
+    def _drive_queue_write(action: str, **fields) -> dict:
+        """POST /drive-queue's ``{action, ...fields}`` shape (#2429 DQW-2).
+
+        Live mode only — callers check ``_fixture is not None`` themselves
+        (mirrors ``_write_board``, whose fixture no-op lives at the call
+        site in ``api_pipeline_action``, not inside ``_write_board`` itself).
+
+        Resolves daemon-vs-local by hand, the same decision
+        ``_read_board()``/``_write_board()`` make for the board, rather than
+        going through ``coord.state``'s own routed ``enqueue_drive_queue``/
+        ``dequeue_drive_queue``/``update_drive_queue_entry``/
+        ``move_drive_queue_entry`` wrappers — those already do this exact
+        dance internally, but routing here keeps the dashboard's thin-client
+        posture visible in this file instead of buried behind a
+        `coord.state` implementation detail.
+
+        Returns the daemon's per-action response dict verbatim
+        (``{"moved": bool}`` / ``{"deleted": bool}`` / ``{"updated": bool}``
+        / ``{"entry_id": int}``), whether it came from the wire or from the
+        matching local ``_*_local`` function directly — the same functions
+        ``coord/serve_app.py``'s own ``post_drive_queue`` route calls.
+        """
+        from coord import board_service
+
+        svc = board_service.resolve()
+        if svc is not None:
+            from coord.client import post_drive_queue
+
+            return post_drive_queue(svc, action, **fields)
+
+        from coord.state import (
+            _dequeue_drive_queue_local,
+            _enqueue_drive_queue_local,
+            _move_drive_queue_entry_local,
+            _update_drive_queue_entry_local,
+        )
+
+        if action == "dequeue":
+            return {
+                "deleted": _dequeue_drive_queue_local(
+                    fields["repo_name"], fields["issue_number"]
+                )
+            }
+        if action == "enqueue":
+            entry_id = _enqueue_drive_queue_local(
+                fields["repo_name"],
+                fields["issue_number"],
+                machine=fields.get("machine"),
+                after=fields.get("after") or [],
+                position=fields.get("position"),
+            )
+            return {"entry_id": entry_id}
+        if action == "update":
+            return {
+                "updated": _update_drive_queue_entry_local(
+                    fields["repo_name"], fields["issue_number"], **fields["fields"]
+                )
+            }
+        if action == "move":
+            return {
+                "moved": _move_drive_queue_entry_local(
+                    fields["repo_name"], fields["issue_number"], fields["to_position"]
+                )
+            }
+        raise ValueError(f"unknown drive-queue action: {action!r}")
+
     # ── Real-time event bus ────────────────────────────────────────────────
     event_source = EventSource()
 
@@ -1024,6 +1141,150 @@ def build_app(
         entries = [r for r in rows if r.get("repo_name") == repo] if repo else rows
         return JSONResponse({"entries": entries, "summary": asdict(summary)})
 
+    async def api_drive_queue_action(request: Request) -> JSONResponse:
+        """POST /api/drive-queue/action — move/remove/unblock/resume a
+        `coord drive` queue row (#2429 DQW-2).
+
+        Body: ``{"repo_name": "...", "issue_number": N, "action": "move" |
+        "remove" | "unblock" | "resume", ...}``. Response:
+        ``{"ok": bool, "error"?: str}`` — the same envelope
+        ``api_pipeline_action`` uses, not a new one.
+
+        All four actions ride the daemon's already-implemented
+        ``POST /drive-queue`` ops (``coord/serve_app.py``'s
+        ``post_drive_queue``) via ``_drive_queue_write`` — no new
+        queue-mutation logic here, just routing plus the two client-side
+        guards the TUI already enforces (``tui/src/app/drive_queue.rs``'s
+        ``queue_unblock_selected``/``queue_resume_selected``):
+
+        * ``move`` -> ``{action: "move", to_position}`` -> daemon op ``move``.
+        * ``remove`` -> daemon op ``dequeue``.
+        * ``unblock`` -> dequeue then re-enqueue with the row's ``machine``
+          preserved and ``after`` DROPPED — the exact recipe
+          ``dispatch_drive_queue_unblock`` (and its Python precedent,
+          ``coord/commands/drive_queue.py``'s ``_requeue_command``) uses: an
+          unsatisfiable pre-req is one of the two things that blocks a row,
+          so re-adding with the same ``after`` would just re-block it.
+          Refused with 400 on anything but a ``state == "blocked"`` row.
+        * ``resume`` -> daemon op ``update`` with
+          ``fields={hold_state: "released", hold_probes: 0}``. Refused with
+          400 on a row whose gate hasn't fired (``hold_state != "fired"``).
+
+        In fixture mode (#1538) every one of these is **recorded, not
+        executed** — mirrors ``api_pipeline_action``'s ``_fixture_action``.
+        """
+        try:
+            body = await request.json()
+        except ValueError:
+            return JSONResponse({"error": "invalid JSON"}, status_code=400)
+
+        repo_name = body.get("repo_name")
+        issue_number = body.get("issue_number")
+        action = body.get("action")
+        if not repo_name or issue_number is None or not action:
+            return JSONResponse(
+                {"error": "repo_name, issue_number and action are required"},
+                status_code=400,
+            )
+        try:
+            issue_number = int(issue_number)
+        except (TypeError, ValueError):
+            return JSONResponse({"error": "issue_number must be an int"}, status_code=400)
+
+        if action not in ("move", "remove", "unblock", "resume"):
+            return JSONResponse({"error": f"unknown action: {action!r}"}, status_code=400)
+
+        to_position = None
+        if action == "move":
+            try:
+                to_position = int(body.get("to_position"))
+            except (TypeError, ValueError):
+                return JSONResponse(
+                    {"error": "to_position must be an int"}, status_code=400
+                )
+
+        rows = _fixture.drive_queue() if _fixture is not None else _read_drive_queue()
+        entry = next(
+            (
+                r for r in rows
+                if r.get("repo_name") == repo_name
+                and int(r.get("issue_number", -1)) == issue_number
+            ),
+            None,
+        )
+        if entry is None:
+            return JSONResponse({"error": "drive-queue entry not found"}, status_code=404)
+
+        if action == "unblock" and entry.get("state") != STATE_BLOCKED:
+            return JSONResponse(
+                {"ok": False, "error": "only a blocked entry can be unblocked"},
+                status_code=400,
+            )
+        if action == "resume" and entry.get("hold_state") != HOLD_FIRED:
+            return JSONResponse(
+                {
+                    "ok": False,
+                    "error": "only an entry whose deploy gate has fired can be resumed",
+                },
+                status_code=400,
+            )
+
+        if _fixture is not None:
+            _fixture.record("/api/drive-queue/action", body, action=action)
+            return JSONResponse({"ok": True})
+
+        try:
+            if action == "move":
+                result = _drive_queue_write(
+                    "move",
+                    repo_name=repo_name,
+                    issue_number=issue_number,
+                    to_position=to_position,
+                )
+                ok = bool(result.get("moved"))
+            elif action == "remove":
+                result = _drive_queue_write(
+                    "dequeue", repo_name=repo_name, issue_number=issue_number
+                )
+                ok = bool(result.get("deleted"))
+            elif action == "unblock":
+                dequeue_result = _drive_queue_write(
+                    "dequeue", repo_name=repo_name, issue_number=issue_number
+                )
+                if bool(dequeue_result.get("deleted")):
+                    enqueue_result = _drive_queue_write(
+                        "enqueue",
+                        repo_name=repo_name,
+                        issue_number=issue_number,
+                        machine=entry.get("machine"),
+                        after=[],
+                    )
+                    ok = enqueue_result.get("entry_id") is not None
+                else:
+                    # The guard read above (``_read_drive_queue()``) is not
+                    # atomic with this write: the row can be removed/changed
+                    # by a concurrent dequeue/resume/daemon tick between the
+                    # two. If there was nothing to dequeue, there is nothing
+                    # to re-enqueue either — doing so anyway would silently
+                    # resurrect a row someone else legitimately removed.
+                    ok = False
+            else:  # resume
+                result = _drive_queue_write(
+                    "update",
+                    repo_name=repo_name,
+                    issue_number=issue_number,
+                    fields={"hold_state": "released", "hold_probes": 0},
+                )
+                ok = bool(result.get("updated"))
+        except Exception as exc:  # noqa: BLE001
+            return JSONResponse({"ok": False, "error": str(exc)}, status_code=500)
+
+        if not ok:
+            return JSONResponse(
+                {"ok": False, "error": "drive-queue entry not found"}, status_code=404
+            )
+        return JSONResponse({"ok": True})
+
     async def api_approve(request: Request) -> JSONResponse:
         from coord.dispatch import dispatch, post_briefing, compute_do_not_touch
         from coord.state import (
@@ -1944,6 +2205,7 @@ def build_app(
         Route("/api/sessions", api_sessions, methods=["GET"]),
         Route("/api/proposals", api_proposals, methods=["GET"]),
         Route("/api/drive-queue", api_drive_queue, methods=["GET"]),
+        Route("/api/drive-queue/action", api_drive_queue_action, methods=["POST"]),
         Route("/api/approve", api_approve, methods=["POST"]),
         Route("/api/reject", api_reject, methods=["POST"]),
         Route("/api/diff/{id}", api_diff, methods=["GET"]),

{code_coordinator-0.5.171 → code_coordinator-0.5.173}/coord/drive.py

@@ -114,6 +114,7 @@ from coord.failure_class import (
     plan_usage_limit_resume,
 )
 from coord.models import DELIVERABLE_ANALYSIS_LABEL, POLICY_REFUSAL_MARKER
+from coord.self_health import self_freshness
 from coord.usage_limits import PlanLimits, evaluate_usage_gate, get_plan_limits
 # Lost in the #1584-onto-#1590 rebase: _decide_review() calls this, but the
 # import lived in a hunk #1590 rewrote, so the merge came out textually clean
@@ -181,6 +182,20 @@ EXIT_DISPATCH_REFUSED = 5
 # vimcode#635 for the two live incidents (140 minutes and ~25 minutes of a
 # held queue slot, respectively, producing nothing).
 EXIT_DEAD_END = 6
+# #2443: a deliberate SELF-HEAL exit, not a failure — the drive loop noticed
+# it was stuck repeating the identical WAIT reason (see `_SELF_HEAL_WAIT_
+# STREAK`) while its OWN on-disk `coord` install had moved since this
+# session started. Python never reloads an already-imported module, so a
+# fix landing mid-run is otherwise invisible to a live session for as long
+# as `--deadline` allows — the claude-coordinator#2286 incident this closes
+# polled one unfetchable path every ~60s for 2+ hours after the fix was
+# already on disk. Distinct from EXIT_DISPATCH_REFUSED/EXIT_DEAD_END on
+# purpose: this condition is NOT permanent — relaunching is exactly the fix
+# — so it must fall through `coord.drive_queue._reconcile_running`'s
+# ordinary `retry` branch rather than either of those two `blocked`
+# branches, which is why nothing in drive_queue.py needs to special-case
+# this code at all.
+EXIT_SELF_STALE = 7
 
 
 class DriveError(Exception):
@@ -218,6 +233,31 @@ _CAPTURED_OUTPUT_LIMIT = 4000
 # never *tightened* for the environmental case.
 _ENVIRONMENTAL_WORK_RETRY_BUDGET = 5
 
+# #2443: how many CONSECUTIVE polls of the IDENTICAL `Action.label` to
+# tolerate before `Driver._loop` checks whether its own on-disk `coord`
+# install has moved since this session started. Below this, a same-label
+# repeat is indistinguishable from an ordinary slow-but-progressing wait (a
+# 10-20 minute test, a slow CI check) and checking would just be wasted
+# subprocess calls; at/above it, the check itself is a single local `git
+# rev-parse HEAD` (no network — see `coord.self_health.self_freshness
+# (fetch=False)`), cheap enough to run on every remaining poll of the
+# streak. At the default `--poll` of 60s this is ~10 minutes — fast enough
+# to matter against a multi-hour `--deadline`, slow enough that a routine
+# wait is never mistaken for the stuck case this exists to catch.
+_SELF_HEAL_WAIT_STREAK = 10
+
+
+def _current_self_head() -> str | None:
+    """Real default for `Driver.self_head_probe` (#2443): THIS process's own
+    on-disk `coord` install's current HEAD, or ``None`` when it can't be
+    determined (not a git checkout, unreadable HEAD — see
+    :func:`coord.self_health.self_freshness`). ``fetch=False``: this only
+    needs to notice code that has ALREADY landed locally (e.g. a prior `git
+    pull`), never reaches the network, and therefore never blocks the poll
+    loop on a slow/unreachable origin.
+    """
+    return self_freshness(fetch=False).head_sha
+
 
 def _bounded_tail(text: str, limit: int = _CAPTURED_OUTPUT_LIMIT) -> str:
     """*text*, or its last *limit* characters if longer — the tail, because
@@ -3685,8 +3725,19 @@ class Driver:
     # real `claude -p "/usage"` subprocess — mirrors *verifier*/*oracle_gate*
     # above. Defaults to the real (cached, ~60s) probe.
     usage_prober: Callable[[], PlanLimits] = get_plan_limits
+    # #2443: injected so tests can script a fake on-disk HEAD sequence
+    # without a real git checkout — same shape as *usage_prober* above.
+    # Defaults to the real, local-only (`fetch=False`) probe.
+    self_head_probe: Callable[[], str | None] = _current_self_head
 
     _run_log: Path | None = field(default=None, init=False, repr=False)
+    # #2443: this session's own on-disk `coord` HEAD, captured once by
+    # `_loop()` right as the poll loop begins — the baseline every later
+    # `_self_heal_drift_message` check compares against. `None` when it
+    # could not be determined (not a git checkout, unreadable HEAD), which
+    # keeps the self-heal check permanently a no-op for this run rather than
+    # ever comparing against a placeholder.
+    _start_head_sha: str | None = field(default=None, init=False, repr=False)
     # #1499: the terminating Action's own message, captured by `_loop()` right
     # before it returns — `run()` folds this into the `drive_exited` audit
     # summary/details so a non-exceptional terminal exit (e.g. `decide()`
@@ -3818,6 +3869,36 @@ class Driver:
         finally:
             lock.release()
 
+    # ── self-heal (#2443) ──────────────────────────────────────────────
+    def _self_heal_drift_message(self, label: str, streak: int) -> str | None:
+        """Has THIS process's own on-disk ``coord`` install moved since this
+        drive session started? ``None`` when it hasn't — or when freshness
+        can't be determined at all, which must never be misread as drift —
+        the overwhelmingly common case, so the caller just keeps waiting
+        exactly as before.
+
+        Only ever consulted once *label* (a WAIT ``Action``'s own reason)
+        has repeated *streak* times in a row (``_loop``'s
+        ``_SELF_HEAL_WAIT_STREAK`` gate) — this is specifically the #2286
+        shape: ``_decide_acceptance_author``'s "could not verify commits
+        (git fetch failed), retrying" arm returned the IDENTICAL label every
+        ~60s for 2+ hours after the fix that would have resolved it had
+        already landed on disk, because Python never reloads an
+        already-imported module. A stale in-memory `coord/drive.py` has no
+        way to notice that on its own — this is the bounded check that lets
+        it notice anyway.
+        """
+        current = self.self_head_probe()
+        if not current or not self._start_head_sha or current == self._start_head_sha:
+            return None
+        return (
+            "code changed underneath this session — on-disk coord moved "
+            f"from {self._start_head_sha[:8]} to {current[:8]} while stuck "
+            f"repeating the same wait {streak}x: {label!r}. Exiting "
+            "(EXIT_SELF_STALE) so coord drive-queue relaunches with "
+            f"current code instead of continuing to wait on stale logic (#2443)."
+        )
+
     def _post_escalation_comment(self, state: IssueState, message: str) -> None:
         """#1526: durably surface an escalation's reason onto the issue
         itself, not just this run's tmux pane and the ``coord escalate``
@@ -4061,6 +4142,15 @@ class Driver:
         # nudge) while guaranteeing a stalled stage is never more than one
         # `stall_secs` window away from a fresh check.
         last_nudge: float | None = None
+        # #2443: this session's own on-disk `coord` HEAD, captured once,
+        # right as the poll loop begins — see `_self_heal_drift_message`.
+        self._start_head_sha = self.self_head_probe()
+        # A distinct object (never equal to any real `Action.label`, empty
+        # string included) so the very first WAIT of the run always starts
+        # its streak at 1 rather than accidentally matching an unset
+        # sentinel.
+        last_wait_label: object = object()
+        same_wait_streak = 0
 
         while True:
             now = self.clock()
@@ -4155,6 +4245,36 @@ class Driver:
             for warning in action.warnings:
                 self.warn(warning)
 
+            # #2443: self-heal — see `_self_heal_drift_message`. Tracked off
+            # the Action's own `label`, NOT `fingerprint` above: a WAIT can
+            # (and, in the #2286 shape, does) repeat the identical reason
+            # poll after poll while the board fingerprint itself is static
+            # for the same underlying reason, so this is really the same
+            # signal — but keying directly on what the loop is ABOUT TO DO
+            # keeps this correct even for a WAIT arm whose label happens to
+            # be static text unrelated to fingerprint (e.g. "TEST: in
+            # progress on a capability-matched machine") without needing to
+            # reason about the two staying in lockstep. A non-WAIT action
+            # (RUN or EXIT) always resets the streak: dispatching something
+            # is progress by definition.
+            if action.kind == WAIT:
+                if action.label == last_wait_label:
+                    same_wait_streak += 1
+                else:
+                    last_wait_label = action.label
+                    same_wait_streak = 1
+                if same_wait_streak >= _SELF_HEAL_WAIT_STREAK:
+                    drift = self._self_heal_drift_message(
+                        action.label, same_wait_streak
+                    )
+                    if drift:
+                        self._last_exit_message = drift
+                        self.warn(drift)
+                        return EXIT_SELF_STALE
+            else:
+                last_wait_label = object()
+                same_wait_streak = 0
+
             if action.is_exit:
                 # #1499: capture the exit reason for the audit boundary before
                 # anything below can fail — the escalation write is explicitly

{code_coordinator-0.5.171 → code_coordinator-0.5.173}/coord/drive_queue.py

@@ -2558,12 +2558,34 @@ def _reconcile_running(
     dispatch_only = _dispatch_produced_nothing(
         entry, facts
     ) and not _is_merge_gate_block_reason(own_reason)
-    dispatch_note = (
-        " — no assignment was ever created for this run (#2273): likely an "
-        "infrastructure/dispatch-layer failure, not a code defect"
-        if dispatch_only
-        else ""
-    )
+    if not dispatch_only:
+        dispatch_note = ""
+    elif own_reason:
+        # A clean exit that still names no assignment — `own_reason` is
+        # present and already ruled out as a merge-gate block above, so the
+        # confident diagnosis is warranted: the drive itself narrated a
+        # death, and that death happened before `coord assign` ever ran.
+        dispatch_note = (
+            " — no assignment was ever created for this run (#2273): likely "
+            "an infrastructure/dispatch-layer failure, not a code defect"
+        )
+    else:
+        # #2442: a REAP, not a clean exit — the session was killed/crashed
+        # and left no `own_reason` text at all, so there is nothing for
+        # `_is_merge_gate_block_reason` to match against. That is not
+        # evidence the cause WAS a dispatch failure; it just means this
+        # branch has no way to rule one in or out. #2286 is the live
+        # escalation this produced: a session parked 2.3h inside a
+        # legitimate, already-diagnosed JIT-slice wait loop (#2426/#2437)
+        # looked, to `_dispatch_produced_nothing` alone, identical to one
+        # that never got dispatched — and got the same confident-but-wrong
+        # "infrastructure/dispatch-layer failure" wording #2424 already
+        # established was unreliable for the merge-gate case. Name the
+        # effect (no assignment) without asserting the unknowable cause.
+        dispatch_note = (
+            " — no assignment was ever created for this run (#2273), and "
+            "the session left no exit reason to diagnose why"
+        )
 
     # #2363: the "claimed success, wrote nothing" signature gets a WIDER
     # ceiling than every other death reason — see `EMPTY_BRANCH_MAX_ATTEMPTS`

{code_coordinator-0.5.171 → code_coordinator-0.5.173}/docs/OPERATING_GOTCHAS.md

@@ -44,6 +44,23 @@ doc's guess) and reports STALE with a commit count when it hasn't been pulled
 since a `coord/**` fix merged — the checkable gate for this row, the same way
 `coord diagnose --graph` is the checkable gate for graphify freshness.
 
+**#2443: a LIVE `coord drive` session now self-heals mid-run too.** #2436
+above only helps *before* a new launch — it says nothing about a session
+that was already running, with the OLD code loaded into memory, when the fix
+landed. Python never reloads an already-imported module, so a stale live
+session has no way to notice a fix on its own. `coord/drive.py`'s poll loop
+now watches its own `WAIT` actions: once the identical wait reason repeats
+`_SELF_HEAL_WAIT_STREAK` (10) polls in a row, it compares its own on-disk
+`coord` HEAD (captured once, at session start) against the current one
+(`coord.self_health.self_freshness(fetch=False)` — a local `git rev-parse
+HEAD`, no network). If the checkout moved underneath it, the session exits
+`EXIT_SELF_STALE` — a clean, non-permanent exit `coord drive-queue`'s
+ordinary retry/relaunch path picks straight back up under the current code —
+instead of continuing to poll dead logic for the rest of `--deadline`. This
+is the actual fix for the incident #2436 diagnosed after the fact: a live
+session on dellserver polled one unfetchable path every ~60s for 2+ hours
+after the #2319/#2320 fix that would have resolved it was already on disk.
+
 Not academic. #1394 (worker strands uncommitted work, then cleanup destroys it)
 sat merged-but-undeployed, and the very next dispatch — #1402 — hit the
 identical bug: **$3.44 and 10 minutes lost to something already fixed on