code-coordinator 0.5.220__tar.gz → 0.5.222__tar.gz

{code_coordinator-0.5.220 → code_coordinator-0.5.222}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.220",
+  "tag": "0.5.222",
   "distance": 0,
-  "node": "g3b354927ade8c4466bfcb6981c100e1c23f7c41c",
+  "node": "g0a0c97af031f26980c629e83e6ab895bfca5a393",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-22"

{code_coordinator-0.5.220 → code_coordinator-0.5.222}/coord/agent.py

@@ -1076,6 +1076,37 @@ def _commits_ahead(wt_path: Path, base: str) -> int | None:
     return None
 
 
+def _pushed_commits_ahead(repo_path: Path, base: str, branch: str) -> int | None:
+    """Commits ``origin/<branch>`` is ahead of *base*, checked from *repo_path*.
+
+    #2552: used by ``_reap``'s post-cleanup recheck, run AFTER
+    ``_cleanup_worktree`` has possibly already torn the worktree down — so,
+    unlike :func:`_commits_ahead`, this never touches the (possibly gone)
+    worktree directory. It reads from *repo_path* instead, which stays valid
+    for the whole reap: branch refs (including ``refs/remotes/origin/*``)
+    live in the shared ``.git`` directory, not per-worktree.
+
+    Deliberately compares against the REMOTE-tracking ref ``origin/<branch>``
+    rather than the local branch ref. A commit that only exists locally on
+    this one agent (the push in ``_rescue_uncommitted_work`` can fail, same
+    as any push) isn't yet something Test/Review/Merge — which all operate
+    against GitHub — can act on, so it must not flip a status that implies
+    "ready for the pipeline". Returns ``None`` when the remote ref can't be
+    resolved at all (no ``origin`` configured, or the push never landed) —
+    callers should treat that exactly like :func:`_commits_ahead`'s ``None``:
+    unknown, don't act on it.
+    """
+    for base_ref in (f"origin/{base}", base):
+        try:
+            raw = _git(
+                repo_path, "rev-list", "--count", f"{base_ref}..origin/{branch}"
+            )
+            return int(raw.strip())
+        except (_GitError, ValueError):
+            continue
+    return None
+
+
 _ISSUE_REF_RE = re.compile(r"#(\d+)")
 
 
@@ -8903,6 +8934,52 @@ class AgentServer:
         if assignment is not None:
             self._cleanup_worktree(assignment)
 
