code-coordinator 0.5.642__tar.gz → 0.5.644__tar.gz

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.642
+Version: 0.5.644
 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.644/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.644",
+  "distance": 0,
+  "node": "g634dd923ef760cbdf3bb66239d0470e25f7af742",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-16"
+}

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/coord/agent.py

@@ -2137,6 +2137,18 @@ def _sanitize_branch(branch: str) -> str:
 # worktree.  The captured group is the conflicting worktree's path.
 _WT_COLLISION_RE = re.compile(r"already used by worktree at '([^']+)'")
 
+# #3704: the *other* shape git raises for a branch-name collision — "fatal: a
+# branch named '<branch>' already exists".  `git worktree add -b <branch> ...`
+# raises this whenever the branch ref exists at all, whether or not it is
+# currently checked out anywhere — unlike `_WT_COLLISION_RE` above, which only
+# fires when something has it checked out.  A retried smoke-fix/test-fix
+# dispatch picks the same deterministic branch name as its failed predecessor;
+# if that predecessor's worktree was torn down without the branch itself being
+# deleted (`git worktree remove` never deletes the branch), the retry hits
+# this exact message and — before this fix — crashed instead of recovering.
+# The captured group is the branch name, not a path.
+_WT_BRANCH_EXISTS_RE = re.compile(r"a branch named '([^']+)' already exists")
+
 # Build-intermediate file suffixes that are never useful stash artifacts.
 # Cargo produces dozens of *.rcgu.o incremental-codegen objects per build
 # (e.g. `tui_selection-<hash>.<unit>.rcgu.o`) — Path.suffix on these returns
@@ -2765,6 +2777,29 @@ def _parse_worktree_porcelain(output: str) -> list[dict[str, str]]:
     return worktrees
 
 
+def _worktree_path_for_branch(repo_path: Path, branch_name: str) -> str | None:
+    """Path of the worktree currently holding *branch_name*, or ``None`` (#3704).
+
+    Git's "a branch named '<branch>' already exists" error (matched by
+    :data:`_WT_BRANCH_EXISTS_RE`) names the *branch*, not a worktree path —
+    unlike :data:`_WT_COLLISION_RE`'s "already used by worktree at '<path>'",
+    which hands :func:`_git_worktree_add` the path directly. This resolves the
+    same thing by scanning ``git worktree list --porcelain`` for an entry
+    whose branch matches. ``None`` means the branch ref exists but nothing has
+    it checked out anywhere — the common case for a retried dispatch whose
+    prior attempt's worktree was already cleaned up without the branch itself
+    being deleted.
+    """
+    try:
+        output = _git(repo_path, "worktree", "list", "--porcelain")
+    except _GitError:
+        return None
+    for wt in _parse_worktree_porcelain(output):
+        if wt.get("branch", "") == branch_name:
+            return wt.get("worktree")
+    return None
+
+
 def _is_same_path(candidate: str, resolved_target: Path) -> bool:
     """True when *candidate* points at the same directory as *resolved_target*.
 
@@ -3443,15 +3478,83 @@ def _git_worktree_add(
     *default_branch* is deliberately optional and the remedy is skipped
     without it: the helper has to know where to put the base, and a caller
     that cannot say keeps #1693's behaviour unchanged (refuse and re-raise).
+
+    #3704: git raises a *second* message shape for a branch-name collision —
+    "a branch named '<branch>' already exists" — whenever the ``-b <branch>``
+    form is used and the branch ref exists at all, checked out anywhere or
+    not.  A retried smoke-fix/test-fix dispatch deterministically picks the
+    same branch name as its failed predecessor, so if that predecessor's
+    worktree was already torn down (leaving a stale branch ref behind — ``git
+    worktree remove`` never deletes the branch), the retry hits this exact
+    message.  It is resolved the same way: look up where the branch is
+    checked out (if anywhere) via :func:`_worktree_path_for_branch` and fall
+    into the identical main-checkout-restore / linked-worktree-evict logic
+    below.  Nothing checked out anywhere is the common case — the stale ref
+    is just deleted and the add is retried once.
     """
