code-coordinator 0.5.641__tar.gz → 0.5.643__tar.gz

{code_coordinator-0.5.641 → code_coordinator-0.5.643}/PKG-INFO

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.643",
+  "distance": 0,
+  "node": "g5cc36b9db469d261fca9cd362e96e6ed99820ccc",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-15"
+}

{code_coordinator-0.5.641 → code_coordinator-0.5.643}/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.641 → code_coordinator-0.5.643}/coord/reports.py

@@ -5470,12 +5470,23 @@ def _xlsx_cell(value: Any, meta: Mapping[str, Any] | None = None) -> Any:
 _XLSX_FIXED_STAMP = datetime(1980, 1, 1, 0, 0, 0)
 
 
+_XLSX_FIXED_STAMP_ISO = "1980-01-01T00:00:00Z"
+
+# ISO 8601 datetime pattern used by openpyxl in docProps/core.xml.
+_ISO_DATETIME_RE = re.compile(
+    rb"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z"
+)
+
+
 def _zero_xlsx_zip_timestamps(data: bytes) -> bytes:
     """Rewrite every zip entry's `date_time` in a saved `.xlsx` to the fixed
-    stamp, leaving contents untouched. `openpyxl` has no option to pin this
-    itself, so it has to be done as a post-processing pass over the bytes
-    it produced (#3500)."""
+    stamp, and normalise timestamps embedded in ``docProps/core.xml``.
+
+    openpyxl ignores a pinned ``wb.properties.modified`` and writes
+    ``datetime.now()`` at save time, so the zip-entry rewrite alone is not
+    sufficient — the XML content itself must be normalised too (#3500)."""
     stamp = _XLSX_FIXED_STAMP.timetuple()[:6]
+    fixed_iso = _XLSX_FIXED_STAMP_ISO.encode()
     src = io.BytesIO(data)
     dst = io.BytesIO()
     with (
@@ -5484,6 +5495,8 @@ def _zero_xlsx_zip_timestamps(data: bytes) -> bytes:
     ):
         for item in zin.infolist():
             payload = zin.read(item.filename)
+            if item.filename == "docProps/core.xml":
+                payload = _ISO_DATETIME_RE.sub(fixed_iso, payload)
             info = zipfile.ZipInfo(item.filename, date_time=stamp)
             info.compress_type = item.compress_type
             info.external_attr = item.external_attr

{code_coordinator-0.5.641 → code_coordinator-0.5.643}/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.641 → code_coordinator-0.5.643}/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.641 → code_coordinator-0.5.643}/tests/test_reports.py

@@ -3972,27 +3972,18 @@ class TestXlsxSerializer:
         assert result_to_xlsx(result) == result_to_xlsx(result.to_dict())
 
     def test_output_is_byte_identical_even_as_the_save_clock_advances(
-        self, monkeypatch
+        self,
     ) -> None:
-        """#3500: `zipfile.ZipFile.writestr` stamps every entry's
-        `date_time` with `time.localtime(time.time())` *at save*, at
-        one-second resolution — so two saves of the identical report
-        straddling a second boundary used to produce different bytes,
-        exactly the flake observed on PR #2785's CI run. Advance the clock
-        `zipfile` reads from by several seconds between the two calls and
-        assert the output doesn't move."""
+        """#3500: openpyxl writes wall-clock timestamps into both zip entry
+        metadata and ``docProps/core.xml`` at save time.
+        ``_zero_xlsx_zip_timestamps`` normalises both, so two saves of the
+        identical report separated by real wall-clock time must produce
+        byte-identical output without any monkeypatching."""
         pytest.importorskip("openpyxl")
         result = _export_fixture_result()
 
-        base_wall = time.time()
-        clock = {"offset": 0.0}
-        monkeypatch.setattr(
-            "zipfile.time.time", lambda: base_wall + clock["offset"]
-        )
-
         first = result_to_xlsx(result)
-        clock["offset"] += 5.0  # advance the save clock by 5s, well past
-        # the 1s resolution that caused the flake.
+        time.sleep(2)
         second = result_to_xlsx(result)
 
         assert first == second

code_coordinator-0.5.641/code_coordinator.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.5.641",
-  "distance": 0,
-  "node": "gb9ba3c63b73fe5670ec2c1c2f7e746049613a847",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-12"
-}