+        # #2552: `_cleanup_worktree` above may have just rescued a dirty
+        # worktree into a WIP commit and pushed it (`_rescue_uncommitted_
+        # work`) — AFTER the "0 commits ahead" status decision earlier in
+        # this method already ran. That decision (ADVISORY's `zero_commit_
+        # reason`, or REFUSED_POLICY's `policy_refusal_reason`) was computed
+        # from a branch that was genuinely empty at the moment of judgement;
+        # a rescue that landed a real, pushed commit on it makes the verdict
+        # stale by construction — reporting "nothing was authored" about a
+        # branch that, four log lines later, carries the worker's actual
+        # output. Recompute from `repo_path` (not the worktree, which may
+        # already be gone) whether the rescue's push actually reached
+        # origin, and correct the status when it did. Only ADVISORY/
+        # REFUSED_POLICY are ever reachable here (both are set exclusively
+        # in the `_ahead == 0` branch above, itself gated on `spec.type in
+        # _ZERO_COMMIT_TYPES`) — DONE, FAILED-for-other-reasons, CANCELLED
+        # etc. are untouched.
+        if (
+            assignment is not None
+            and assignment.status in (ADVISORY, REFUSED_POLICY)
+            and assignment.dirty_worktree_reason is not None
+        ):
+            _rescue_branch = assignment.branch or assignment.spec.target_branch
+            if _rescue_branch:
+                _rescue_repo_path = Path(assignment.spec.repo_path).expanduser()
+                _rescue_base = assignment.spec.branch or "main"
+                _post_ahead = _pushed_commits_ahead(
+                    _rescue_repo_path, _rescue_base, _rescue_branch
+                )
+                if _post_ahead is not None and _post_ahead > 0:
+                    _prior_status = assignment.status
+                    with self._lock:
+                        _live = self._assignments.get(assignment_id)
+                        if _live is not None and _live.status == _prior_status:
+                            _live.status = DONE
+                        if assignment is not _live:
+                            assignment.status = DONE
+                    self._persist()
+                    self._log_line(
+                        assignment,
+                        "# reap: post-cleanup recheck — "
+                        f"{_post_ahead} commit(s) pushed to origin/"
+                        f"{_rescue_branch} ahead of {_rescue_base} after "
+                        f"rescue (was {_prior_status!r}); status corrected "
+                        "to done (#2552)",
+                    )
+
     def _prune_completed_history(self) -> None:
         """Drop oldest terminal assignments over _COMPLETED_HISTORY_CAP (#452).
 

{code_coordinator-0.5.220 → code_coordinator-0.5.222}/coord/commands/drive_queue.py

@@ -1916,14 +1916,21 @@ def _fetch_live_ci_gate(
     gate ``coord merge --plan`` computes, taken live, right now, this tick
     (#2182).
 
-    The second dict (#2347) carries the reason text
+    The second dict (#2347, extended by #2556) carries the reason text
     :func:`coord.merge_queue.entry_gate_status` returned alongside each
-    still-blocked verdict — used ONLY to let :func:`coord.drive_queue.
-    plan_tick` rewrite a still-``parked`` entry's ``last_reason`` when the
-    fresh reading is specifically "GitHub unreachable"
-    (``is_ci_unreadable_reason``) and differs from what is currently stored;
-    see that function's ``live_ci_gate_reason`` parameter. Never consulted
-    to decide whether to resume — that remains the first dict's job alone.
+    still-blocked verdict, and is handed to :func:`coord.drive_queue.
+    plan_tick` as its ``live_ci_gate_reason`` parameter, which now gives it
+    a first, decisive job (#2556): when this text carries none of the
+    self-refreshing prefixes (``is_ci_pending_reason``/``is_ci_infra_reason``/
+    ``is_ci_flaky_reason``/``is_ci_unreadable_reason``), ``plan_tick``
+    overrides the first dict's still-blocked verdict into a resume — a
+    completed, *failing* CI run must never be indistinguishable from a slow
+    one. When it DOES carry one of those prefixes, this reason is used the
+    pre-#2556 way: only to rewrite a still-``parked`` entry's
+    ``last_reason`` when the fresh reading is specifically "GitHub
+    unreachable" (``is_ci_unreadable_reason``) and differs from what is
+    currently stored. See ``plan_tick``'s own ``live_ci_gate_reason``
+    docstring for the full account.
 
     THE GAP THIS CLOSES. On the daemon host — the only machine that ever
     runs this tick (``docs/AGENT_OPERATIONS.md``) — ``_fetch_board_view``

{code_coordinator-0.5.220 → code_coordinator-0.5.222}/coord/drive_queue.py

@@ -95,7 +95,7 @@ from coord.merge_queue import (
     PLAN_READY,
     is_ci_flaky_reason,
     is_ci_infra_reason,
-    is_ci_pending_reason,
+    is_ci_terminal_reason,
     is_ci_unreadable_reason,
     is_stale_smoke_reason,
 )
@@ -1121,12 +1121,7 @@ def build_board_view(
         # board-build time. `plan_reason` already carries it whenever it
         # applies; the live plan reading and a live `coord merge` attempt's
         # raw reading can never disagree about this one.
-        if not (
-            is_ci_pending_reason(reason)
-            or is_ci_infra_reason(reason)
-            or is_ci_flaky_reason(reason)
-            or is_ci_unreadable_reason(reason)
-        ):
+        if is_ci_terminal_reason(reason):
             continue
         # #2158: the same plan row that came back with NO reason of its own
         # also carries `ci_summary` — `summarize_counts` over the very checks
@@ -3180,18 +3175,33 @@ def plan_tick(
     the #2158 ceiling included — see
     :func:`coord.commands.drive_queue._fetch_live_ci_gate` for the shell
     side, which computes this ONLY for the bounded set of entries currently
-    `parked` on a CI reason, never the whole queue.
-
-    *live_ci_gate_reason* (#2347) is *live_ci_gate*'s companion: the reason
-    text the SAME fresh `entry_gate_status` call returned, for entries whose
-    reading is STILL blocked. Never used to decide whether to resume (that
-    remains `live_ci_gate`'s job) — only to rewrite a still-parked entry's
-    `last_reason` when the fresh reading is `CI_UNREADABLE_PREFIX`-shaped and
-    differs from what is currently stored, so `coord drive-queue list`/
-    `status` shows "GitHub could not be reached" the moment that becomes the
-    real cause, instead of silently keeping whatever reason the entry
-    happened to park on originally (which #1891/#1892/#2252's "still shut ⇒
-    no reconcile, no write" rule would otherwise leave frozen indefinitely —
+    `parked` on a CI reason, never the whole queue. `True` is NOT simply
+    "stay parked" any more (#2556): it means the fresh read isn't
+    ``PLAN_READY``, which is true both while checks are still genuinely in
+    flight (or mid one of their own bounded self-refreshing windows —
+    :func:`~coord.merge_queue.is_ci_pending_reason`/`is_ci_infra_reason`/
+    `is_ci_flaky_reason`/`is_ci_unreadable_reason`, stay parked) AND once
+    they have reported a TERMINAL verdict against the code (a plain "CI
+    failed: ..." reading with none of those prefixes — resume instead, so a
+    completed, failing run can never be indistinguishable from a slow one).
+    See *live_ci_gate_reason* just below, which is what makes that
+    distinction possible.
+
+    *live_ci_gate_reason* (#2347, extended by #2556) is *live_ci_gate*'s
+    companion: the reason text the SAME fresh `entry_gate_status` call
+    returned, for entries whose reading is STILL not `PLAN_READY`. #2556
+    gives it a first, decisive job: when this text carries none of the
+    self-refreshing prefixes (`is_ci_pending_reason`/`is_ci_infra_reason`/
+    `is_ci_flaky_reason`/`is_ci_unreadable_reason`), `live_ci_gate`'s `True`
+    is overridden into a resume — see `plan_tick`'s body. When it DOES carry
+    one of those prefixes, this reason is used the pre-#2556 way: only to
+    rewrite a still-parked entry's `last_reason` when the fresh reading is
+    `CI_UNREADABLE_PREFIX`-shaped and differs from what is currently stored,
+    so `coord drive-queue list`/`status` shows "GitHub could not be reached"
+    the moment that becomes the real cause, instead of silently keeping
+    whatever reason the entry happened to park on originally (which
+    #1891/#1892/#2252's "still shut ⇒ no reconcile, no write" rule would
+    otherwise leave frozen indefinitely —
     see the issue for the observed incident: a stale "CI running: ..."
     reason surviving a run of transient GitHub API 503s for most of
     `PARK_STALE_SECONDS` with no operator-visible signal of the real cause).
@@ -3524,6 +3534,60 @@ def plan_tick(
         live_override = (live_ci_gate or {}).get(entry.key)
         if live_override is not None:
             if live_override:
+                live_reason = (live_ci_gate_reason or {}).get(entry.key)
+                # #2556: `live_override=True` only means the FRESH read
+                # taken THIS tick isn't PLAN_READY — but "not ready" folds
+                # together two very different facts. One is "checks are
+                # genuinely still in flight" (`is_ci_pending_reason`), or one
+                # of the other self-refreshing, no-verdict-yet classes
+                # (`is_ci_infra_reason`'s verdictless failure mid its own
+                # bounded auto-rerun, `is_ci_flaky_reason`'s one-shot re-run
+                # to rule out a flake, `is_ci_unreadable_reason`'s bare
+                # GitHub-unreachable read, handled specially just below) —
+                # for all of these, "still shut ⇒ stay parked" (#1891/#2182)
+                # is exactly right, because there is no fresh verdict to act
+                # on yet. The other is "checks already reported a TERMINAL
+                # verdict against the code" — a plain "CI failed: ..."
+                # reading carrying none of those prefixes. This entry's own
+                # park message promises "the queue resumes it automatically
+                # once they do [report]" — a completed, failing run
+                # satisfies that in every ordinary reading, so staying
+                # parked on it forever (as every prior tick did — the #2158
+                # staleness ceiling never even runs, because it only applies
+                # when `live_override` is absent) is the bug: a red CI on a
+                # parked row was indistinguishable from a slow CI on one,
+                # unboundedly. Resume here exactly like the "reads READY"
+                # branch below (no attempt spent — a fresh GitHub read is
+                # not a failed launch attempt) so this falls straight into
+                # the SAME `waiting` walk, on the SAME tick; whatever
+                # relaunches `coord drive` finds the terminal CI reading and
+                # routes it through `_decide_merge`'s existing checks_failed
+                # handling (dispatch a fix, or block with a real reason) —
+                # exactly the path any other red-CI entry already takes.
+                if live_reason and is_ci_terminal_reason(live_reason):
+                    reason = (
+                        f"live re-check of {entry.key}'s gate this tick "
+                        f"reads a terminal, non-pending result ({live_reason}) "
+                        "— resuming from parked without spending an attempt "
+                        "so the normal checks_failed handling can take over "
+                        "(#2556)"
+                    )
+                    reconciles.append(
+                        Reconcile(
+                            entry.key,
+                            "resumed",
+                            reason,
+                            occupies=False,
+                            updates={
+                                "state": STATE_WAITING,
+                                "attempts": 0,
+                                "last_reason": reason,
+                            },
+                        )
+                    )
+                    states[entry.key] = STATE_WAITING
+                    effective_attempts[entry.key] = 0
+                    continue
                 # #2347: CONFIRMED still blocked — but if the FRESH reading
                 # taken THIS tick says the real cause is "GitHub could not
                 # be reached" (not a real CI verdict) and that differs from
@@ -3535,7 +3599,6 @@ def plan_tick(
                 # rule does for every other still-blocked reading. State
                 # stays `parked`, no attempt spent — this changes only what
                 # the operator is told, never the decision.
-                live_reason = (live_ci_gate_reason or {}).get(entry.key)
                 if (
                     live_reason
                     and is_ci_unreadable_reason(live_reason)

{code_coordinator-0.5.220 → code_coordinator-0.5.222}/coord/merge_queue.py

@@ -1525,6 +1525,41 @@ def is_ci_flaky_reason(reason: str | None) -> bool:
     return (reason or "").startswith(CI_FLAKY_PREFIX)
 
 
+def is_ci_terminal_reason(reason: str | None) -> bool:
+    """True when *reason* is a CONCLUDED CI verdict — a plain "checks
+    failed: ..." (or similarly final) reading carrying none of the four
+    self-refreshing, no-verdict-yet prefixes above (#2556).
+
+    ``not is_ci_terminal_reason(r)`` is exactly "this reading is still
+    genuinely in flight, or mid one of its own bounded self-refreshing
+    windows, and answers nothing yet about whether the code is any good" —
+    :func:`is_ci_pending_reason` (checks exist and are still running),
+    :func:`is_ci_infra_reason` (a check completed but said nothing about the
+    code, mid its own auto-rerun), :func:`is_ci_flaky_reason` (a real
+    verdict, but only observed once, mid its one-shot re-run to rule out a
+    flake), or :func:`is_ci_unreadable_reason` (GitHub could not even be
+    asked the question). Anything else — most commonly a plain "checks
+    failed: ..." with none of those prefixes — is terminal: a concluded
+    result the queue can act on now, never indistinguishable from a slow or
+    still-resolving one.
+
+    The single implementation of this classification. Two call sites used to
+    each spell out the identical four-way disjunction inline — a `parked`
+    entry's "is this still self-refreshing?" gate in this module's own
+    `process()`, and `coord.drive_queue.plan_tick`'s #2556 resume-on-
+    terminal-failure branch — which is exactly the "two independent
+    implementations that agree today are a split-brain waiting to happen"
+    shape this repo's own review checklist warns against. Call this instead
+    of re-deriving the disjunction at a new call site.
+    """
+    return not (
+        is_ci_pending_reason(reason)
+        or is_ci_infra_reason(reason)
+        or is_ci_flaky_reason(reason)
+        or is_ci_unreadable_reason(reason)
+    )
+
+
 # #1892: auto-reruns `process()` will trigger for a single entry's verdictless
 # CI failure (via `CiStore.rerun_for_pr`) before giving up and parking it for
 # a human instead of the queue's own #1891 machinery. A workflow genuinely

{code_coordinator-0.5.220 → code_coordinator-0.5.222}/coord/test_author.py

@@ -579,6 +579,36 @@ def dispatch_test_author(
                 "work, open a fresh branch by hand — do not retry as-is."
             )
 
+    # #2552: a retried JIT dispatch re-derives this SAME branch for the same
+    # (tracking_issue, issue_number) pair, and `_setup_worktree` already
+    # resumes from `origin/<branch>` at the git level whenever it exists —
+    # the #389/#460 continuation-branch logic checks out the remote tip
+    # instead of branching fresh. So a retried worker's worktree is NOT
+    # empty when the branch already carries real commits (e.g. a #1394
+    # WIP-rescue commit left behind by a killed prior attempt) — but the
+    # briefing built above reads identically whether the branch is fresh or
+    # already has content, so nothing told the worker to check what's
+    # already there before writing more, and a worker that doesn't think to
+    # `git log` first can end up re-authoring over its own prior output.
+    # `branch_commits_ahead` asks GitHub directly (no local checkout
+    # required — the coordinator dispatching this may not have one); `None`
+    # (lookup failed) is left silent rather than asserted either way, same
+    # fail-quiet posture as every other best-effort GitHub read in this
+    # function.
+    _resume_ahead = github_ops.branch_commits_ahead(
+        repo_cfg.github, repo_cfg.default_branch or "main", branch
+    )
+    if _resume_ahead:
+        briefing += (
+            "\n\n---\nRESUMING: this branch already has "
+            f"{_resume_ahead} commit(s) on it ahead of "
+            f"{repo_cfg.default_branch or 'main'} — likely unfinished or "
+            "unverified work from an interrupted prior session (possibly a "
+            "coordinator WIP-rescue commit — see #1394). Run `git log` and "
+            "read what's already there FIRST. Continue/complete/verify it "
+            "rather than re-authoring from scratch (#2552)."
+        )
+
     deny_commands = test_author_deny_commands(config, repo_name)
 
     # #2549: this was the only dispatcher on the fleet that never sent

{code_coordinator-0.5.220 → code_coordinator-0.5.222}/tests/test_agent.py

@@ -3938,6 +3938,99 @@ def test_reap_review_type_gets_no_stash_diagnostic(tmp_path: Path) -> None:
     server.shutdown()
 
 
+def _init_repo_with_remote(path: Path) -> Path:
+    """Like `_init_repo`, but with a real (local, bare) `origin` configured
+    and `main` already pushed.
+
+    #2552's post-cleanup recheck (`AgentServer._pushed_commits_ahead`)
+    deliberately reads the REMOTE-tracking ref (`origin/<branch>`), not the
+    local branch — a rescue commit that never reached origin must not flip
+    status. `_init_repo` (no remote) can't exercise that path at all, since
+    `origin/<branch>` never exists there.
+    """
+    remote = path.parent / f"{path.name}-remote.git"
+    subprocess.run(
+        ["git", "init", "--bare", "-b", "main", str(remote)],
+        check=True, capture_output=True,
+    )
+    _init_repo(path)
+    subprocess.run(
+        ["git", "remote", "add", "origin", str(remote)],
+        cwd=str(path), check=True, capture_output=True,
+    )
+    subprocess.run(
+        ["git", "push", "-u", "origin", "main"],
+        cwd=str(path), check=True, capture_output=True,
+    )
+    return path
+
+
+def test_reap_status_reflects_post_rescue_branch_state(tmp_path: Path) -> None:
+    """#2552: a rescued WIP commit that reaches origin must correct the
+    pre-cleanup zero-commit verdict instead of leaving it standing.
+
+    Reported bug: `_reap` measures "0 commits ahead of main" (true at that
+    instant, since the worker left a tracked-file edit uncommitted) and sets
+    ADVISORY with `zero_commit_reason` — BEFORE `_cleanup_worktree` runs.
+    Cleanup then rescues the dirty worktree into a `WIP [coord-rescue]`
+    commit and pushes it (`_rescue_uncommitted_work`), landing a real commit
+    on the very branch the ADVISORY verdict was judged empty one step
+    earlier. Nothing ever revisited the verdict, so a successful #1394
+    rescue was always scored as "nothing was authored".
+
+    Drives the real `_reap` path end to end (`assign()`/`wait_for()`,
+    exactly like the neighboring stash-diagnostic tests above) rather than
+    re-implementing the ordering inline, so a regression in the actual
+    `_reap`/`_cleanup_worktree` sequence is what this test would catch.
+    """
+    repo = _init_repo_with_remote(tmp_path / "repo")
+    server = _server(
+        tmp_path,
+        argv=["/bin/sh", "-c", "echo dirty >> README; exit 0"],
+        repo_path=repo,
+    )
+
+    a = server.assign(_spec(repo))
+    final = server.wait_for(a.id, timeout=15)
+
+    assert final.status == DONE
+    assert final.dirty_worktree_reason is not None
+    assert "coord-rescue" in final.dirty_worktree_reason
+    assert "UNVERIFIED" in final.dirty_worktree_reason
+    server.shutdown()
+
+
+def test_reap_stays_advisory_when_rescue_commit_never_reaches_origin(
+    tmp_path: Path,
+) -> None:
+    """#2552 control: a rescue commit that stays LOCAL ONLY must NOT flip
+    status to done.
+
+    Same dirty-worktree shape as the test above, but the repo has no
+    `origin` at all — the WIP-rescue push has nothing to push to, so the
+    commit only ever exists on this one agent. Test/Review/Merge all operate
+    against GitHub; a branch nobody but this agent can see is not "ready for
+    the pipeline", so the post-cleanup recheck must leave the pre-existing
+    ADVISORY verdict alone (the `dirty_worktree_reason` still records that
+    real work exists — see `_record_dirty_worktree` — just not that it is
+    live anywhere the pipeline can consume it).
+    """
+    repo = _init_repo(tmp_path / "repo")  # no `origin` remote configured
+    server = _server(
+        tmp_path,
+        argv=["/bin/sh", "-c", "echo dirty >> README; exit 0"],
+        repo_path=repo,
+    )
+
+    a = server.assign(_spec(repo))
+    final = server.wait_for(a.id, timeout=15)
+
+    assert final.status == ADVISORY
+    assert final.dirty_worktree_reason is not None
+    assert "coord-rescue" in final.dirty_worktree_reason
+    server.shutdown()
+
+
 def test_sanitize_branch_replaces_slashes(tmp_path: Path) -> None:
     """_sanitize_branch should replace slashes with dashes."""
     from coord.agent import _sanitize_branch

{code_coordinator-0.5.220 → code_coordinator-0.5.222}/tests/test_cli_drive_queue.py

@@ -1835,6 +1835,15 @@ def _green_check(name: str = "test (3.12)"):
     )
 
 
+def _failed_check(name: str = "test (3.12)"):
+    from coord.ci_store import CheckRun
+
+    return CheckRun(
+        name=name, status="completed", conclusion="failure",
+        url="", run_id="1", started_at=100.0, completed_at=160.0,
+    )
+
+
 def _running_check(name: str = "test (3.12)"):
     from coord.ci_store import CheckRun
 
@@ -1914,6 +1923,45 @@ def test_a_parked_entry_with_ci_still_genuinely_running_stays_parked(
     assert "1 parked" in cli_no_gates("status").output
 
 
+def test_a_parked_entry_resumes_once_ci_reports_a_confirmed_failure(
+    cli_no_gates, seed, launches, coord_db, live_ci_backend,
+):
+    """#2556, reproduced rather than injected.
+
+    coord-portal#131 (live, 2026-08-22): a row parked on "CI running: e2e
+    smoke (playwright)" never noticed the check it was watching completed as
+    FAILURE — it stayed `parked`, with `last_reason` still reading "CI
+    running: ..." over an hour after the run finished. The #2182 live
+    re-check correctly asks GitHub again every tick, but collapsed "still
+    running" and "confirmed failed" into the same "stay parked" branch,
+    because both merely fail to read `PLAN_READY`. A completed run — even a
+    red one — satisfies this entry's own park promise ("the queue resumes it
+    automatically once they do [report]"); it must resume and let the normal
+    `waiting`/launch path route the failure through `coord drive`'s existing
+    checks_failed handling, exactly like any other red-CI entry.
+    """
+    _park_with_pr(cli_no_gates, seed, coord_db)
+    assert "CI running" in (queued(2159)["last_reason"] or "")
+
+    live_ci_backend([_failed_check()])
+
+    result = cli_no_gates("tick")
+    assert result.exit_code == 0, result.output
+    # The resume itself is visible in this tick's own reconcile line — the
+    # entry then launches in the SAME tick (like the #2182 green-check case
+    # above), which clears `last_reason` to "" on success, so the CI-failed
+    # reading is only observable in the tick's rendered output, not the
+    # post-launch row.
+    assert "resumed" in result.output
+    assert "CI failed" in result.output
+    entry = queued(2159)
+    assert entry["state"] != "parked", entry  # no longer wedged
+    assert entry["attempts"] == 0  # #1891/#2273: still free — no attempt spent
+    assert len(launches) == 2, launches  # resumed straight into a fresh launch
+
+    assert "parked" not in cli_no_gates("status").output
+
+
 def test_a_parked_entrys_reason_is_corrected_when_github_is_unreachable(
     cli_no_gates, seed, launches, coord_db, live_ci_backend,
 ):

{code_coordinator-0.5.220 → code_coordinator-0.5.222}/tests/test_drive.py

@@ -4662,24 +4662,33 @@ def driver_factory(tmp_path, monkeypatch, capsys):
     monkeypatch.setenv("TMPDIR", str(tmp_path))
     monkeypatch.setattr("coord.drive_state.scratch_dir", lambda: tmp_path)
     monkeypatch.setattr("coord.drive.scratch_dir", lambda: tmp_path)
-    # A per-test notify.lock, so a Driver test's `--notify` nudge never
-    # contends with the OPERATOR'S real ~/.coord/notify.lock — the same
-    # convention `tests/test_notify_drain.py`'s `lock_path` fixture already
-    # documents ("so tests never touch the real ~/.coord one").
+    # #2170-class isolation, fixture-wide: `run_notify()` takes a REAL flock
+    # on `notify_lock_path()` (`Path.home()/".coord"/"notify.lock"`, resolved
+    # at call time) whenever `DriveOptions(notify=True)` is in play. Any
+    # driver test in this module can turn that on, and without isolating it
+    # the lock contends with whatever else on the host legitimately holds it
+    # — on a machine that actually runs the fleet, `coord-notify.timer`
+    # (5-minute cadence) and the board daemon's own drain both hold it for
+    # the length of a full notify pass. The test then burns up to the full
+    # 5-minute `timeout=300` per acquire, logs "could not take
+    # ~/.coord/notify.lock within 5m — skipping nudge", and fails with an
+    # empty call list. That is a race with whatever else is running on the
+    # machine, not a signal about the code under test — exactly the class
+    # `tests/test_ambient_home_isolation.py` and the `populated-home` CI job
+    # exist to keep out.
     #
-    # Without this, `Driver.run_notify()` takes the live lock for real: on
-    # any host that actually runs the fleet, `coord-notify.timer` (5-minute
-    # cadence) and the board daemon's own drain both hold it for the length
-    # of a full notify pass, so every nudge assertion here
-    # (`test_notify_nudges_coord_notify_under_the_shared_lock` and the two
-    # #1593 stall-nudge tests) was one unlucky overlap away from seeing
-    # LockBusy, logging "could not take ~/.coord/notify.lock within 5m —
-    # skipping nudge", and failing with an empty call list after a 5-minute
-    # stall. That is a race with whatever else is running on the machine,
-    # not a signal about the code under test.
-    monkeypatch.setattr(
-        "coord.drive.notify_lock_path", lambda: tmp_path / "notify.lock"
-    )
+    # Redirecting $HOME is the whole mechanism, and it subsumes the earlier
+    # #2536 fix (which pinned `coord.drive.notify_lock_path` at
+    # `tmp_path/"notify.lock"` instead): `notify_lock_path()` resolves
+    # `Path.home()` at call time, so the lock lands at
+    # `tmp_path/".coord"/"notify.lock"` either way — but $HOME also covers
+    # everything *else* in the driver that reaches for `~/.coord`, and it
+    # needs no upkeep as call sites move. Deliberately NOT belt-and-braces:
+    # re-pinning `notify_lock_path` on top of this would move the lock back
+    # out of the redirected $HOME and silently defeat
+    # `test_notify_nudges_coord_notify_under_the_shared_lock`, whose whole
+    # job is to assert the redirection took.
+    monkeypatch.setenv("HOME", str(tmp_path))
 
     def make(
         payloads, *, opts=None, verifier=None, config=None, oracle_gate=None,
@@ -5725,6 +5734,15 @@ def test_notify_is_off_by_default(driver_factory, monkeypatch):
 
 
 def test_notify_nudges_coord_notify_under_the_shared_lock(driver_factory, tmp_path):
+    # #2170-class isolation: `run_notify()` takes a REAL flock on
+    # `notify_lock_path()` — i.e. `Path.home()/".coord"/"notify.lock"`,
+    # resolved at call time. `driver_factory` redirects $HOME to `tmp_path`
+    # fixture-wide (see its definition) precisely so this doesn't contend
+    # with whatever else on the host legitimately holds that lock (a live
+    # `coord notify` / `run_drain` on a daemon host, or simply another
+    # pytest worker running the sibling drain tests) and burn the full
+    # 5-minute `timeout=300` before failing with an empty `seen`. This
+    # assertion just confirms the redirection actually took.
     driver = driver_factory(
         [board(status="merged")], opts=DriveOptions(machine="precision", notify=True)
     )
@@ -5732,6 +5750,8 @@ def test_notify_nudges_coord_notify_under_the_shared_lock(driver_factory, tmp_pa
     driver.run_coord = lambda args, **kw: seen.append(args) or 0  # type: ignore[assignment]
     driver.run_notify()
     assert seen == [("notify",)]
+    # The lock really was taken under the redirected $HOME, not the host's.
+    assert (tmp_path / ".coord" / "notify.lock").exists()
 
 
 def test_stalled_stage_gets_re_nudged_on_every_stall_window(driver_factory, capsys):