+    # #3704: set only when the failure was "a branch named '<branch>' already
+    # exists" — the ``-b`` form's signal that it wants a brand-new branch at
+    # this name, never that it wants to reuse the existing one.  Whatever
+    # clears the collision below (restoring the base checkout, evicting a
+    # linked worktree) only moves things *off* the branch; it never deletes
+    # the ref, so without this the retry would hit the identical error again.
+    pending_branch_delete: str | None = None
+
+    def _delete_pending_branch() -> None:
+        """Delete *pending_branch_delete*, if set, once its checkout is clear.
+
+        Best-effort: a failure here just means the retry below hits the same
+        "already exists" error and surfaces it as a real ``_GitError`` —
+        exactly like every other irrecoverable case in this function.
+        """
+        if pending_branch_delete is None:
+            return
+        try:
+            _git(repo_path, "branch", "-D", pending_branch_delete)
+        except _GitError:
+            pass
+
     try:
         _git(repo_path, "worktree", "add", *add_args)
         return
     except _GitError as exc:
         m = _WT_COLLISION_RE.search(str(exc))
-        if not m:
-            raise  # unrelated error — propagate unchanged
-        conflicting_path = m.group(1)
+        if m:
+            conflicting_path = m.group(1)
+        else:
+            m = _WT_BRANCH_EXISTS_RE.search(str(exc))
+            if not m:
+                raise  # unrelated error — propagate unchanged
+            branch_name = m.group(1)
+            conflicting_path = _worktree_path_for_branch(repo_path, branch_name)
+            if conflicting_path is None:
+                # #3704: the branch ref exists but nothing has it checked out
+                # — e.g. a prior attempt's worktree was already cleaned up
+                # without deleting the branch itself.  Safe to delete the
+                # stale ref outright and retry once.
+                if log_path:
+                    _append_log_line(
+                        log_path,
+                        f"# worktree-add: branch {branch_name!r} already "
+                        f"exists but is not checked out in any worktree "
+                        f"(#3704) — deleting the stale ref and retrying\n",
+                    )
+                try:
+                    _git(repo_path, "branch", "-D", branch_name)
+                except _GitError as delete_exc:
+                    raise _GitError(
+                        f"cannot create a worktree for branch "
+                        f"{branch_name!r}: it already exists and could not "
+                        f"be deleted ({delete_exc})"
+                    ) from exc
+                # One retry only — raises if it fails again.
+                _git(repo_path, "worktree", "add", *add_args)
+                return
+            # Checked out somewhere — fall into the main-checkout-restore /
+            # linked-worktree-evict logic below, which clears the *checkout*.
+            # The branch ref itself still needs deleting once that's done,
+            # since the whole point of `-b` is a fresh branch (#3704).
+            pending_branch_delete = branch_name
         original = exc
 
     # #1693: refuse before removing.  The base checkout is not a recoverable
@@ -3485,6 +3588,12 @@ def _git_worktree_add(
                             f"collision (#1694). Nothing was deleted. "
                             f"Retrying the add once.\n",
                         )
+                    # #3704: if the original error was "branch already
+                    # exists" (not the older "already used by worktree"),
+                    # the branch ref itself is still there even though the
+                    # base checkout just moved off it — delete it now that
+                    # nothing has it checked out.
+                    _delete_pending_branch()
                     # One retry only — raises if it fails again.
                     _git(repo_path, "worktree", "add", *add_args)
                     return
@@ -3519,6 +3628,10 @@ def _git_worktree_add(
         # to be removable here.  Anything else is refused and the retry below
         # raises the real error.
     )
+    # #3704: as above — a "branch already exists" origin means the branch
+    # ref outlives the worktree that just got evicted, and needs its own
+    # deletion before the retry can succeed.
+    _delete_pending_branch()
     # One retry only — raises if it fails again.
     _git(repo_path, "worktree", "add", *add_args)
 

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/coord/diagnose.py

@@ -1441,10 +1441,19 @@ def _recover_test(
             from coord.reconcile import (  # noqa: PLC0415
                 propagate_smoke_terminal_failure,
             )
-
+            from coord.state import load_assignment_exit_code  # noqa: PLC0415
+
+            # #3705: the board projection carries no `exit_code`, so read the
+            # smoke child's recorded exit status directly — without it every
+            # reason-less failure would reclassify as a silent #1605 death and
+            # earn a bounded retry instead of a work failure.  A `cancelled`
+            # row is the operator's own `coord stop`, whose exit status is the
+            # kill signal rather than a verdict on the code under test.
             propagate_smoke_terminal_failure(
                 parent_assignment_id=latest.assignment_id,
                 failure_reason=smoke.failure_reason,
+                operator_cancelled=(smoke.status or "") == "cancelled",
+                exit_code=load_assignment_exit_code(smoke.assignment_id),
             )
             res.actions_taken.append(
                 f"resolved stuck test_state='running' from smoke child "

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/coord/failure_class.py

@@ -98,6 +98,11 @@ KIND_NETWORK = "network"
 #: diagnosis of a lost Test-stage leg, never a verdict about the code
 #: under test.
 KIND_INFRA = "infra"
+#: #3705: a Test-stage worker died with literally no `failure_reason` to
+#: classify — not "classified as work because the text didn't match any
+#: environmental pattern" (that case has real diagnostic text and stays
+#: `KIND_WORK`), but zero evidence at all. See :func:`silent_test_death`.
+KIND_SILENT = "silent"
 KIND_WORK = "work"
 
 #: HTTP statuses from the Claude API that mean "the provider, not the work".
@@ -353,6 +358,40 @@ def _usage_limit(reset_at_raw: str | None, signal: str) -> FailureClassification
     )
 
 
+def silent_test_death() -> FailureClassification:
+    """#3705: classification for a Test-stage worker that died reporting
+    literally nothing — no usage-limit/API/network/infra signal and no
+    ``failure_reason`` text at all for :func:`classify_failure` to have
+    scanned in the first place (a dead agent, a killed process group, a
+    terminal API error with the summary itself lost — the #1605 class).
+
+    Deliberately **not** a branch inside :func:`classify_failure`: that
+    function's "everything else is WORK, including no evidence" rule is
+    correct for a failure that has *some* terminal text which simply didn't
+    match an environmental pattern (that IS a real, if unrecognized, work
+    failure with diagnostic content worth handing a fix worker). This is
+    the narrower case of *zero* content — nothing to classify, let alone
+    hand to a fix worker — which only
+    :func:`coord.reconcile.propagate_smoke_terminal_failure` can tell apart
+    from the ordinary case (it alone sees whether ``failure_reason`` itself
+    was ever populated). Classified ``ENVIRONMENTAL`` so it gets the same
+    bounded clear-and-retry-then-park treatment as a usage limit or network
+    drop — a silent death is no more evidence of a code defect than either
+    of those, and parking (never a blind ``coord fix``) is the correct
+    escalation once the shared retry budget is exhausted.
+    """
+    return FailureClassification(
+        failure_class=ENVIRONMENTAL,
+        kind=KIND_SILENT,
+        reason=(
+            "environmental (silent #1605 death): the Test-stage worker "
+            "died without recording any reason — no usage-limit, API, "
+            "network, or infra signal, and no terminal output at all"
+        ),
+        signal=None,
+    )
+
+
 def _reset_at_from_reason(reason: str | None) -> str | None:
     """Pull the raw reset string back out of a stamped ``failure_reason``."""
     if not is_usage_limit_reason(reason):

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/coord/notify.py

@@ -4623,17 +4623,26 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
                 # can protect a still-live/already-passed sibling partition
                 # from a false aggregate failure instead of folding this
                 # leg's cancellation straight into the parent's verdict.
+                # #3705: `exit_code` is the deciding evidence for the
+                # silent-death branch — a leg that actually ran and exited
+                # non-zero is a genuine work failure even with no classified
+                # reason text, while a leg whose process left no exit status
+                # at all is the #1605 class that gets a bounded retry. Same
+                # forwarding as `coord.reconcile`'s own call site, so both
+                # surfaces answer "silent or genuine?" identically.
                 propagate_smoke_terminal_failure(
                     parent_assignment_id=transition.assignment_id,
                     failure_reason=_failure_reason,
                     fanout_parent_id=parent_id,
                     operator_cancelled=entry.get("status") == "cancelled",
+                    exit_code=transition.exit_code,
                 )
                 finalize_smoke_fanout(parent_id)
             else:
                 propagate_smoke_terminal_failure(
                     parent_assignment_id=parent_id,
                     failure_reason=_failure_reason,
+                    exit_code=transition.exit_code,
                 )
     elif transition.event == EVENT_COMPLETION:
         # #2188: a `deliverable:analysis` issue that legitimately ended with

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/coord/reconcile.py

@@ -590,6 +590,7 @@ def reconcile_completed_assignments(
             propagate_smoke_terminal_failure(
                 parent_assignment_id=a.review_of_assignment_id,
                 failure_reason=_failure_reason,
+                exit_code=entry.get("exit_code"),
             )
 
         # #666 Gap A: best-effort cost/token capture from the agent completed
@@ -940,9 +941,14 @@ def _environmental_cause_phrase(classification: "FailureClassification") -> str:
         KIND_API_ERROR,
         KIND_INFRA,
         KIND_NETWORK,
+        KIND_SILENT,
         KIND_USAGE_LIMIT,
     )
 
+    if classification.kind == KIND_SILENT:
+        # #3705: a Test-stage worker that died reporting nothing at all —
+        # not a provider signal, just no diagnostic to hand anyone.
+        return "a Test-stage worker repeatedly dying with no reason recorded (#1605)"
     if classification.kind == KIND_USAGE_LIMIT:
         return "an exhausted account usage limit"
     if classification.kind == KIND_API_ERROR:
@@ -969,6 +975,7 @@ def propagate_smoke_terminal_failure(
     environmental: bool | None = None,
     fanout_parent_id: str | None = None,
     operator_cancelled: bool = False,
+    exit_code: int | None = None,
 ) -> None:
     """#1605: resolve a work row's ``test_state`` when its Test-stage
     (``type="smoke"``) child dies without ever reporting pass/fail.
@@ -1036,6 +1043,30 @@ def propagate_smoke_terminal_failure(
       ``test_state="failed"`` exactly like a normal non-zero-exit smoke
       completion already does (`coord/notify.py`'s completion handler), so
       the existing bounded `coord fix` loop picks it up from there.
+    * **silent** (#3705: *failure_reason* itself is empty — no usage-limit,
+      API, network, or infra token to classify, because there is no text at
+      all) — this is the #1605 class the module docstring above describes,
+      and it is treated like **environmental**, not **work**: there is
+      nothing for a `coord fix` worker to act on, so dispatching one only
+      adds a full Work→Test→Review cycle onto a row whose original Work may
+      already be approved, for zero actionable content. Reclassified via
+      :func:`coord.failure_class.silent_test_death` and folded into the same
+      bounded clear-and-retry-then-park machinery as a genuine environmental
+      death, sharing its budget and tally. Deliberately distinct from
+      **work**'s "no RECOGNIZED signal" case, which still has real
+      diagnostic text worth a fix worker's time and keeps its current
+      ``test_state="failed"`` handling unchanged.
+
+    *exit_code* (#3705) is the deciding evidence for that **silent** branch,
+    and every automatic caller must forward it: the dying worker's own
+    process exit status, when the agent recorded one. A non-zero exit means
+    the worker ran and returned an error — real evidence of a work failure,
+    even with no reason text — so only ``exit_code in {0, None}`` reclassifies
+    as silent. *operator_cancelled* overrides this, since a `coord stop`
+    kills the process group and its exit status reflects the operator's
+    signal rather than the code under test. Leaving *exit_code* unset means
+    "no exit status is known", which is itself the #1605 shape, so a caller
+    that CAN see one and omits it would reclassify genuine failures as silent.
 
     *environmental* (#2275) overrides that classification when the CALLER
     already knows the answer.  Default ``None`` means "classify from
@@ -1134,6 +1165,48 @@ def propagate_smoke_terminal_failure(
     if environmental is None:
         is_environmental = classification.is_environmental
         cause = classification.reason
+        if (
+            not is_environmental
+            and not (failure_reason or "").strip()
+            and (operator_cancelled or exit_code in (0, None))
+        ):
+            # #3705: `classify_failure` correctly calls this WORK — its own
+            # "no evidence at all defaults to WORK" rule — but that rule is
+            # about an UNRECOGNIZED signal, not an ABSENT one. There is a
+            # real difference between "the worker's own terminal text didn't
+            # match any environmental pattern" (real diagnostic content, a
+            # genuine work failure worth a fix worker's time) and "there is
+            # no `failure_reason` text at all" (a dead agent, a killed
+            # process group — the #1605 class this function exists for,
+            # with nothing for a fix worker to act on). Only this caller can
+            # tell the two apart, since only it sees whether
+            # *failure_reason* itself was ever populated.
+            #
+            # The additional *exit_code* guard keeps a non-zero exit code
+            # (e.g. exit_code=1: the `claude -p` process actually ran and
+            # returned an error) as a genuine WORK failure even when the
+            # agent captured no classified reason text — a non-zero exit IS
+            # a signal, just one without a human-readable reason string.
+            # Only `exit_code in {0, None}` qualifies as truly silent.
+            #
+            # *operator_cancelled* overrides that guard: a `coord stop` kills
+            # the worker's process group, so its exit status reports the
+            # OPERATOR'S signal, not a verdict on the code under test. Every
+            # cancellation is therefore silent by construction, whatever exit
+            # code the kill happened to leave behind — the same reasoning as
+            # the sibling-protection branch above, applied to a solo leg that
+            # has no live sibling left to protect.
+            # Treat all of the above like an environmental death: bounded
+            # clear-and-retry of the Test stage, parking (never a blind
+            # `coord fix`) once the shared #3315 budget is exhausted —
+            # instead of ever recording a `test_state="failed"` work verdict
+            # with a synthetic placeholder reason and no actual failure
+            # behind it.
+            from coord.failure_class import silent_test_death  # noqa: PLC0415
+
+            classification = silent_test_death()
+            is_environmental = True
+            cause = classification.reason
     else:
         is_environmental = bool(environmental)
         cause = failure_reason or classification.reason

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/coord/state.py

@@ -4587,6 +4587,51 @@ def load_assignment_test_reason(assignment_id: str) -> str | None:
     return row["test_reason"] if hasattr(row, "keys") else row[0]
 
 
+def load_assignment_exit_code(assignment_id: str) -> int | None:
+    """#3705: the recorded process ``exit_code`` for one assignment.
+
+    The single-row read that lets a caller holding only an
+    :class:`coord.models.Assignment` (whose projection carries no
+    ``exit_code``) answer "did this worker actually run and return an error?"
+    — the deciding evidence
+    :func:`coord.reconcile.propagate_smoke_terminal_failure` needs to tell a
+    genuine work failure from a silent #1605 death.
+
+    Same daemon-first, local-fallback routing as
+    :func:`load_assignment_test_reason`. Returns ``None`` when the row is
+    absent, the column is NULL (the agent recorded no exit status), or a
+    remote read failed — all three mean "no exit status I can see", which is
+    itself the silent shape, so callers must treat it as absence of evidence
+    rather than as a successful exit.
+    """
+    if not assignment_id:
+        return None
+    svc = _board_service()
+    if svc is not None:
+        try:
+            from coord.client import fetch_assignment  # noqa: PLC0415
+
+            row = fetch_assignment(svc, assignment_id)
+            if row is not None:
+                code = row.get("exit_code")
+                return int(code) if code is not None else None
+            return None
+        except Exception:  # noqa: BLE001 — degraded fallback, never blocking
+            return None
+    try:
+        conn = get_connection()
+        row = sql.execute(conn,
+            "SELECT exit_code FROM assignments WHERE assignment_id=?",
+            (assignment_id,),
+        ).fetchone()
+    except Exception:  # noqa: BLE001
+        return None
+    if row is None:
+        return None
+    code = row["exit_code"] if hasattr(row, "keys") else row[0]
+    return int(code) if code is not None else None
+
+
 def load_assignment_test_state(assignment_id: str) -> str | None:
     """#2244: the current ``test_state`` for one assignment.
 

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/docs/COST_DISCIPLINE.md

@@ -41,6 +41,15 @@ Minimize direct code work in the coordinator — instead, write a good briefing
 - **Catch platform violations at review time.** The adversarial reviewer should check for
   platform-specific code in shared/cross-platform paths. Catching after merge costs an entire
   round-trip.
+- **One backend per issue for multi-backend repos (quadraui, vimcode).** A cross-backend
+  feature becomes a **seam issue** (shared trait methods + one headless backend, typically TUI)
+  plus **one issue per backend** (GTK, macOS, Windows). The seam issue touches only
+  `backend.rs`, `testing/`, the TUI painter, and `todo!()`-style stubs in the other backends
+  — never real painters for GTK/macOS/win. Each backend issue is verified only on its own
+  host. Filing a single issue that spans all backends triggers the full smoke fanout matrix,
+  balloons scope past 6 files, and has burned 3+ fix rounds without landing (quadraui#1539,
+  2026-10-14; quadraui#1476, 2026-10-10). **Check the target repo's CLAUDE.md before filing**
+  — quadraui's encodes this rule.
 
 ## Operator sessions: dispatch, don't do
 

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/tests/test_base_checkout_restore.py

@@ -308,6 +308,90 @@ def test_the_collision_retry_for_a_real_linked_worktree_still_works(
     assert _current_branch(base) == "main", "the base was moved for no reason"
 
 
+# ── #3704: git's *other* collision message — "a branch named '<branch>' ──────
+# already exists" — raised by the plain ``-b`` form whenever the branch ref
+# exists at all, checked out anywhere or not.  A retried smoke-fix/test-fix
+# dispatch picks the same branch name as its failed predecessor, so if that
+# predecessor's worktree was already torn down (which never deletes the
+# branch), the retry hits this exact message instead of "already used by
+# worktree at ...".  All three sub-cases below funnel into the identical
+# recovery machinery above; the branch ref is deleted once nothing has it
+# checked out, since `-b` always means "I want a fresh branch here".
+
+
+def test_branch_exists_but_checked_out_nowhere_is_freed_and_retried(
+    repo_with_remote: Path, tmp_path: Path
+) -> None:
+    """The common case: a prior attempt's worktree was cleaned up, but `git
+    worktree remove` never deletes the branch it held — so the stale ref is
+    all that is left to collide with the retry."""
+    base = repo_with_remote
+    stale = tmp_path / "stale"
+    _run(base, "worktree", "add", "-b", "issue-3704-stale", str(stale))
+    _run(base, "worktree", "remove", str(stale))
+    assert _run(base, "branch", "--list", "issue-3704-stale"), "branch should linger"
+
+    log = tmp_path / "worker.log"
+    log.write_text("")
+    new_wt = tmp_path / "new-wt"
+    _git_worktree_add(
+        base,
+        ["-b", "issue-3704-stale", str(new_wt)],
+        log_path=str(log),
+    )
+
+    assert new_wt.exists(), "the worktree add did not succeed after the remedy"
+    assert _current_branch(new_wt) == "issue-3704-stale"
+    assert "not checked out in any worktree" in log.read_text()
+
+
+def test_branch_exists_in_a_linked_worktree_is_evicted_and_retried(
+    repo_with_remote: Path, tmp_path: Path
+) -> None:
+    """The branch is live in a linked worktree — evict it, same as #460/#1693,
+    then delete the now-unchecked-out ref so the `-b` retry can recreate it."""
+    base = repo_with_remote
+    linked = tmp_path / "linked"
+    _run(base, "worktree", "add", "-b", "issue-3704-linked", str(linked))
+
+    new_wt = tmp_path / "new-wt"
+    _git_worktree_add(
+        base,
+        ["-b", "issue-3704-linked", str(new_wt)],
+    )
+
+    assert new_wt.exists(), "the worktree add did not succeed after the remedy"
+    assert not linked.exists(), "the stale linked worktree should have been evicted"
+    assert _current_branch(new_wt) == "issue-3704-linked"
+
+
+def test_branch_exists_in_the_base_checkout_is_restored_and_retried(
+    repo_with_remote: Path, tmp_path: Path
+) -> None:
+    """The branch is checked out in the *base* checkout itself — move the base
+    off it non-destructively (#1694), then delete the ref it leaves behind so
+    the `-b` retry can recreate it fresh."""
+    base = repo_with_remote
+    _park(base, "issue-3704-parked")
+    log = tmp_path / "worker.log"
+    log.write_text("")
+
+    new_wt = tmp_path / "new-wt"
+    _git_worktree_add(
+        base,
+        ["-b", "issue-3704-parked", str(new_wt)],
+        log_path=str(log),
+        default_branch="main",
+    )
+
+    assert new_wt.exists(), "the worktree add did not succeed after the remedy"
+    assert _current_branch(base) == "main", "base was not moved to the default branch"
+    assert _current_branch(new_wt) == "issue-3704-parked"
+    text = log.read_text()
+    assert "base checkout was parked on 'issue-3704-parked'" in text, text
+    assert "moved it to main" in text, text
+
+
 # ── The helper's own contract ───────────────────────────────────────────────
 
 

{code_coordinator-0.5.642 → code_coordinator-0.5.644}/tests/test_diagnose.py

@@ -1712,10 +1712,9 @@ def test_stuck_test_state_with_terminal_smoke_child_is_recovered(monkeypatch, co
     calls: list[dict] = []
     monkeypatch.setattr(
         "coord.reconcile.propagate_smoke_terminal_failure",
-        lambda *, parent_assignment_id, failure_reason: calls.append(
-            {"parent_assignment_id": parent_assignment_id, "failure_reason": failure_reason}
-        ),
+        lambda **kw: calls.append(kw),
     )
+    monkeypatch.setattr("coord.state.load_assignment_exit_code", lambda aid: None)
     work = _assign(aid="w1", typ="work", status="done")
     work.test_state = "running"
     smoke = _assign(
@@ -1728,12 +1727,75 @@ def test_stuck_test_state_with_terminal_smoke_child_is_recovered(monkeypatch, co
 
     assert any("test_state='running'" in f and "s1" in f for f in res.findings)
     assert calls == [
-        {"parent_assignment_id": "w1", "failure_reason": "api_error: aborted_streaming"}
+        {
+            "parent_assignment_id": "w1",
+            "failure_reason": "api_error: aborted_streaming",
+            "operator_cancelled": False,
+            "exit_code": None,
+        }
     ]
     assert any("resolved stuck test_state" in a for a in res.actions_taken)
     assert res.recovered is True
 
 
+def test_stuck_test_state_forwards_the_smoke_child_exit_code(monkeypatch, config) -> None:
+    """#3705: a smoke child that ran and exited non-zero is a genuine work
+    failure even with no reason text recorded, so the repair must forward the
+    child's own exit status — the board projection does not carry it, and
+    omitting it would reclassify the failure as a silent #1605 death and earn
+    it a bounded Test-stage retry instead."""
+    _stub(monkeypatch, session="dead")
+    calls: list[dict] = []
+    monkeypatch.setattr(
+        "coord.reconcile.propagate_smoke_terminal_failure",
+        lambda **kw: calls.append(kw),
+    )
+    monkeypatch.setattr(
+        "coord.state.load_assignment_exit_code",
+        lambda aid: 1 if aid == "s1" else None,
+    )
+    work = _assign(aid="w1", typ="work", status="done")
+    work.test_state = "running"
+    smoke = _assign(aid="s1", typ="smoke", status="failed", review_of="w1")
+    board = Board(completed=[work, smoke])
+
+    diagnose.diagnose_stage(board, config, "api", 42, "test")
+
+    assert calls and calls[0]["exit_code"] == 1, (
+        "the smoke child's recorded exit status must reach "
+        f"propagate_smoke_terminal_failure — got {calls!r}"
+    )
+    assert calls[0]["operator_cancelled"] is False
+
+
+def test_stuck_test_state_marks_a_cancelled_smoke_child_operator_cancelled(
+    monkeypatch, config
+) -> None:
+    """#3705/#3333: an operator `coord stop` leaves the smoke row `cancelled`
+    and its exit status is the kill signal, not a verdict on the code under
+    test — so the repair must flag the cancellation and keep the clear-and-retry
+    treatment rather than letting the signal's exit code read as a work
+    failure."""
+    _stub(monkeypatch, session="dead")
+    calls: list[dict] = []
+    monkeypatch.setattr(
+        "coord.reconcile.propagate_smoke_terminal_failure",
+        lambda **kw: calls.append(kw),
+    )
+    monkeypatch.setattr("coord.state.load_assignment_exit_code", lambda aid: -15)
+    work = _assign(aid="w1", typ="work", status="done")
+    work.test_state = "running"
+    smoke = _assign(aid="s1", typ="smoke", status="cancelled", review_of="w1")
+    board = Board(completed=[work, smoke])
+
+    diagnose.diagnose_stage(board, config, "api", 42, "test")
+
+    assert calls and calls[0]["operator_cancelled"] is True, (
+        f"a cancelled smoke child must be reported as operator-cancelled — got {calls!r}"
+    )
+    assert calls[0]["exit_code"] == -15
+
+
 def test_stuck_test_state_dry_run_reports_without_writing(monkeypatch, config) -> None:
     _stub(monkeypatch, session="dead")